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 2
40#include <initializer_list>
62#include <forward_list>
68#include <unordered_map>
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)
1264#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1265 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1267#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1268 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
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 JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1289 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1290#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1291 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1292 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1293#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1294 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1295 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1296#elif defined(_Check_return_)
1297 #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1298 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1300 #define JSON_HEDLEY_WARN_UNUSED_RESULT
1301 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
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)
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(...)
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
1888#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1889 #undef JSON_HEDLEY_RETURNS_NON_NULL
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 JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1896#elif defined(_Ret_notnull_)
1897 #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1899 #define JSON_HEDLEY_RETURNS_NON_NULL
1902#if defined(JSON_HEDLEY_ARRAY_PARAM)
1903 #undef JSON_HEDLEY_ARRAY_PARAM
1906 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1907 !defined(__STDC_NO_VLA__) && \
1908 !defined(__cplusplus) && \
1909 !defined(JSON_HEDLEY_PGI_VERSION) && \
1910 !defined(JSON_HEDLEY_TINYC_VERSION)
1911 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1913 #define JSON_HEDLEY_ARRAY_PARAM(name)
1916#if defined(JSON_HEDLEY_IS_CONSTANT)
1917 #undef JSON_HEDLEY_IS_CONSTANT
1919#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1920 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1924#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1925 #undef JSON_HEDLEY_IS_CONSTEXPR_
1928 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1929 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1930 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1931 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1932 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1933 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1934 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1935 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1936 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1937 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1938 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1940#if !defined(__cplusplus)
1942 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1943 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1944 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1945 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1946 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1947 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1948 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1949#if defined(__INTPTR_TYPE__)
1950 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1953 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1957 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1958 !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1959 !defined(JSON_HEDLEY_PGI_VERSION) && \
1960 !defined(JSON_HEDLEY_IAR_VERSION)) || \
1961 (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1962 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1963 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1964 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1965 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1966#if defined(__INTPTR_TYPE__)
1967 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1970 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1973 defined(JSON_HEDLEY_GCC_VERSION) || \
1974 defined(JSON_HEDLEY_INTEL_VERSION) || \
1975 defined(JSON_HEDLEY_TINYC_VERSION) || \
1976 defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1977 JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1978 defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1979 defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1980 defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1981 defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1983# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1987 ((void*) ((expr) * 0L) ) : \
1988((struct { char v[sizeof(void) * 2]; } *) 1) \
1994#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1995 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1996 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1998 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2000 #if !defined(JSON_HEDLEY_IS_CONSTANT)
2001 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2003 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2006#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2007 #undef JSON_HEDLEY_BEGIN_C_DECLS
2009#if defined(JSON_HEDLEY_END_C_DECLS)
2010 #undef JSON_HEDLEY_END_C_DECLS
2012#if defined(JSON_HEDLEY_C_DECL)
2013 #undef JSON_HEDLEY_C_DECL
2015#if defined(__cplusplus)
2016 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2017 #define JSON_HEDLEY_END_C_DECLS }
2018 #define JSON_HEDLEY_C_DECL extern "C"
2020 #define JSON_HEDLEY_BEGIN_C_DECLS
2021 #define JSON_HEDLEY_END_C_DECLS
2022 #define JSON_HEDLEY_C_DECL
2025#if defined(JSON_HEDLEY_STATIC_ASSERT)
2026 #undef JSON_HEDLEY_STATIC_ASSERT
2029 !defined(__cplusplus) && ( \
2030 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2031 (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2032 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2033 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2034 defined(_Static_assert) \
2036# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2038 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2039 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2040 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2041# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2043# define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2046#if defined(JSON_HEDLEY_NULL)
2047 #undef JSON_HEDLEY_NULL
2049#if defined(__cplusplus)
2050 #if __cplusplus >= 201103L
2051 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2053 #define JSON_HEDLEY_NULL NULL
2055 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2058 #define JSON_HEDLEY_NULL NULL
2060 #define JSON_HEDLEY_NULL ((void*) 0)
2063#if defined(JSON_HEDLEY_MESSAGE)
2064 #undef JSON_HEDLEY_MESSAGE
2066#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2067# define JSON_HEDLEY_MESSAGE(msg) \
2068 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2069 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2070 JSON_HEDLEY_PRAGMA(message msg) \
2071 JSON_HEDLEY_DIAGNOSTIC_POP
2073 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2074 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2075# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2076#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2077# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2078#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2079# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2080#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2081# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2083# define JSON_HEDLEY_MESSAGE(msg)
2086#if defined(JSON_HEDLEY_WARNING)
2087 #undef JSON_HEDLEY_WARNING
2089#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2090# define JSON_HEDLEY_WARNING(msg) \
2091 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2092 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2093 JSON_HEDLEY_PRAGMA(clang warning msg) \
2094 JSON_HEDLEY_DIAGNOSTIC_POP
2096 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2097 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2098 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2099# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2101 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2102 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2103# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2105# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2108#if defined(JSON_HEDLEY_REQUIRE)
2109 #undef JSON_HEDLEY_REQUIRE
2111#if defined(JSON_HEDLEY_REQUIRE_MSG)
2112 #undef JSON_HEDLEY_REQUIRE_MSG
2114#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2115# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2116# define JSON_HEDLEY_REQUIRE(expr) \
2117 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2118 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2119 __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2120 JSON_HEDLEY_DIAGNOSTIC_POP
2121# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2122 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2123 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2124 __attribute__((diagnose_if(!(expr), msg, "error"))) \
2125 JSON_HEDLEY_DIAGNOSTIC_POP
2127# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2128# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2131# define JSON_HEDLEY_REQUIRE(expr)
2132# define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2135#if defined(JSON_HEDLEY_FLAGS)
2136 #undef JSON_HEDLEY_FLAGS
2138#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2139 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2141 #define JSON_HEDLEY_FLAGS
2144#if defined(JSON_HEDLEY_FLAGS_CAST)
2145 #undef JSON_HEDLEY_FLAGS_CAST
2147#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2148# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2149 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2150 _Pragma("warning(disable:188)") \
2152 JSON_HEDLEY_DIAGNOSTIC_POP \
2155# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2158#if defined(JSON_HEDLEY_EMPTY_BASES)
2159 #undef JSON_HEDLEY_EMPTY_BASES
2162 (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2163 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2164 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2166 #define JSON_HEDLEY_EMPTY_BASES
2171#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2172 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2174#if defined(__clang__)
2175 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2177 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2180#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2181 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2183#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2185#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2186 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2188#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2190#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2191 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2193#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2195#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2196 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2198#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2200#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2201 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2203#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2205#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2206 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2208#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2210#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2211 #undef JSON_HEDLEY_CLANG_HAS_WARNING
2213#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2222#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2223 #if defined(__clang__)
2224 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2225 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2227 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2228 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2229 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2236#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2237 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2238 #define JSON_HAS_CPP_20
2239 #define JSON_HAS_CPP_17
2240 #define JSON_HAS_CPP_14
2241 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
2242 #define JSON_HAS_CPP_17
2243 #define JSON_HAS_CPP_14
2244 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2245 #define JSON_HAS_CPP_14
2248 #define JSON_HAS_CPP_11
2252#if defined(__clang__)
2253 #pragma clang diagnostic push
2254 #pragma clang diagnostic ignored "-Wdocumentation"
2255 #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2259#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2260 #define JSON_THROW(exception) throw exception
2261 #define JSON_TRY try
2262 #define JSON_CATCH(exception) catch(exception)
2263 #define JSON_INTERNAL_CATCH(exception) catch(exception)
2266 #define JSON_THROW(exception) std::abort()
2267 #define JSON_TRY if(true)
2268 #define JSON_CATCH(exception) if(false)
2269 #define JSON_INTERNAL_CATCH(exception) if(false)
2273#if defined(JSON_THROW_USER)
2275 #define JSON_THROW JSON_THROW_USER
2277#if defined(JSON_TRY_USER)
2279 #define JSON_TRY JSON_TRY_USER
2281#if defined(JSON_CATCH_USER)
2283 #define JSON_CATCH JSON_CATCH_USER
2284 #undef JSON_INTERNAL_CATCH
2285 #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2287#if defined(JSON_INTERNAL_CATCH_USER)
2288 #undef JSON_INTERNAL_CATCH
2289 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2293#if !defined(JSON_ASSERT)
2295 #define JSON_ASSERT(x) assert(x)
2299#if defined(JSON_TESTS_PRIVATE)
2300 #define JSON_PRIVATE_UNLESS_TESTED public
2302 #define JSON_PRIVATE_UNLESS_TESTED private
2310#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2311 template<typename BasicJsonType> \
2312 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2314 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2315 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2316 auto it = std::find_if(std::begin(m), std::end(m), \
2317 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2319 return ej_pair.first == e; \
2321 j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2323 template<typename BasicJsonType> \
2324 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2326 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2327 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2328 auto it = std::find_if(std::begin(m), std::end(m), \
2329 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2331 return ej_pair.second == j; \
2333 e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2339#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2340 template<template<typename, typename, typename...> class ObjectType, \
2341 template<typename, typename...> class ArrayType, \
2342 class StringType, class BooleanType, class NumberIntegerType, \
2343 class NumberUnsignedType, class NumberFloatType, \
2344 template<typename> class AllocatorType, \
2345 template<typename, typename = void> class JSONSerializer, \
2348#define NLOHMANN_BASIC_JSON_TPL \
2349 basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2350 NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2351 AllocatorType, JSONSerializer, BinaryType>
2355#define NLOHMANN_JSON_EXPAND( x ) x
2356#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
2357#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2358 NLOHMANN_JSON_PASTE64, \
2359 NLOHMANN_JSON_PASTE63, \
2360 NLOHMANN_JSON_PASTE62, \
2361 NLOHMANN_JSON_PASTE61, \
2362 NLOHMANN_JSON_PASTE60, \
2363 NLOHMANN_JSON_PASTE59, \
2364 NLOHMANN_JSON_PASTE58, \
2365 NLOHMANN_JSON_PASTE57, \
2366 NLOHMANN_JSON_PASTE56, \
2367 NLOHMANN_JSON_PASTE55, \
2368 NLOHMANN_JSON_PASTE54, \
2369 NLOHMANN_JSON_PASTE53, \
2370 NLOHMANN_JSON_PASTE52, \
2371 NLOHMANN_JSON_PASTE51, \
2372 NLOHMANN_JSON_PASTE50, \
2373 NLOHMANN_JSON_PASTE49, \
2374 NLOHMANN_JSON_PASTE48, \
2375 NLOHMANN_JSON_PASTE47, \
2376 NLOHMANN_JSON_PASTE46, \
2377 NLOHMANN_JSON_PASTE45, \
2378 NLOHMANN_JSON_PASTE44, \
2379 NLOHMANN_JSON_PASTE43, \
2380 NLOHMANN_JSON_PASTE42, \
2381 NLOHMANN_JSON_PASTE41, \
2382 NLOHMANN_JSON_PASTE40, \
2383 NLOHMANN_JSON_PASTE39, \
2384 NLOHMANN_JSON_PASTE38, \
2385 NLOHMANN_JSON_PASTE37, \
2386 NLOHMANN_JSON_PASTE36, \
2387 NLOHMANN_JSON_PASTE35, \
2388 NLOHMANN_JSON_PASTE34, \
2389 NLOHMANN_JSON_PASTE33, \
2390 NLOHMANN_JSON_PASTE32, \
2391 NLOHMANN_JSON_PASTE31, \
2392 NLOHMANN_JSON_PASTE30, \
2393 NLOHMANN_JSON_PASTE29, \
2394 NLOHMANN_JSON_PASTE28, \
2395 NLOHMANN_JSON_PASTE27, \
2396 NLOHMANN_JSON_PASTE26, \
2397 NLOHMANN_JSON_PASTE25, \
2398 NLOHMANN_JSON_PASTE24, \
2399 NLOHMANN_JSON_PASTE23, \
2400 NLOHMANN_JSON_PASTE22, \
2401 NLOHMANN_JSON_PASTE21, \
2402 NLOHMANN_JSON_PASTE20, \
2403 NLOHMANN_JSON_PASTE19, \
2404 NLOHMANN_JSON_PASTE18, \
2405 NLOHMANN_JSON_PASTE17, \
2406 NLOHMANN_JSON_PASTE16, \
2407 NLOHMANN_JSON_PASTE15, \
2408 NLOHMANN_JSON_PASTE14, \
2409 NLOHMANN_JSON_PASTE13, \
2410 NLOHMANN_JSON_PASTE12, \
2411 NLOHMANN_JSON_PASTE11, \
2412 NLOHMANN_JSON_PASTE10, \
2413 NLOHMANN_JSON_PASTE9, \
2414 NLOHMANN_JSON_PASTE8, \
2415 NLOHMANN_JSON_PASTE7, \
2416 NLOHMANN_JSON_PASTE6, \
2417 NLOHMANN_JSON_PASTE5, \
2418 NLOHMANN_JSON_PASTE4, \
2419 NLOHMANN_JSON_PASTE3, \
2420 NLOHMANN_JSON_PASTE2, \
2421 NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2422#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2423#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2424#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2425#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2426#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2427#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
2428#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
2429#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
2430#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
2431#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
2432#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
2433#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
2434#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
2435#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
2436#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
2437#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
2438#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
2439#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
2440#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
2441#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
2442#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
2443#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
2444#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
2445#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
2446#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
2447#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
2448#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
2449#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
2450#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
2451#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
2452#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
2453#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
2454#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
2455#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
2456#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
2457#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
2458#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
2459#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
2460#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
2461#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
2462#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
2463#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
2464#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
2465#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
2466#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
2467#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
2468#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
2469#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
2470#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
2471#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
2472#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
2473#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
2474#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
2475#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
2476#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
2477#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
2478#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
2479#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
2480#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
2481#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
2482#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
2483#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
2484#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
2486#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2487#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2494#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2495 friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2496 friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2503#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2504 inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2505 inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2507#ifndef JSON_USE_IMPLICIT_CONVERSIONS
2508 #define JSON_USE_IMPLICIT_CONVERSIONS 1
2511#if JSON_USE_IMPLICIT_CONVERSIONS
2512 #define JSON_EXPLICIT
2514 #define JSON_EXPLICIT explicit
2517#ifndef JSON_DIAGNOSTICS
2518 #define JSON_DIAGNOSTICS 0
2541 const std::string& t)
2544 for (
auto pos = s.find(f);
2545 pos != std::string::npos;
2546 s.replace(pos, f.size(), t),
2547 pos = s.find(f, pos + t.size()))
2601 constexpr operator size_t()
const
2653 const char*
what() const noexcept
override
2663 exception(
int id_, const
char* what_arg) :
id(id_),
m(what_arg) {}
2665 static std::string
name(
const std::string& ename,
int id_)
2667 return "[json.exception." + ename +
"." + std::to_string(id_) +
"] ";
2670 template<
typename BasicJsonType>
2674 std::vector<std::string> tokens;
2675 for (
const auto* current = &leaf_element; current->m_parent !=
nullptr; current = current->m_parent)
2677 switch (current->m_parent->type())
2681 for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
2683 if (¤t->m_parent->m_value.array->operator[](i) == current)
2685 tokens.emplace_back(std::to_string(i));
2694 for (
const auto& element : *current->m_parent->m_value.object)
2696 if (&element.second == current)
2698 tokens.emplace_back(element.first.c_str());
2723 return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
2724 [](
const std::string & a,
const std::string & b)
2726 return a +
"/" + detail::escape(b);
2729 static_cast<void>(leaf_element);
2736 std::runtime_error
m;
2796 template<
typename BasicJsonType>
2804 template<
typename BasicJsonType>
2805 static parse_error create(
int id_, std::size_t byte_,
const std::string& what_arg,
const BasicJsonType& context)
2808 (byte_ != 0 ? (
" at byte " + std::to_string(byte_)) :
"") +
2830 return " at line " + std::to_string(pos.
lines_read + 1) +
2875 template<
typename BasicJsonType>
2930 template<
typename BasicJsonType>
2978 template<
typename BasicJsonType>
3017 template<
typename BasicJsonType>
3037#include <type_traits>
3049using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3051#ifdef JSON_HAS_CPP_14
3054using std::enable_if_t;
3055using std::index_sequence;
3056using std::make_index_sequence;
3057using std::index_sequence_for;
3062template<
bool B,
typename T =
void>
3089template <
typename T, T... Ints>
3093 static constexpr std::size_t
size() noexcept
3095 return sizeof...(Ints);
3104template <
size_t... Ints>
3107namespace utility_internal
3110template <
typename Seq,
size_t SeqSize,
size_t Rem>
3114template <
typename T, T... Ints,
size_t SeqSize>
3120template <
typename T, T... Ints,
size_t SeqSize>
3128template <
typename T,
size_t N>
3135template <
typename T>
3150template <
typename T, T N>
3166template <
typename... Ts>
3206#include <type_traits>
3237template<
typename It,
typename =
void>
3240template<
typename It>
3244 typename It::reference, typename It::iterator_category >>
3255template<
typename T,
typename =
void>
3285#include <type_traits>
3305template<
class Default,
3307 template<
class...>
class Op,
3315template<
class Default,
template<
class...>
class Op,
class... Args>
3322template<
template<
class...>
class Op,
class... Args>
3325template<
template<
class...>
class Op,
class... Args>
3328template<
template<
class...>
class Op,
class... Args>
3331template<
class Default,
template<
class...>
class Op,
class... Args>
3334template<
class Default,
template<
class...>
class Op,
class... Args>
3337template<
class Expected,
template<
class...>
class Op,
class... Args>
3340template<
class To,
template<
class...>
class Op,
class... Args>
3342 std::is_convertible<
detected_t<Op, Args...>, To>;
3347#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3348#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3370template<
typename T =
void,
typename SFINAE =
void>
3371struct adl_serializer;
3373template<
template<
typename U,
typename V,
typename... Args>
class ObjectType =
3375 template<
typename U,
typename... Args>
class ArrayType = std::vector,
3376 class StringType = std::string,
class BooleanType = bool,
3377 class NumberIntegerType = std::int64_t,
3378 class NumberUnsignedType = std::uint64_t,
3379 class NumberFloatType = double,
3380 template<
typename U>
class AllocatorType = std::allocator,
3381 template<
typename T,
typename SFINAE =
void>
class JSONSerializer =
3383 class BinaryType = std::vector<std::uint8_t>>
3397template<
typename BasicJsonType>
3410template<
class Key,
class T,
class IgnoredLess,
class Allocator>
3498template<
typename T,
typename... Args>
3501template<
typename T,
typename... Args>
3504template<
typename T,
typename U>
3508template<
typename BasicJsonType,
typename T,
typename =
void>
3515template <
typename BasicJsonType,
typename T>
3521template<
typename BasicJsonType,
typename T>
3524 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3528 const BasicJsonType&, T&>
::value;
3533template<
typename BasicJsonType,
typename T,
typename =
void>
3536template<
typename BasicJsonType,
typename T>
3539 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3548template<
typename BasicJsonType,
typename T,
typename =
void>
3551template<
typename BasicJsonType,
typename T>
3554 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3569template<
class B1,
class... Bn>
3571: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3574template<
class B>
struct negation : std::integral_constant < bool, !B::value > { };
3579template <
typename T>
3582template <
typename T1,
typename T2>
3584 :
conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3586template <
typename T1,
typename T2>
3588 :
conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3590template <
typename... Ts>
3592 :
conjunction<is_default_constructible<Ts>...> {};
3594template <
typename... Ts>
3596 :
conjunction<is_default_constructible<Ts>...> {};
3599template <
typename T,
typename... Args>
3602template <
typename T1,
typename T2>
3605template <
typename T1,
typename T2>
3608template <
typename... Ts>
3611template <
typename... Ts>
3615template<
typename T,
typename =
void>
3637template<
typename T,
typename =
void>
3643template<
typename BasicJsonType,
typename CompatibleObjectType,
3647template<
typename BasicJsonType,
typename CompatibleObjectType>
3649 BasicJsonType, CompatibleObjectType,
3658 typename CompatibleObjectType::key_type>
::value &&
3660 typename CompatibleObjectType::mapped_type>
::value;
3663template<
typename BasicJsonType,
typename CompatibleObjectType>
3667template<
typename BasicJsonType,
typename ConstructibleObjectType,
3671template<
typename BasicJsonType,
typename ConstructibleObjectType>
3673 BasicJsonType, ConstructibleObjectType,
3681 (std::is_move_assignable<ConstructibleObjectType>::value ||
3682 std::is_copy_assignable<ConstructibleObjectType>::value) &&
3684 typename object_t::key_type>
::value &&
3686 typename object_t::mapped_type,
3687 typename ConstructibleObjectType::mapped_type >
::value)) ||
3689 typename ConstructibleObjectType::mapped_type>
::value ||
3692 typename ConstructibleObjectType::mapped_type >
::value);
3695template<
typename BasicJsonType,
typename ConstructibleObjectType>
3698 ConstructibleObjectType> {};
3700template<
typename BasicJsonType,
typename CompatibleStringType,
3704template<
typename BasicJsonType,
typename CompatibleStringType>
3706 BasicJsonType, CompatibleStringType,
3714template<
typename BasicJsonType,
typename ConstructibleStringType>
3718template<
typename BasicJsonType,
typename ConstructibleStringType,
3722template<
typename BasicJsonType,
typename ConstructibleStringType>
3724 BasicJsonType, ConstructibleStringType,
3730 typename BasicJsonType::string_t>
::value;
3733template<
typename BasicJsonType,
typename ConstructibleStringType>
3737template<
typename BasicJsonType,
typename CompatibleArrayType,
typename =
void>
3740template<
typename BasicJsonType,
typename CompatibleArrayType>
3742 BasicJsonType, CompatibleArrayType,
3749 iterator_traits<CompatibleArrayType >>
::value >>
3753 typename CompatibleArrayType::value_type>
::value;
3756template<
typename BasicJsonType,
typename CompatibleArrayType>
3760template<
typename BasicJsonType,
typename ConstructibleArrayType,
typename =
void>
3763template<
typename BasicJsonType,
typename ConstructibleArrayType>
3765 BasicJsonType, ConstructibleArrayType,
3767 typename BasicJsonType::value_type>
::value >>
3768 : std::true_type {};
3770template<
typename BasicJsonType,
typename ConstructibleArrayType>
3772 BasicJsonType, ConstructibleArrayType,
3774 typename BasicJsonType::value_type>
::value&&
3776(std::is_move_assignable<ConstructibleArrayType>::value ||
3777 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3781detected_t<value_type_t, ConstructibleArrayType >>
::value >>
3791 (std::is_same<
typename ConstructibleArrayType::value_type,
3792 typename BasicJsonType::array_t::value_type>
::value ||
3794 typename ConstructibleArrayType::value_type>
::value ||
3796 BasicJsonType,
typename ConstructibleArrayType::value_type >
::value);
3799template<
typename BasicJsonType,
typename ConstructibleArrayType>
3803template<
typename RealIntegerType,
typename CompatibleNumberIntegerType,
3807template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3809 RealIntegerType, CompatibleNumberIntegerType,
3811 std::is_integral<CompatibleNumberIntegerType>
::value&&
3812 !std::is_same<bool, CompatibleNumberIntegerType>
::value >>
3820 CompatibleNumberIntegerType>
::value &&
3821 CompatibleLimits::is_integer &&
3822 RealLimits::is_signed == CompatibleLimits::is_signed;
3825template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3828 CompatibleNumberIntegerType> {};
3830template<
typename BasicJsonType,
typename CompatibleType,
typename =
void>
3833template<
typename BasicJsonType,
typename CompatibleType>
3835 BasicJsonType, CompatibleType,
3842template<
typename BasicJsonType,
typename CompatibleType>
3846template<
typename T1,
typename T2>
3849template<
typename T1,
typename... Args>
3854template <
typename T>
3864 template <
typename C>
static one test(
decltype(&C::capacity) ) ;
3867 enum {
value =
sizeof(test<T>(
nullptr)) ==
sizeof(
char) };
3871template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value,
int > = 0 >
3874 return static_cast<T
>(
value);
3877template<typename T, typename U, enable_if_t<std::is_same<T, U>::value,
int> = 0>
3893template<
typename BasicJsonType>
3894void from_json(
const BasicJsonType& j,
typename std::nullptr_t& n)
3904template <
typename BasicJsonType,
typename ArithmeticType,
3905 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3906 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3910 switch (
static_cast<value_t>(j))
3914 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3919 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3924 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3940template<
typename BasicJsonType>
3941void from_json(
const BasicJsonType& j,
typename BasicJsonType::boolean_t& b)
3947 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3950template<
typename BasicJsonType>
3951void from_json(
const BasicJsonType& j,
typename BasicJsonType::string_t& s)
3957 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3961 typename BasicJsonType,
typename ConstructibleStringType,
3963 is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3964 !std::is_same<
typename BasicJsonType::string_t,
3965 ConstructibleStringType>
::value,
3967void from_json(
const BasicJsonType& j, ConstructibleStringType& s)
3974 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3977template<
typename BasicJsonType>
3978void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_float_t& val)
3983template<
typename BasicJsonType>
3984void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_unsigned_t& val)
3989template<
typename BasicJsonType>
3990void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_integer_t& val)
3995template<
typename BasicJsonType,
typename EnumType,
3996 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
3999 typename std::underlying_type<EnumType>::type val;
4001 e =
static_cast<EnumType
>(val);
4005template<
typename BasicJsonType,
typename T,
typename Allocator,
4006 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
4007void from_json(
const BasicJsonType& j, std::forward_list<T, Allocator>& l)
4014 std::transform(j.rbegin(), j.rend(),
4015 std::front_inserter(l), [](
const BasicJsonType & i)
4017 return i.template get<T>();
4022template<
typename BasicJsonType,
typename T,
4023 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
4031 std::transform(j.begin(), j.end(), std::begin(l),
4032 [](
const BasicJsonType & elem)
4034 return elem.template get<T>();
4038template<
typename BasicJsonType,
typename T, std::
size_t N>
4040->
decltype(j.template get<T>(), void())
4042 for (std::size_t i = 0; i < N; ++i)
4044 arr[i] = j.at(i).template get<T>();
4048template<
typename BasicJsonType>
4051 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
4054template<
typename BasicJsonType,
typename T, std::
size_t N>
4057->
decltype(j.template get<T>(), void())
4059 for (std::size_t i = 0; i < N; ++i)
4061 arr[i] = j.at(i).template get<T>();
4065template<
typename BasicJsonType,
typename ConstructibleArrayType,
4067 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4071 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4072 j.template get<typename ConstructibleArrayType::value_type>(),
4077 ConstructibleArrayType ret;
4078 ret.reserve(j.size());
4079 std::transform(j.begin(), j.end(),
4080 std::inserter(ret, end(ret)), [](
const BasicJsonType & i)
4084 return i.template get<typename ConstructibleArrayType::value_type>();
4086 arr = std::move(ret);
4089template<
typename BasicJsonType,
typename ConstructibleArrayType,
4091 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4098 ConstructibleArrayType ret;
4100 j.begin(), j.end(), std::inserter(ret, end(ret)),
4101 [](
const BasicJsonType & i)
4105 return i.template get<typename ConstructibleArrayType::value_type>();
4107 arr = std::move(ret);
4110template <
typename BasicJsonType,
typename ConstructibleArrayType,
4112 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
4113 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
4114 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4115 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4116 !is_basic_json<ConstructibleArrayType>::value,
4118auto from_json(
const BasicJsonType& j, ConstructibleArrayType& arr)
4120j.template get<typename ConstructibleArrayType::value_type>(),
4131template <
typename BasicJsonType,
typename T, std::size_t... Idx >
4135 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4138template <
typename BasicJsonType,
typename T, std::
size_t N >
4150template<
typename BasicJsonType>
4151void from_json(
const BasicJsonType& j,
typename BasicJsonType::binary_t& bin)
4158 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4161template<
typename BasicJsonType,
typename ConstructibleObjectType,
4162 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value,
int> = 0>
4163void from_json(
const BasicJsonType& j, ConstructibleObjectType& obj)
4170 ConstructibleObjectType ret;
4171 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4172 using value_type =
typename ConstructibleObjectType::value_type;
4174 inner_object->begin(), inner_object->end(),
4175 std::inserter(ret, ret.begin()),
4176 [](
typename BasicJsonType::object_t::value_type
const & p)
4178 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4180 obj = std::move(ret);
4187template <
typename BasicJsonType,
typename ArithmeticType,
4189 std::is_arithmetic<ArithmeticType>::value&&
4190 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4191 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4192 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4193 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4197 switch (
static_cast<value_t>(j))
4201 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4206 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4211 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4216 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4231template<
typename BasicJsonType,
typename... Args, std::size_t... Idx>
4234 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).
template get<Args>()...);
4237template <
typename BasicJsonType,
class A1,
class A2 >
4240 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4241 std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4244template<
typename BasicJsonType,
typename A1,
typename A2>
4250template<
typename BasicJsonType,
typename... Args>
4256template<
typename BasicJsonType,
typename... Args>
4262template<
typename BasicJsonType,
typename TupleRelated>
4271 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4274template <
typename BasicJsonType,
typename Key,
typename Value,
typename Compare,
typename Allocator,
4276 typename BasicJsonType::string_t, Key >
::value >>
4277void from_json(
const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4284 for (
const auto& p : j)
4290 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4294template <
typename BasicJsonType,
typename Key,
typename Value,
typename Hash,
typename KeyEqual,
typename Allocator,
4296 typename BasicJsonType::string_t, Key >
::value >>
4297void from_json(
const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
4304 for (
const auto& p : j)
4310 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4316 template<
typename BasicJsonType,
typename T>
4318 noexcept(
noexcept(
from_json(j, std::forward<T>(val))))
4319 ->
decltype(
from_json(j, std::forward<T>(val)))
4321 return from_json(j, std::forward<T>(val));
4342#include <type_traits>
4365template<
typename string_type>
4369 using std::to_string;
4380 using string_type =
typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().
key() ) >::type >::type;
4431 switch (
anchor.m_object->type())
4463 typename IteratorType::reference
value()
const
4496template<std::
size_t N,
typename IteratorType, enable_if_t<N == 0,
int> = 0>
4504template<std::
size_t N,
typename IteratorType, enable_if_t<N == 1,
int> = 0>
4518#if defined(__clang__)
4520 #pragma clang diagnostic push
4521 #pragma clang diagnostic ignored "-Wmismatched-tags"
4523template<
typename IteratorType>
4525 :
public std::integral_constant<std::size_t, 2> {};
4527template<std::
size_t N,
typename IteratorType>
4532 get<N>(std::declval <
4535#if defined(__clang__)
4536 #pragma clang diagnostic pop
4567 template<
typename BasicJsonType>
4568 static void construct(BasicJsonType& j,
typename BasicJsonType::boolean_t b)
noexcept
4570 j.m_value.destroy(j.m_type);
4573 j.assert_invariant();
4580 template<
typename BasicJsonType>
4581 static void construct(BasicJsonType& j,
const typename BasicJsonType::string_t& s)
4583 j.m_value.destroy(j.m_type);
4586 j.assert_invariant();
4589 template<
typename BasicJsonType>
4590 static void construct(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4592 j.m_value.destroy(j.m_type);
4594 j.m_value = std::move(s);
4595 j.assert_invariant();
4598 template <
typename BasicJsonType,
typename CompatibleStringType,
4599 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4601 static void construct(BasicJsonType& j,
const CompatibleStringType& str)
4603 j.m_value.destroy(j.m_type);
4605 j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4606 j.assert_invariant();
4613 template<
typename BasicJsonType>
4614 static void construct(BasicJsonType& j,
const typename BasicJsonType::binary_t& b)
4616 j.m_value.destroy(j.m_type);
4618 j.m_value =
typename BasicJsonType::binary_t(b);
4619 j.assert_invariant();
4622 template<
typename BasicJsonType>
4623 static void construct(BasicJsonType& j,
typename BasicJsonType::binary_t&& b)
4625 j.m_value.destroy(j.m_type);
4627 j.m_value =
typename BasicJsonType::binary_t(std::move(b));
4628 j.assert_invariant();
4635 template<
typename BasicJsonType>
4636 static void construct(BasicJsonType& j,
typename BasicJsonType::number_float_t val)
noexcept
4638 j.m_value.destroy(j.m_type);
4641 j.assert_invariant();
4648 template<
typename BasicJsonType>
4649 static void construct(BasicJsonType& j,
typename BasicJsonType::number_unsigned_t val)
noexcept
4651 j.m_value.destroy(j.m_type);
4654 j.assert_invariant();
4661 template<
typename BasicJsonType>
4662 static void construct(BasicJsonType& j,
typename BasicJsonType::number_integer_t val)
noexcept
4664 j.m_value.destroy(j.m_type);
4667 j.assert_invariant();
4674 template<
typename BasicJsonType>
4675 static void construct(BasicJsonType& j,
const typename BasicJsonType::array_t& arr)
4677 j.m_value.destroy(j.m_type);
4681 j.assert_invariant();
4684 template<
typename BasicJsonType>
4685 static void construct(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4687 j.m_value.destroy(j.m_type);
4689 j.m_value = std::move(arr);
4691 j.assert_invariant();
4694 template <
typename BasicJsonType,
typename CompatibleArrayType,
4695 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4697 static void construct(BasicJsonType& j,
const CompatibleArrayType& arr)
4702 j.m_value.destroy(j.m_type);
4704 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4706 j.assert_invariant();
4709 template<
typename BasicJsonType>
4710 static void construct(BasicJsonType& j,
const std::vector<bool>& arr)
4712 j.m_value.destroy(j.m_type);
4715 j.m_value.array->reserve(arr.size());
4716 for (
const bool x : arr)
4718 j.m_value.array->push_back(x);
4719 j.set_parent(j.m_value.array->back());
4721 j.assert_invariant();
4724 template<
typename BasicJsonType,
typename T,
4726 static void construct(BasicJsonType& j,
const std::valarray<T>& arr)
4728 j.m_value.destroy(j.m_type);
4731 j.m_value.array->resize(arr.size());
4734 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4737 j.assert_invariant();
4744 template<
typename BasicJsonType>
4745 static void construct(BasicJsonType& j,
const typename BasicJsonType::object_t& obj)
4747 j.m_value.destroy(j.m_type);
4751 j.assert_invariant();
4754 template<
typename BasicJsonType>
4755 static void construct(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4757 j.m_value.destroy(j.m_type);
4759 j.m_value = std::move(obj);
4761 j.assert_invariant();
4764 template <
typename BasicJsonType,
typename CompatibleObjectType,
4765 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value,
int > = 0 >
4766 static void construct(BasicJsonType& j,
const CompatibleObjectType& obj)
4771 j.m_value.destroy(j.m_type);
4773 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4775 j.assert_invariant();
4783template<
typename BasicJsonType,
typename T,
4784 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value,
int> = 0>
4790template<
typename BasicJsonType,
typename CompatibleString,
4791 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value,
int> = 0>
4792void to_json(BasicJsonType& j,
const CompatibleString& s)
4797template<
typename BasicJsonType>
4798void to_json(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4803template<
typename BasicJsonType,
typename FloatType,
4804 enable_if_t<std::is_floating_point<FloatType>::value,
int> = 0>
4805void to_json(BasicJsonType& j, FloatType val)
noexcept
4810template<
typename BasicJsonType,
typename CompatibleNumberUnsignedType,
4811 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value,
int> = 0>
4812void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val)
noexcept
4817template<
typename BasicJsonType,
typename CompatibleNumberIntegerType,
4818 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value,
int> = 0>
4819void to_json(BasicJsonType& j, CompatibleNumberIntegerType val)
noexcept
4824template<
typename BasicJsonType,
typename EnumType,
4825 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
4826void to_json(BasicJsonType& j, EnumType e)
noexcept
4828 using underlying_type =
typename std::underlying_type<EnumType>::type;
4832template<
typename BasicJsonType>
4833void to_json(BasicJsonType& j,
const std::vector<bool>& e)
4838template <
typename BasicJsonType,
typename CompatibleArrayType,
4839 enable_if_t < is_compatible_array_type<BasicJsonType,
4841 !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4842 !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4843 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4844 !is_basic_json<CompatibleArrayType>::value,
4846void to_json(BasicJsonType& j,
const CompatibleArrayType& arr)
4851template<
typename BasicJsonType>
4852void to_json(BasicJsonType& j,
const typename BasicJsonType::binary_t& bin)
4857template<
typename BasicJsonType,
typename T,
4858 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4859void to_json(BasicJsonType& j,
const std::valarray<T>& arr)
4864template<
typename BasicJsonType>
4865void to_json(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4870template <
typename BasicJsonType,
typename CompatibleObjectType,
4871 enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value,
int > = 0 >
4872void to_json(BasicJsonType& j,
const CompatibleObjectType& obj)
4877template<
typename BasicJsonType>
4878void to_json(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4884 typename BasicJsonType,
typename T, std::size_t N,
4885 enable_if_t < !std::is_constructible<
typename BasicJsonType::string_t,
4893template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value,
int > = 0 >
4894void to_json(BasicJsonType& j,
const std::pair<T1, T2>& p)
4896 j = { p.first, p.second };
4900template<
typename BasicJsonType,
typename T,
4901 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>
::value,
int> = 0>
4904 j = { {b.key(), b.value()} };
4907template<
typename BasicJsonType,
typename Tuple, std::size_t... Idx>
4910 j = { std::get<Idx>(t)... };
4913template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value,
int > = 0>
4914void to_json(BasicJsonType& j,
const T& t)
4921 template<
typename BasicJsonType,
typename T>
4922 auto operator()(BasicJsonType& j, T&& val)
const noexcept(
noexcept(
to_json(j, std::forward<T>(val))))
4923 ->
decltype(
to_json(j, std::forward<T>(val)), void())
4925 return to_json(j, std::forward<T>(val));
4947template<
typename ValueType,
typename>
4961 template<
typename BasicJsonType,
typename TargetType = ValueType>
4962 static auto from_json(BasicJsonType && j, TargetType& val)
noexcept(
4963 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4964 ->
decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
4966 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4981 template<
typename BasicJsonType,
typename TargetType = ValueType>
4986 return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
4998 template<
typename BasicJsonType,
typename TargetType = ValueType>
4999 static auto to_json(BasicJsonType& j, TargetType && val)
noexcept(
5000 noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
5001 ->
decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
5003 ::nlohmann::to_json(j, std::forward<TargetType>(val));
5031template<
typename BinaryType>
5072 return !(rhs == *
this);
5190#include <functional>
5203inline std::size_t
combine(std::size_t seed, std::size_t h)
noexcept
5205 seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
5220template<
typename BasicJsonType>
5221std::size_t
hash(
const BasicJsonType& j)
5223 using string_t =
typename BasicJsonType::string_t;
5224 using number_integer_t =
typename BasicJsonType::number_integer_t;
5225 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5226 using number_float_t =
typename BasicJsonType::number_float_t;
5228 const auto type =
static_cast<std::size_t
>(j.type());
5231 case BasicJsonType::value_t::null:
5232 case BasicJsonType::value_t::discarded:
5237 case BasicJsonType::value_t::object:
5239 auto seed =
combine(type, j.size());
5240 for (
const auto& element : j.items())
5242 const auto h = std::hash<string_t> {}(element.key());
5249 case BasicJsonType::value_t::array:
5251 auto seed =
combine(type, j.size());
5252 for (
const auto& element : j)
5259 case BasicJsonType::value_t::string:
5261 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5265 case BasicJsonType::value_t::boolean:
5267 const auto h = std::hash<bool> {}(j.template get<bool>());
5271 case BasicJsonType::value_t::number_integer:
5273 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
5277 case BasicJsonType::value_t::number_unsigned:
5279 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
5283 case BasicJsonType::value_t::number_float:
5285 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
5289 case BasicJsonType::value_t::binary:
5291 auto seed =
combine(type, j.get_binary().size());
5292 const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
5294 seed =
combine(seed,
static_cast<std::size_t
>(j.get_binary().subtype()));
5295 for (
const auto byte : j.get_binary())
5297 seed =
combine(seed, std::hash<std::uint8_t> {}(byte));
5339#include <type_traits>
5387 return std::fgetc(
m_file);
5416 is->clear(
is->rdstate() & std::ios::eofbit);
5421 :
is(&i),
sb(i.rdbuf())
5430 :
is(rhs.is),
sb(rhs.sb)
5441 auto res =
sb->sbumpc();
5445 is->clear(
is->rdstate() | std::ios::eofbit);
5452 std::istream*
is =
nullptr;
5453 std::streambuf*
sb =
nullptr;
5459template<
typename IteratorType>
5463 using char_type =
typename std::iterator_traits<IteratorType>::value_type;
5473 auto result = std::char_traits<char_type>::to_int_type(*
current);
5478 return std::char_traits<char_type>::eof();
5485 template<
typename BaseInputAdapter,
size_t T>
5495template<
typename BaseInputAdapter,
size_t T>
5498template<
typename BaseInputAdapter>
5503 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5504 size_t& utf8_bytes_index,
5505 size_t& utf8_bytes_filled)
5507 utf8_bytes_index = 0;
5511 utf8_bytes[0] = std::char_traits<char>::eof();
5512 utf8_bytes_filled = 1;
5517 const auto wc = input.get_character();
5522 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5523 utf8_bytes_filled = 1;
5525 else if (wc <= 0x7FF)
5527 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
5528 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5529 utf8_bytes_filled = 2;
5531 else if (wc <= 0xFFFF)
5533 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
5534 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5535 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5536 utf8_bytes_filled = 3;
5538 else if (wc <= 0x10FFFF)
5540 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | ((
static_cast<unsigned int>(wc) >> 18u) & 0x07u));
5541 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
5542 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5543 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5544 utf8_bytes_filled = 4;
5549 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5550 utf8_bytes_filled = 1;
5556template<
typename BaseInputAdapter>
5561 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5562 size_t& utf8_bytes_index,
5563 size_t& utf8_bytes_filled)
5565 utf8_bytes_index = 0;
5569 utf8_bytes[0] = std::char_traits<char>::eof();
5570 utf8_bytes_filled = 1;
5575 const auto wc = input.get_character();
5580 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5581 utf8_bytes_filled = 1;
5583 else if (wc <= 0x7FF)
5585 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u)));
5586 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5587 utf8_bytes_filled = 2;
5589 else if (0xD800 > wc || wc >= 0xE000)
5591 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u)));
5592 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5593 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5594 utf8_bytes_filled = 3;
5600 const auto wc2 =
static_cast<unsigned int>(input.get_character());
5601 const auto charcode = 0x10000u + (((
static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
5602 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | (charcode >> 18u));
5603 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 12u) & 0x3Fu));
5604 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 6u) & 0x3Fu));
5605 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (charcode & 0x3Fu));
5606 utf8_bytes_filled = 4;
5610 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5611 utf8_bytes_filled = 1;
5619template<
typename BaseInputAdapter,
typename W
ideCharType>
5633 fill_buffer<sizeof(WideCharType)>();
5655 std::array<std::char_traits<char>::int_type, 4>
utf8_bytes = {{0, 0, 0, 0}};
5664template<
typename IteratorType,
typename Enable =
void>
5668 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5673 return adapter_type(std::move(first), std::move(last));
5687template<
typename IteratorType>
5691 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5702template<
typename IteratorType>
5706 return factory_type::create(first, last);
5713namespace container_input_adapter_factory_impl
5719template<
typename ContainerType,
typename Enable =
void>
5722template<
typename ContainerType>
5724 void_t<decltype(begin(
std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
5736template<
typename ContainerType>
5763template <
typename CharT,
5764 typename std::enable_if <
5765 std::is_pointer<CharT>::value&&
5766 !std::is_array<CharT>::value&&
5767 std::is_integral<typename std::remove_pointer<CharT>::type>
::value&&
5768 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5772 auto length = std::strlen(
reinterpret_cast<const char*
>(b));
5773 const auto* ptr =
reinterpret_cast<const char*
>(b);
5777template<
typename T, std::
size_t N>
5789 template <
typename CharT,
5790 typename std::enable_if <
5791 std::is_pointer<CharT>::value&&
5792 std::is_integral<typename std::remove_pointer<CharT>::type>
::value&&
5793 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5796 : ia(
reinterpret_cast<const char*
>(b),
reinterpret_cast<const char*
>(b) + l) {}
5798 template<
class IteratorType,
5799 typename std::enable_if<
5800 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>
::value,
5807 return std::move(ia);
5840template<
typename BasicJsonType>
5944 const std::string& last_token,
5971template<
typename BasicJsonType>
5987 : root(r), allow_exceptions(allow_exceptions_)
5999 handle_value(
nullptr);
6035 handle_value(std::move(val));
6041 ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
6045 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6054 object_element = &(ref_stack.back()->m_value.object->operator[](val));
6060 ref_stack.back()->set_parents();
6061 ref_stack.pop_back();
6067 ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
6071 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6079 ref_stack.back()->set_parents();
6080 ref_stack.pop_back();
6084 template<
class Exception>
6086 const Exception& ex)
6089 static_cast<void>(ex);
6090 if (allow_exceptions)
6109 template<
typename Value>
6113 if (ref_stack.empty())
6115 root = BasicJsonType(std::forward<Value>(v));
6119 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6121 if (ref_stack.back()->is_array())
6123 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6124 return &(ref_stack.back()->m_value.array->back());
6129 *object_element = BasicJsonType(std::forward<Value>(v));
6130 return object_element;
6136 std::vector<BasicJsonType*> ref_stack {};
6138 BasicJsonType* object_element =
nullptr;
6140 bool errored =
false;
6142 const bool allow_exceptions =
true;
6145template<
typename BasicJsonType>
6159 const bool allow_exceptions_ =
true)
6160 : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6162 keep_stack.push_back(
true);
6174 handle_value(
nullptr);
6210 handle_value(std::move(val));
6217 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::object_start,
discarded);
6218 keep_stack.push_back(keep);
6220 auto val = handle_value(BasicJsonType::value_t::object,
true);
6221 ref_stack.push_back(val.second);
6224 if (ref_stack.back() &&
JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6226 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6234 BasicJsonType k = BasicJsonType(val);
6237 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::key, k);
6238 key_keep_stack.push_back(keep);
6241 if (keep && ref_stack.back())
6243 object_element = &(ref_stack.back()->m_value.object->operator[](val) =
discarded);
6251 if (ref_stack.back())
6253 if (!callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
6260 ref_stack.back()->set_parents();
6266 ref_stack.pop_back();
6267 keep_stack.pop_back();
6269 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
6272 for (
auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
6274 if (it->is_discarded())
6276 ref_stack.back()->erase(it);
6287 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::array_start,
discarded);
6288 keep_stack.push_back(keep);
6290 auto val = handle_value(BasicJsonType::value_t::array,
true);
6291 ref_stack.push_back(val.second);
6294 if (ref_stack.back() &&
JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6296 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6306 if (ref_stack.back())
6308 keep = callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
6311 ref_stack.back()->set_parents();
6322 ref_stack.pop_back();
6323 keep_stack.pop_back();
6326 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
6328 ref_stack.back()->m_value.array->pop_back();
6334 template<
class Exception>
6336 const Exception& ex)
6339 static_cast<void>(ex);
6340 if (allow_exceptions)
6368 template<
typename Value>
6369 std::pair<bool, BasicJsonType*>
handle_value(Value&& v,
const bool skip_callback =
false)
6375 if (!keep_stack.back())
6377 return {
false,
nullptr};
6381 auto value = BasicJsonType(std::forward<Value>(v));
6384 const bool keep = skip_callback || callback(
static_cast<int>(ref_stack.size()), parse_event_t::value,
value);
6389 return {
false,
nullptr};
6392 if (ref_stack.empty())
6394 root = std::move(
value);
6395 return {
true, &root};
6400 if (!ref_stack.back())
6402 return {
false,
nullptr};
6406 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6409 if (ref_stack.back()->is_array())
6411 ref_stack.back()->m_value.array->emplace_back(std::move(
value));
6412 return {
true, &(ref_stack.back()->m_value.array->back())};
6419 const bool store_element = key_keep_stack.back();
6420 key_keep_stack.pop_back();
6424 return {
false,
nullptr};
6428 *object_element = std::move(
value);
6429 return {
true, object_element};
6435 std::vector<BasicJsonType*> ref_stack {};
6437 std::vector<bool> keep_stack {};
6439 std::vector<bool> key_keep_stack {};
6441 BasicJsonType* object_element =
nullptr;
6443 bool errored =
false;
6447 const bool allow_exceptions =
true;
6449 BasicJsonType
discarded = BasicJsonType::value_t::discarded;
6452template<
typename BasicJsonType>
6539#include <initializer_list>
6559template<
typename BasicJsonType>
6593 return "<uninitialized>";
6595 return "true literal";
6597 return "false literal";
6599 return "null literal";
6601 return "string literal";
6605 return "number literal";
6619 return "<parse error>";
6621 return "end of input";
6623 return "'[', '{', or a literal";
6626 return "unknown token";
6636template<
typename BasicJsonType,
typename InputAdapterType>
6649 explicit lexer(InputAdapterType&& adapter,
bool ignore_comments_ =
false) noexcept
6650 :
ia(
std::move(adapter))
6671 const auto* loc = localeconv();
6673 return (loc->decimal_point ==
nullptr) ?
'.' : *(loc->decimal_point);
6701 const auto factors = { 12u, 8u, 4u, 0u };
6702 for (
const auto factor : factors)
6708 codepoint +=
static_cast<int>((
static_cast<unsigned int>(
current) - 0x30u) << factor);
6712 codepoint +=
static_cast<int>((
static_cast<unsigned int>(
current) - 0x37u) << factor);
6716 codepoint +=
static_cast<int>((
static_cast<unsigned int>(
current) - 0x57u) << factor);
6724 JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6745 JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6748 for (
auto range = ranges.begin(); range != ranges.end(); ++range)
6794 case std::char_traits<char_type>::eof():
6797 return token_type::parse_error;
6803 return token_type::value_string;
6848 int codepoint = codepoint1;
6852 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6853 return token_type::parse_error;
6857 if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6866 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6867 return token_type::parse_error;
6874 codepoint =
static_cast<int>(
6876 (
static_cast<unsigned int>(codepoint1) << 10u)
6878 +
static_cast<unsigned int>(codepoint2)
6886 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6887 return token_type::parse_error;
6892 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6893 return token_type::parse_error;
6900 error_message =
"invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6901 return token_type::parse_error;
6906 JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6909 if (codepoint < 0x80)
6914 else if (codepoint <= 0x7FF)
6917 add(
static_cast<char_int_type>(0xC0u | (
static_cast<unsigned int>(codepoint) >> 6u)));
6918 add(
static_cast<char_int_type>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6920 else if (codepoint <= 0xFFFF)
6923 add(
static_cast<char_int_type>(0xE0u | (
static_cast<unsigned int>(codepoint) >> 12u)));
6924 add(
static_cast<char_int_type>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6925 add(
static_cast<char_int_type>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6930 add(
static_cast<char_int_type>(0xF0u | (
static_cast<unsigned int>(codepoint) >> 18u)));
6931 add(
static_cast<char_int_type>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6932 add(
static_cast<char_int_type>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6933 add(
static_cast<char_int_type>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6941 error_message =
"invalid string: forbidden character after backslash";
6942 return token_type::parse_error;
6951 error_message =
"invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6952 return token_type::parse_error;
6957 error_message =
"invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6958 return token_type::parse_error;
6963 error_message =
"invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6964 return token_type::parse_error;
6969 error_message =
"invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6970 return token_type::parse_error;
6975 error_message =
"invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6976 return token_type::parse_error;
6981 error_message =
"invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6982 return token_type::parse_error;
6987 error_message =
"invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6988 return token_type::parse_error;
6993 error_message =
"invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6994 return token_type::parse_error;
6999 error_message =
"invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
7000 return token_type::parse_error;
7005 error_message =
"invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
7006 return token_type::parse_error;
7011 error_message =
"invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
7012 return token_type::parse_error;
7017 error_message =
"invalid string: control character U+000B (VT) must be escaped to \\u000B";
7018 return token_type::parse_error;
7023 error_message =
"invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
7024 return token_type::parse_error;
7029 error_message =
"invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
7030 return token_type::parse_error;
7035 error_message =
"invalid string: control character U+000E (SO) must be escaped to \\u000E";
7036 return token_type::parse_error;
7041 error_message =
"invalid string: control character U+000F (SI) must be escaped to \\u000F";
7042 return token_type::parse_error;
7047 error_message =
"invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
7048 return token_type::parse_error;
7053 error_message =
"invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
7054 return token_type::parse_error;
7059 error_message =
"invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
7060 return token_type::parse_error;
7065 error_message =
"invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
7066 return token_type::parse_error;
7071 error_message =
"invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
7072 return token_type::parse_error;
7077 error_message =
"invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7078 return token_type::parse_error;
7083 error_message =
"invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7084 return token_type::parse_error;
7089 error_message =
"invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7090 return token_type::parse_error;
7095 error_message =
"invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7096 return token_type::parse_error;
7101 error_message =
"invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7102 return token_type::parse_error;
7107 error_message =
"invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7108 return token_type::parse_error;
7113 error_message =
"invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7114 return token_type::parse_error;
7119 error_message =
"invalid string: control character U+001C (FS) must be escaped to \\u001C";
7120 return token_type::parse_error;
7125 error_message =
"invalid string: control character U+001D (GS) must be escaped to \\u001D";
7126 return token_type::parse_error;
7131 error_message =
"invalid string: control character U+001E (RS) must be escaped to \\u001E";
7132 return token_type::parse_error;
7137 error_message =
"invalid string: control character U+001F (US) must be escaped to \\u001F";
7138 return token_type::parse_error;
7275 return token_type::parse_error;
7285 return token_type::parse_error;
7309 return token_type::parse_error;
7319 return token_type::parse_error;
7329 return token_type::parse_error;
7341 return token_type::parse_error;
7351 return token_type::parse_error;
7360 return token_type::parse_error;
7383 case std::char_traits<char_type>::eof():
7400 case std::char_traits<char_type>::eof():
7431 error_message =
"invalid comment; expecting '/' or '*' after '/'";
7438 static
void strtof(
float& f, const
char* str,
char** endptr) noexcept
7440 f = std::strtof(str, endptr);
7444 static
void strtof(
double& f, const
char* str,
char** endptr) noexcept
7446 f = std::strtod(str, endptr);
7450 static
void strtof(
long double& f, const
char* str,
char** endptr) noexcept
7452 f = std::strtold(str, endptr);
7502 token_type number_type = token_type::value_unsigned;
7510 goto scan_number_minus;
7516 goto scan_number_zero;
7530 goto scan_number_any1;
7540 number_type = token_type::value_integer;
7546 goto scan_number_zero;
7560 goto scan_number_any1;
7566 return token_type::parse_error;
7577 goto scan_number_decimal1;
7584 goto scan_number_exponent;
7588 goto scan_number_done;
7607 goto scan_number_any1;
7613 goto scan_number_decimal1;
7620 goto scan_number_exponent;
7624 goto scan_number_done;
7627scan_number_decimal1:
7629 number_type = token_type::value_float;
7644 goto scan_number_decimal2;
7650 return token_type::parse_error;
7654scan_number_decimal2:
7670 goto scan_number_decimal2;
7677 goto scan_number_exponent;
7681 goto scan_number_done;
7684scan_number_exponent:
7686 number_type = token_type::value_float;
7693 goto scan_number_sign;
7708 goto scan_number_any2;
7714 "invalid number; expected '+', '-', or digit after exponent";
7715 return token_type::parse_error;
7735 goto scan_number_any2;
7740 error_message =
"invalid number; expected digit after exponent sign";
7741 return token_type::parse_error;
7761 goto scan_number_any2;
7765 goto scan_number_done;
7773 char* endptr =
nullptr;
7777 if (number_type == token_type::value_unsigned)
7779 const auto x = std::strtoull(
token_buffer.data(), &endptr, 10);
7789 return token_type::value_unsigned;
7793 else if (number_type == token_type::value_integer)
7795 const auto x = std::strtoll(
token_buffer.data(), &endptr, 10);
7805 return token_type::value_integer;
7817 return token_type::value_float;
7830 for (std::size_t i = 1; i < length; ++i)
7835 return token_type::parse_error;
7929 token_buffer.push_back(
static_cast<typename string_t::value_type
>(c));
7980 if (
static_cast<unsigned char>(c) <=
'\x1F')
7983 std::array<char, 9> cs{{}};
7984 (std::snprintf)(cs.data(), cs.size(),
"<U+%.4X>",
static_cast<unsigned char>(c));
7985 result += cs.data();
7990 result.push_back(
static_cast<std::string::value_type
>(c));
8017 return get() == 0xBB &&
get() == 0xBF;
8040 error_message =
"invalid BOM; must be 0xEF 0xBB 0xBF if given";
8041 return token_type::parse_error;
8052 return token_type::parse_error;
8063 return token_type::begin_array;
8065 return token_type::end_array;
8067 return token_type::begin_object;
8069 return token_type::end_object;
8071 return token_type::name_separator;
8073 return token_type::value_separator;
8079 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
8084 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
8089 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
8113 case std::char_traits<char_type>::eof():
8114 return token_type::end_of_input;
8119 return token_type::parse_error;
8182 decltype(std::declval<T&>().boolean(std::declval<bool>()));
8184template<
typename T,
typename Integer>
8186 decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8188template<
typename T,
typename Un
signed>
8190 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8192template<
typename T,
typename Float,
typename String>
8194 std::declval<Float>(), std::declval<const String&>()));
8196template<
typename T,
typename String>
8198 decltype(std::declval<T&>().string(std::declval<String&>()));
8200template<
typename T,
typename Binary>
8202 decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8206 decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8208template<
typename T,
typename String>
8210 decltype(std::declval<T&>().key(std::declval<String&>()));
8217 decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
8222template<
typename T,
typename Exception>
8224 std::declval<std::size_t>(), std::declval<const std::string&>(),
8225 std::declval<const Exception&>()));
8227template<
typename SAX,
typename BasicJsonType>
8232 "BasicJsonType must be of type basic_json<...>");
8258template<
typename SAX,
typename BasicJsonType>
8263 "BasicJsonType must be of type basic_json<...>");
8274 "Missing/invalid function: bool null()");
8276 "Missing/invalid function: bool boolean(bool)");
8278 "Missing/invalid function: bool boolean(bool)");
8282 "Missing/invalid function: bool number_integer(number_integer_t)");
8286 "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
8289 "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
8292 "Missing/invalid function: bool string(string_t&)");
8295 "Missing/invalid function: bool binary(binary_t&)");
8297 "Missing/invalid function: bool start_object(std::size_t)");
8299 "Missing/invalid function: bool key(string_t&)");
8301 "Missing/invalid function: bool end_object()");
8303 "Missing/invalid function: bool start_array(std::size_t)");
8305 "Missing/invalid function: bool end_array()");
8308 "Missing/invalid function: bool parse_error(std::size_t, const "
8309 "std::string&, const exception&)");
8341 return *
reinterpret_cast<char*
>(&num) == 1;
8352template<
typename BasicJsonType,
typename InputAdapterType,
typename SAX = json_sax_dom_parser<BasicJsonType>>
8393 const
bool strict = true,
8397 bool result =
false;
8455 std::int32_t document_size{};
8468 return sax->end_object();
8480 auto out = std::back_inserter(result);
8492 *out++ =
static_cast<typename string_t::value_type
>(
current);
8507 template<
typename NumberType>
8528 template<
typename NumberType>
8538 std::uint8_t subtype{};
8540 result.set_subtype(subtype);
8556 const std::size_t element_type_parse_position)
8558 switch (element_type)
8592 return sax->boolean(
get() != 0);
8602 std::int32_t
value{};
8608 std::int64_t
value{};
8614 std::array<char, 3> cr{{}};
8615 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(element_type));
8616 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()));
8637 while (
auto element_type =
get())
8644 const std::size_t element_type_parse_position =
chars_read;
8650 if (!is_array && !
sax->key(
key))
8673 std::int32_t document_size{};
8686 return sax->end_array();
8707 case std::char_traits<char_type>::eof():
8739 std::uint8_t number{};
8745 std::uint16_t number{};
8751 std::uint32_t number{};
8757 std::uint64_t number{};
8786 return sax->number_integer(
static_cast<std::int8_t
>(0x20 - 1 -
current));
8790 std::uint8_t number{};
8796 std::uint16_t number{};
8802 std::uint32_t number{};
8808 std::uint64_t number{};
8908 return get_cbor_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(
current) & 0x1Fu), tag_handler);
8918 std::uint16_t len{};
8924 std::uint32_t len{};
8930 std::uint64_t len{};
8962 return get_cbor_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(
current) & 0x1Fu), tag_handler);
8972 std::uint16_t len{};
8978 std::uint32_t len{};
8984 std::uint64_t len{};
9011 switch (tag_handler)
9026 std::uint8_t subtype_to_ignore{};
9032 std::uint16_t subtype_to_ignore{};
9038 std::uint32_t subtype_to_ignore{};
9044 std::uint64_t subtype_to_ignore{};
9062 std::uint8_t subtype{};
9064 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9069 std::uint16_t subtype{};
9071 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9076 std::uint32_t subtype{};
9078 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9083 std::uint64_t subtype{};
9085 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
9102 return sax->boolean(
false);
9105 return sax->boolean(
true);
9112 const auto byte1_raw =
get();
9117 const auto byte2_raw =
get();
9123 const auto byte1 =
static_cast<unsigned char>(byte1_raw);
9124 const auto byte2 =
static_cast<unsigned char>(byte2_raw);
9134 const auto half =
static_cast<unsigned int>((byte1 << 8u) + byte2);
9135 const double val = [&half]
9137 const int exp = (half >> 10u) & 0x1Fu;
9138 const unsigned int mant = half & 0x3FFu;
9144 return std::ldexp(mant, -24);
9147 ? std::numeric_limits<double>::infinity()
9148 : std::numeric_limits<double>::quiet_NaN();
9150 return std::ldexp(mant + 1024, exp - 25);
9153 return sax->number_float((half & 0x8000u) != 0
9235 std::uint16_t len{};
9241 std::uint32_t len{};
9247 std::uint64_t len{};
9253 while (
get() != 0xFF)
9260 result.append(chunk);
9331 std::uint16_t len{};
9338 std::uint32_t len{};
9345 std::uint64_t len{};
9352 while (
get() != 0xFF)
9359 result.insert(result.end(), chunk.begin(), chunk.end());
9386 if (len != std::size_t(-1))
9388 for (std::size_t i = 0; i < len; ++i)
9398 while (
get() != 0xFF)
9407 return sax->end_array();
9427 if (len != std::size_t(-1))
9429 for (std::size_t i = 0; i < len; ++i)
9446 while (
get() != 0xFF)
9462 return sax->end_object();
9477 case std::char_traits<char_type>::eof():
9694 return sax->boolean(
false);
9697 return sax->boolean(
true);
9729 std::uint8_t number{};
9735 std::uint16_t number{};
9741 std::uint32_t number{};
9747 std::uint64_t number{};
9753 std::int8_t number{};
9759 std::int16_t number{};
9765 std::int32_t number{};
9771 std::int64_t number{};
9777 std::uint16_t len{};
9783 std::uint32_t len{};
9789 std::uint16_t len{};
9795 std::uint32_t len{};
9832 return sax->number_integer(
static_cast<std::int8_t
>(
current));
9906 std::uint16_t len{};
9912 std::uint32_t len{};
9937 auto assign_and_return_true = [&result](std::int8_t subtype)
9939 result.set_subtype(
static_cast<std::uint8_t
>(subtype));
9954 std::uint16_t len{};
9961 std::uint32_t len{};
9969 std::int8_t subtype{};
9973 assign_and_return_true(subtype);
9978 std::uint16_t len{};
9979 std::int8_t subtype{};
9983 assign_and_return_true(subtype);
9988 std::uint32_t len{};
9989 std::int8_t subtype{};
9993 assign_and_return_true(subtype);
9998 std::int8_t subtype{};
10001 assign_and_return_true(subtype);
10006 std::int8_t subtype{};
10009 assign_and_return_true(subtype);
10014 std::int8_t subtype{};
10017 assign_and_return_true(subtype);
10022 std::int8_t subtype{};
10025 assign_and_return_true(subtype);
10030 std::int8_t subtype{};
10033 assign_and_return_true(subtype);
10052 for (std::size_t i = 0; i < len; ++i)
10060 return sax->end_array();
10075 for (std::size_t i = 0; i < len; ++i)
10090 return sax->end_object();
10139 std::uint8_t len{};
10151 std::int16_t len{};
10157 std::int32_t len{};
10163 std::int64_t len{};
10169 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()));
10183 std::uint8_t number{};
10188 result =
static_cast<std::size_t
>(number);
10194 std::int8_t number{};
10199 result =
static_cast<std::size_t
>(number);
10205 std::int16_t number{};
10210 result =
static_cast<std::size_t
>(number);
10216 std::int32_t number{};
10221 result =
static_cast<std::size_t
>(number);
10227 std::int64_t number{};
10232 result =
static_cast<std::size_t
>(number);
10239 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()));
10256 result.first = string_t::npos;
10263 result.second =
get();
10299 case std::char_traits<char_type>::eof():
10303 return sax->boolean(
true);
10305 return sax->boolean(
false);
10308 return sax->null();
10312 std::uint8_t number{};
10318 std::int8_t number{};
10324 std::int16_t number{};
10330 std::int32_t number{};
10336 std::int64_t number{};
10370 return sax->string(s);
10398 std::pair<std::size_t, char_int_type> size_and_type;
10404 if (size_and_type.first != string_t::npos)
10411 if (size_and_type.second != 0)
10413 if (size_and_type.second !=
'N')
10415 for (std::size_t i = 0; i < size_and_type.first; ++i)
10426 for (std::size_t i = 0; i < size_and_type.first; ++i)
10452 return sax->end_array();
10460 std::pair<std::size_t, char_int_type> size_and_type;
10467 if (size_and_type.first != string_t::npos)
10474 if (size_and_type.second != 0)
10476 for (std::size_t i = 0; i < size_and_type.first; ++i)
10491 for (std::size_t i = 0; i < size_and_type.first; ++i)
10527 return sax->end_object();
10536 std::size_t size{};
10544 std::vector<char> number_vector;
10545 for (std::size_t i = 0; i < size; ++i)
10552 number_vector.push_back(
static_cast<char>(
current));
10558 const auto result_number = number_lexer.scan();
10559 const auto number_string = number_lexer.get_token_string();
10560 const auto result_remainder = number_lexer.scan();
10569 switch (result_number)
10571 case token_type::value_integer:
10572 return sax->number_integer(number_lexer.get_number_integer());
10573 case token_type::value_unsigned:
10574 return sax->number_unsigned(number_lexer.get_number_unsigned());
10575 case token_type::value_float:
10576 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
10577 case token_type::uninitialized:
10578 case token_type::literal_true:
10579 case token_type::literal_false:
10580 case token_type::literal_null:
10581 case token_type::value_string:
10582 case token_type::begin_array:
10583 case token_type::begin_object:
10584 case token_type::end_array:
10585 case token_type::end_object:
10586 case token_type::name_separator:
10587 case token_type::value_separator:
10588 case token_type::parse_error:
10589 case token_type::end_of_input:
10590 case token_type::literal_or_value:
10642 template<
typename NumberType,
bool InputIsLittleEndian = false>
10646 std::array<std::uint8_t,
sizeof(NumberType)> vec{};
10647 for (std::size_t i = 0; i <
sizeof(NumberType); ++i)
10658 vec[
sizeof(NumberType) - i - 1] =
static_cast<std::uint8_t
>(
current);
10662 vec[i] =
static_cast<std::uint8_t
>(
current);
10667 std::memcpy(&result, vec.data(),
sizeof(NumberType));
10685 template<
typename NumberType>
10687 const NumberType len,
10690 bool success =
true;
10691 for (NumberType i = 0; i < len; i++)
10699 result.push_back(
static_cast<typename string_t::value_type
>(
current));
10718 template<
typename NumberType>
10720 const NumberType len,
10723 bool success =
true;
10724 for (NumberType i = 0; i < len; i++)
10732 result.push_back(
static_cast<std::uint8_t
>(
current));
10758 std::array<char, 3> cr{{}};
10759 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(
current));
10760 return std::string{cr.data()};
10770 const std::string& detail,
10771 const std::string& context)
const
10773 std::string error_msg =
"syntax error while parsing ";
10778 error_msg +=
"CBOR";
10782 error_msg +=
"MessagePack";
10786 error_msg +=
"UBJSON";
10790 error_msg +=
"BSON";
10798 return error_msg +
" " + context +
": " + detail;
10829#include <functional>
10873template<
typename BasicJsonType>
10875 std::function<bool(
int ,
parse_event_t , BasicJsonType& )>;
10882template<
typename BasicJsonType,
typename InputAdapterType>
10896 const bool allow_exceptions_ =
true,
10897 const bool skip_comments =
false)
10899 ,
m_lexer(
std::move(adapter), skip_comments)
10941 if (result.is_discarded())
10967 result.assert_invariant();
10982 template<
typename SAX>
11001 template<
typename SAX>
11007 std::vector<bool> states;
11009 bool skip_to_state_evaluation =
false;
11013 if (!skip_to_state_evaluation)
11018 case token_type::begin_object:
11026 if (
get_token() == token_type::end_object)
11056 states.push_back(
false);
11063 case token_type::begin_array:
11071 if (
get_token() == token_type::end_array)
11081 states.push_back(
true);
11087 case token_type::value_float:
11106 case token_type::literal_false:
11115 case token_type::literal_null:
11124 case token_type::literal_true:
11133 case token_type::value_integer:
11142 case token_type::value_string:
11151 case token_type::value_unsigned:
11160 case token_type::parse_error:
11168 case token_type::uninitialized:
11169 case token_type::end_array:
11170 case token_type::end_object:
11171 case token_type::name_separator:
11172 case token_type::value_separator:
11173 case token_type::end_of_input:
11174 case token_type::literal_or_value:
11185 skip_to_state_evaluation =
false;
11189 if (states.empty())
11198 if (
get_token() == token_type::value_separator)
11219 skip_to_state_evaluation =
true;
11231 if (
get_token() == token_type::value_separator)
11273 skip_to_state_evaluation =
true;
11291 std::string error_msg =
"syntax error ";
11293 if (!context.empty())
11295 error_msg +=
"while parsing " + context +
" ";
11310 if (expected != token_type::uninitialized)
11400 return lhs.m_it == rhs.m_it;
11405 return lhs.m_it < rhs.m_it;
11410 auto result = *
this;
11417 return lhs.m_it - rhs.m_it;
11428 auto result = *
this;
11441 auto result = *
this;
11488#include <type_traits>
11510template<
typename IteratorType>
class iteration_proxy;
11511template<
typename IteratorType>
class iteration_proxy_value;
11529template<
typename BasicJsonType>
11544 "iter_impl only accepts (const) basic_json");
11560 using pointer =
typename std::conditional<std::is_const<BasicJsonType>::value,
11561 typename BasicJsonType::const_pointer,
11562 typename BasicJsonType::pointer>::type;
11565 typename std::conditional<std::is_const<BasicJsonType>::value,
11566 typename BasicJsonType::const_reference,
11567 typename BasicJsonType::reference>::type;
11584 switch (m_object->m_type)
11631 : m_object(other.m_object),
m_it(other.m_it)
11642 if (&other !=
this)
11644 m_object = other.m_object;
11656 : m_object(other.m_object),
m_it(other.m_it)
11667 m_object = other.m_object;
11677 void set_begin() noexcept
11681 switch (m_object->m_type)
11725 switch (m_object->m_type)
11764 switch (m_object->m_type)
11808 switch (m_object->m_type)
11848 auto result = *
this;
11861 switch (m_object->m_type)
11899 auto result = *
this;
11912 switch (m_object->m_type)
11948 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 >
11959 switch (m_object->m_type)
11984 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 >
12004 switch (m_object->m_type)
12031 return !other.operator < (*this);
12060 switch (m_object->m_type)
12104 auto result = *
this;
12126 auto result = *
this;
12139 switch (m_object->m_type)
12168 switch (m_object->m_type)
12202 const typename object_t::key_type&
key()
const
12267template<
typename Base>
12341 auto it = --this->base();
12348 auto it = --this->base();
12349 return it.operator * ();
12360#include <algorithm>
12379template<
typename BasicJsonType>
12430 [](
const std::string & a,
const std::string & b)
12432 return a +
"/" + detail::escape(b);
12437 operator std::string()
const
12506 return *
this /= std::to_string(array_idx);
12695 static typename BasicJsonType::size_type
array_index(
const std::string& s)
12697 using size_type =
typename BasicJsonType::size_type;
12711 std::size_t processed_chars = 0;
12712 unsigned long long res = 0;
12715 res = std::stoull(s, &processed_chars);
12730 if (res >=
static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
12735 return static_cast<size_type
>(res);
12772 if (reference_token ==
"0")
12844 if (ptr->is_null())
12848 std::all_of(reference_token.begin(), reference_token.end(),
12849 [](
const unsigned char x)
12851 return std::isdigit(x);
12855 *ptr = (nums || reference_token ==
"-")
12860 switch (ptr->type())
12865 ptr = &ptr->operator[](reference_token);
12871 if (reference_token ==
"-")
12874 ptr = &ptr->operator[](ptr->m_value.array->size());
12879 ptr = &ptr->operator[](
array_index(reference_token));
12910 switch (ptr->type())
12915 ptr = &ptr->at(reference_token);
12925 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12926 ") is out of range", *ptr));
12967 switch (ptr->type())
12972 ptr = &ptr->operator[](reference_token);
12985 ptr = &ptr->operator[](
array_index(reference_token));
13015 switch (ptr->type())
13020 ptr = &ptr->at(reference_token);
13030 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
13031 ") is out of range", *ptr));
13063 switch (ptr->type())
13067 if (!ptr->contains(reference_token))
13073 ptr = &ptr->operator[](reference_token);
13084 if (
JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !(
"0" <= reference_token && reference_token <=
"9")))
13096 for (std::size_t i = 1; i < reference_token.size(); i++)
13107 if (idx >= ptr->size())
13113 ptr = &ptr->operator[](idx);
13147 static std::vector<std::string>
split(
const std::string& reference_string)
13149 std::vector<std::string>
result;
13152 if (reference_string.empty())
13168 std::size_t slash = reference_string.find_first_of(
'/', 1),
13175 start = (slash == std::string::npos) ? 0 : slash + 1,
13177 slash = reference_string.find_first_of(
'/', start))
13181 auto reference_token = reference_string.substr(start, slash - start);
13184 for (std::size_t pos = reference_token.find_first_of(
'~');
13185 pos != std::string::npos;
13186 pos = reference_token.find_first_of(
'~', pos + 1))
13192 (reference_token[pos + 1] !=
'0' &&
13193 reference_token[pos + 1] !=
'1')))
13215 static void flatten(
const std::string& reference_string,
13219 switch (value.type())
13223 if (value.m_value.array->empty())
13226 result[reference_string] =
nullptr;
13231 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
13233 flatten(reference_string +
"/" + std::to_string(i),
13234 value.m_value.array->operator[](i),
result);
13242 if (value.m_value.object->empty())
13245 result[reference_string] =
nullptr;
13250 for (
const auto& element : *value.m_value.object)
13269 result[reference_string] = value;
13296 for (
const auto& element : *value.m_value.object)
13327 return lhs.reference_tokens == rhs.reference_tokens;
13344 return !(lhs == rhs);
13355#include <initializer_list>
13365template<
typename BasicJsonType>
13434#include <algorithm>
13450#include <algorithm>
13484template<typename CharType>
13488template<typename CharType>
13502 void write_characters(const CharType* s,
std::
size_t length)
override
13504 std::copy(s, s + length, std::back_inserter(v));
13508 std::vector<CharType>&
v;
13513template<
typename CharType>
13527 void write_characters(const CharType* s,
std::
size_t length)
override
13529 stream.write(s,
static_cast<std::streamsize
>(length));
13538template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13552 void write_characters(const CharType* s,
std::
size_t length)
override
13554 str.append(s, length);
13561template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13599template<
typename BasicJsonType,
typename CharType>
13625 case value_t::object:
13627 write_bson_object(*j.m_value.object);
13631 case value_t::null:
13632 case value_t::array:
13633 case value_t::string:
13634 case value_t::boolean:
13635 case value_t::number_integer:
13636 case value_t::number_unsigned:
13637 case value_t::number_float:
13638 case value_t::binary:
13639 case value_t::discarded:
13642 JSON_THROW(type_error::create(317,
"to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));
13654 case value_t::null:
13656 oa->write_character(to_char_type(0xF6));
13660 case value_t::boolean:
13662 oa->write_character(j.m_value.boolean
13663 ? to_char_type(0xF5)
13664 : to_char_type(0xF4));
13668 case value_t::number_integer:
13670 if (j.m_value.number_integer >= 0)
13675 if (j.m_value.number_integer <= 0x17)
13677 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13679 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
13681 oa->write_character(to_char_type(0x18));
13682 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13684 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
13686 oa->write_character(to_char_type(0x19));
13687 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13689 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
13691 oa->write_character(to_char_type(0x1A));
13692 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13696 oa->write_character(to_char_type(0x1B));
13697 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13704 const auto positive_number = -1 - j.m_value.number_integer;
13705 if (j.m_value.number_integer >= -24)
13707 write_number(
static_cast<std::uint8_t
>(0x20 + positive_number));
13709 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
13711 oa->write_character(to_char_type(0x38));
13712 write_number(
static_cast<std::uint8_t
>(positive_number));
13714 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
13716 oa->write_character(to_char_type(0x39));
13717 write_number(
static_cast<std::uint16_t
>(positive_number));
13719 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
13721 oa->write_character(to_char_type(0x3A));
13722 write_number(
static_cast<std::uint32_t
>(positive_number));
13726 oa->write_character(to_char_type(0x3B));
13727 write_number(
static_cast<std::uint64_t
>(positive_number));
13733 case value_t::number_unsigned:
13735 if (j.m_value.number_unsigned <= 0x17)
13737 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13739 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13741 oa->write_character(to_char_type(0x18));
13742 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13744 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13746 oa->write_character(to_char_type(0x19));
13747 write_number(
static_cast<std::uint16_t
>(j.m_value.number_unsigned));
13749 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13751 oa->write_character(to_char_type(0x1A));
13752 write_number(
static_cast<std::uint32_t
>(j.m_value.number_unsigned));
13756 oa->write_character(to_char_type(0x1B));
13757 write_number(
static_cast<std::uint64_t
>(j.m_value.number_unsigned));
13762 case value_t::number_float:
13764 if (std::isnan(j.m_value.number_float))
13767 oa->write_character(to_char_type(0xF9));
13768 oa->write_character(to_char_type(0x7E));
13769 oa->write_character(to_char_type(0x00));
13771 else if (std::isinf(j.m_value.number_float))
13774 oa->write_character(to_char_type(0xf9));
13775 oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
13776 oa->write_character(to_char_type(0x00));
13785 case value_t::string:
13788 const auto N = j.m_value.string->size();
13791 write_number(
static_cast<std::uint8_t
>(0x60 + N));
13793 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13795 oa->write_character(to_char_type(0x78));
13796 write_number(
static_cast<std::uint8_t
>(N));
13798 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13800 oa->write_character(to_char_type(0x79));
13801 write_number(
static_cast<std::uint16_t
>(N));
13803 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13805 oa->write_character(to_char_type(0x7A));
13806 write_number(
static_cast<std::uint32_t
>(N));
13809 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13811 oa->write_character(to_char_type(0x7B));
13812 write_number(
static_cast<std::uint64_t
>(N));
13817 oa->write_characters(
13818 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13819 j.m_value.string->size());
13823 case value_t::array:
13826 const auto N = j.m_value.array->size();
13829 write_number(
static_cast<std::uint8_t
>(0x80 + N));
13831 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13833 oa->write_character(to_char_type(0x98));
13834 write_number(
static_cast<std::uint8_t
>(N));
13836 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13838 oa->write_character(to_char_type(0x99));
13839 write_number(
static_cast<std::uint16_t
>(N));
13841 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13843 oa->write_character(to_char_type(0x9A));
13844 write_number(
static_cast<std::uint32_t
>(N));
13847 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13849 oa->write_character(to_char_type(0x9B));
13850 write_number(
static_cast<std::uint64_t
>(N));
13855 for (
const auto& el : *j.m_value.array)
13862 case value_t::binary:
13864 if (j.m_value.binary->has_subtype())
13866 if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
13868 write_number(
static_cast<std::uint8_t
>(0xd8));
13869 write_number(
static_cast<std::uint8_t
>(j.m_value.binary->subtype()));
13871 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
13873 write_number(
static_cast<std::uint8_t
>(0xd9));
13874 write_number(
static_cast<std::uint16_t
>(j.m_value.binary->subtype()));
13876 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
13878 write_number(
static_cast<std::uint8_t
>(0xda));
13879 write_number(
static_cast<std::uint32_t
>(j.m_value.binary->subtype()));
13881 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
13883 write_number(
static_cast<std::uint8_t
>(0xdb));
13884 write_number(
static_cast<std::uint64_t
>(j.m_value.binary->subtype()));
13889 const auto N = j.m_value.binary->size();
13892 write_number(
static_cast<std::uint8_t
>(0x40 + N));
13894 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13896 oa->write_character(to_char_type(0x58));
13897 write_number(
static_cast<std::uint8_t
>(N));
13899 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13901 oa->write_character(to_char_type(0x59));
13902 write_number(
static_cast<std::uint16_t
>(N));
13904 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13906 oa->write_character(to_char_type(0x5A));
13907 write_number(
static_cast<std::uint32_t
>(N));
13910 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13912 oa->write_character(to_char_type(0x5B));
13913 write_number(
static_cast<std::uint64_t
>(N));
13918 oa->write_characters(
13919 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13925 case value_t::object:
13928 const auto N = j.m_value.object->size();
13931 write_number(
static_cast<std::uint8_t
>(0xA0 + N));
13933 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13935 oa->write_character(to_char_type(0xB8));
13936 write_number(
static_cast<std::uint8_t
>(N));
13938 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13940 oa->write_character(to_char_type(0xB9));
13941 write_number(
static_cast<std::uint16_t
>(N));
13943 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13945 oa->write_character(to_char_type(0xBA));
13946 write_number(
static_cast<std::uint32_t
>(N));
13949 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13951 oa->write_character(to_char_type(0xBB));
13952 write_number(
static_cast<std::uint64_t
>(N));
13957 for (
const auto& el : *j.m_value.object)
13959 write_cbor(el.first);
13960 write_cbor(el.second);
13965 case value_t::discarded:
13978 case value_t::null:
13980 oa->write_character(to_char_type(0xC0));
13984 case value_t::boolean:
13986 oa->write_character(j.m_value.boolean
13987 ? to_char_type(0xC3)
13988 : to_char_type(0xC2));
13992 case value_t::number_integer:
13994 if (j.m_value.number_integer >= 0)
13999 if (j.m_value.number_unsigned < 128)
14002 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14004 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
14007 oa->write_character(to_char_type(0xCC));
14008 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14010 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
14013 oa->write_character(to_char_type(0xCD));
14014 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
14016 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
14019 oa->write_character(to_char_type(0xCE));
14020 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
14022 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
14025 oa->write_character(to_char_type(0xCF));
14026 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
14031 if (j.m_value.number_integer >= -32)
14034 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
14036 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
14037 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
14040 oa->write_character(to_char_type(0xD0));
14041 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
14043 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
14044 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
14047 oa->write_character(to_char_type(0xD1));
14048 write_number(
static_cast<std::int16_t
>(j.m_value.number_integer));
14050 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
14051 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
14054 oa->write_character(to_char_type(0xD2));
14055 write_number(
static_cast<std::int32_t
>(j.m_value.number_integer));
14057 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
14058 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
14061 oa->write_character(to_char_type(0xD3));
14062 write_number(
static_cast<std::int64_t
>(j.m_value.number_integer));
14068 case value_t::number_unsigned:
14070 if (j.m_value.number_unsigned < 128)
14073 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14075 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
14078 oa->write_character(to_char_type(0xCC));
14079 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
14081 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
14084 oa->write_character(to_char_type(0xCD));
14085 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
14087 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
14090 oa->write_character(to_char_type(0xCE));
14091 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
14093 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
14096 oa->write_character(to_char_type(0xCF));
14097 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
14102 case value_t::number_float:
14108 case value_t::string:
14111 const auto N = j.m_value.string->size();
14115 write_number(
static_cast<std::uint8_t
>(0xA0 | N));
14117 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
14120 oa->write_character(to_char_type(0xD9));
14121 write_number(
static_cast<std::uint8_t
>(N));
14123 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14126 oa->write_character(to_char_type(0xDA));
14127 write_number(
static_cast<std::uint16_t
>(N));
14129 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14132 oa->write_character(to_char_type(0xDB));
14133 write_number(
static_cast<std::uint32_t
>(N));
14137 oa->write_characters(
14138 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14139 j.m_value.string->size());
14143 case value_t::array:
14146 const auto N = j.m_value.array->size();
14150 write_number(
static_cast<std::uint8_t
>(0x90 | N));
14152 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14155 oa->write_character(to_char_type(0xDC));
14156 write_number(
static_cast<std::uint16_t
>(N));
14158 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14161 oa->write_character(to_char_type(0xDD));
14162 write_number(
static_cast<std::uint32_t
>(N));
14166 for (
const auto& el : *j.m_value.array)
14173 case value_t::binary:
14177 const bool use_ext = j.m_value.binary->has_subtype();
14180 const auto N = j.m_value.binary->size();
14181 if (N <= (std::numeric_limits<std::uint8_t>::max)())
14183 std::uint8_t output_type{};
14190 output_type = 0xD4;
14193 output_type = 0xD5;
14196 output_type = 0xD6;
14199 output_type = 0xD7;
14202 output_type = 0xD8;
14205 output_type = 0xC7;
14213 output_type = 0xC4;
14217 oa->write_character(to_char_type(output_type));
14220 write_number(
static_cast<std::uint8_t
>(N));
14223 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14225 std::uint8_t output_type = use_ext
14229 oa->write_character(to_char_type(output_type));
14230 write_number(
static_cast<std::uint16_t
>(N));
14232 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14234 std::uint8_t output_type = use_ext
14238 oa->write_character(to_char_type(output_type));
14239 write_number(
static_cast<std::uint32_t
>(N));
14245 write_number(
static_cast<std::int8_t
>(j.m_value.binary->subtype()));
14249 oa->write_characters(
14250 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14256 case value_t::object:
14259 const auto N = j.m_value.object->size();
14263 write_number(
static_cast<std::uint8_t
>(0x80 | (N & 0xF)));
14265 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
14268 oa->write_character(to_char_type(0xDE));
14269 write_number(
static_cast<std::uint16_t
>(N));
14271 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
14274 oa->write_character(to_char_type(0xDF));
14275 write_number(
static_cast<std::uint32_t
>(N));
14279 for (
const auto& el : *j.m_value.object)
14281 write_msgpack(el.first);
14282 write_msgpack(el.second);
14287 case value_t::discarded:
14300 const bool use_type,
const bool add_prefix =
true)
14304 case value_t::null:
14308 oa->write_character(to_char_type(
'Z'));
14313 case value_t::boolean:
14317 oa->write_character(j.m_value.boolean
14318 ? to_char_type(
'T')
14319 : to_char_type(
'F'));
14324 case value_t::number_integer:
14326 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
14330 case value_t::number_unsigned:
14332 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
14336 case value_t::number_float:
14338 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
14342 case value_t::string:
14346 oa->write_character(to_char_type(
'S'));
14348 write_number_with_ubjson_prefix(j.m_value.string->size(),
true);
14349 oa->write_characters(
14350 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14351 j.m_value.string->size());
14355 case value_t::array:
14359 oa->write_character(to_char_type(
'['));
14362 bool prefix_required =
true;
14363 if (use_type && !j.m_value.array->empty())
14366 const CharType first_prefix = ubjson_prefix(j.front());
14367 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
14368 [
this, first_prefix](
const BasicJsonType & v)
14370 return ubjson_prefix(v) == first_prefix;
14375 prefix_required =
false;
14376 oa->write_character(to_char_type(
'$'));
14377 oa->write_character(first_prefix);
14383 oa->write_character(to_char_type(
'#'));
14384 write_number_with_ubjson_prefix(j.m_value.array->size(),
true);
14387 for (
const auto& el : *j.m_value.array)
14389 write_ubjson(el, use_count, use_type, prefix_required);
14394 oa->write_character(to_char_type(
']'));
14400 case value_t::binary:
14404 oa->write_character(to_char_type(
'['));
14407 if (use_type && !j.m_value.binary->empty())
14410 oa->write_character(to_char_type(
'$'));
14411 oa->write_character(
'U');
14416 oa->write_character(to_char_type(
'#'));
14417 write_number_with_ubjson_prefix(j.m_value.binary->size(),
true);
14422 oa->write_characters(
14423 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14424 j.m_value.binary->size());
14428 for (
size_t i = 0; i < j.m_value.binary->size(); ++i)
14430 oa->write_character(to_char_type(
'U'));
14431 oa->write_character(j.m_value.binary->data()[i]);
14437 oa->write_character(to_char_type(
']'));
14443 case value_t::object:
14447 oa->write_character(to_char_type(
'{'));
14450 bool prefix_required =
true;
14451 if (use_type && !j.m_value.object->empty())
14454 const CharType first_prefix = ubjson_prefix(j.front());
14455 const bool same_prefix = std::all_of(j.begin(), j.end(),
14456 [
this, first_prefix](
const BasicJsonType & v)
14458 return ubjson_prefix(v) == first_prefix;
14463 prefix_required =
false;
14464 oa->write_character(to_char_type(
'$'));
14465 oa->write_character(first_prefix);
14471 oa->write_character(to_char_type(
'#'));
14472 write_number_with_ubjson_prefix(j.m_value.object->size(),
true);
14475 for (
const auto& el : *j.m_value.object)
14477 write_number_with_ubjson_prefix(el.first.size(),
true);
14478 oa->write_characters(
14479 reinterpret_cast<const CharType*
>(el.first.c_str()),
14481 write_ubjson(el.second, use_count, use_type, prefix_required);
14486 oa->write_character(to_char_type(
'}'));
14492 case value_t::discarded:
14509 const auto it = name.find(
static_cast<typename string_t::value_type
>(0));
14512 JSON_THROW(out_of_range::create(409,
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) +
")", j));
14513 static_cast<void>(j);
14516 return 1ul + name.size() + 1u;
14523 const std::uint8_t element_type)
14525 oa->write_character(to_char_type(element_type));
14526 oa->write_characters(
14527 reinterpret_cast<const CharType*
>(name.c_str()),
14537 write_bson_entry_header(name, 0x08);
14538 oa->write_character(
value ? to_char_type(0x01) : to_char_type(0x00));
14545 const double value)
14547 write_bson_entry_header(name, 0x01);
14548 write_number<double, true>(
value);
14556 return sizeof(std::int32_t) +
value.size() + 1ul;
14565 write_bson_entry_header(name, 0x02);
14567 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(
value.size() + 1ul));
14568 oa->write_characters(
14569 reinterpret_cast<const CharType*
>(
value.c_str()),
14578 write_bson_entry_header(name, 0x0A);
14586 return (std::numeric_limits<std::int32_t>::min)() <=
value &&
value <= (std::numeric_limits<std::int32_t>::max)()
14587 ?
sizeof(std::int32_t)
14588 :
sizeof(std::int64_t);
14595 const std::int64_t value)
14597 if ((std::numeric_limits<std::int32_t>::min)() <=
value &&
value <= (std::numeric_limits<std::int32_t>::max)())
14599 write_bson_entry_header(name, 0x10);
14600 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(
value));
14604 write_bson_entry_header(name, 0x12);
14605 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(
value));
14614 return (
value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14615 ?
sizeof(std::int32_t)
14616 :
sizeof(std::int64_t);
14623 const BasicJsonType& j)
14625 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14627 write_bson_entry_header(name, 0x10 );
14628 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(j.m_value.number_unsigned));
14630 else if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14632 write_bson_entry_header(name, 0x12 );
14633 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(j.m_value.number_unsigned));
14637 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));
14645 const typename BasicJsonType::object_t& value)
14647 write_bson_entry_header(name, 0x03);
14648 write_bson_object(
value);
14656 std::size_t array_index = 0ul;
14658 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)
14660 return result + calc_bson_element_size(std::to_string(array_index++), el);
14663 return sizeof(std::int32_t) + embedded_document_size + 1ul;
14671 return sizeof(std::int32_t) +
value.size() + 1ul;
14678 const typename BasicJsonType::array_t& value)
14680 write_bson_entry_header(name, 0x04);
14681 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_array_size(
value)));
14683 std::size_t array_index = 0ul;
14685 for (
const auto& el :
value)
14687 write_bson_element(std::to_string(array_index++), el);
14690 oa->write_character(to_char_type(0x00));
14699 write_bson_entry_header(name, 0x05);
14701 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(
value.size()));
14702 write_number(
value.has_subtype() ?
static_cast<std::uint8_t
>(
value.subtype()) : std::uint8_t(0x00));
14704 oa->write_characters(
reinterpret_cast<const CharType*
>(
value.data()),
value.size());
14712 const BasicJsonType& j)
14714 const auto header_size = calc_bson_entry_header_size(name, j);
14717 case value_t::object:
14718 return header_size + calc_bson_object_size(*j.m_value.object);
14720 case value_t::array:
14721 return header_size + calc_bson_array_size(*j.m_value.array);
14723 case value_t::binary:
14724 return header_size + calc_bson_binary_size(*j.m_value.binary);
14726 case value_t::boolean:
14727 return header_size + 1ul;
14729 case value_t::number_float:
14730 return header_size + 8ul;
14732 case value_t::number_integer:
14733 return header_size + calc_bson_integer_size(j.m_value.number_integer);
14735 case value_t::number_unsigned:
14736 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
14738 case value_t::string:
14739 return header_size + calc_bson_string_size(*j.m_value.string);
14741 case value_t::null:
14742 return header_size + 0ul;
14745 case value_t::discarded:
14760 const BasicJsonType& j)
14764 case value_t::object:
14765 return write_bson_object_entry(name, *j.m_value.object);
14767 case value_t::array:
14768 return write_bson_array(name, *j.m_value.array);
14770 case value_t::binary:
14771 return write_bson_binary(name, *j.m_value.binary);
14773 case value_t::boolean:
14774 return write_bson_boolean(name, j.m_value.boolean);
14776 case value_t::number_float:
14777 return write_bson_double(name, j.m_value.number_float);
14779 case value_t::number_integer:
14780 return write_bson_integer(name, j.m_value.number_integer);
14782 case value_t::number_unsigned:
14783 return write_bson_unsigned(name, j);
14785 case value_t::string:
14786 return write_bson_string(name, *j.m_value.string);
14788 case value_t::null:
14789 return write_bson_null(name);
14792 case value_t::discarded:
14808 std::size_t document_size = std::accumulate(
value.begin(),
value.end(), std::size_t(0),
14809 [](
size_t result,
const typename BasicJsonType::object_t::value_type & el)
14811 return result += calc_bson_element_size(el.first, el.second);
14814 return sizeof(std::int32_t) + document_size + 1ul;
14823 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_object_size(
value)));
14825 for (
const auto& el :
value)
14827 write_bson_element(el.first, el.second);
14830 oa->write_character(to_char_type(0x00));
14839 return to_char_type(0xFA);
14844 return to_char_type(0xFB);
14853 return to_char_type(0xCA);
14858 return to_char_type(0xCB);
14866 template<
typename NumberType,
typename std::enable_if<
14867 std::is_floating_point<NumberType>::value,
int>::type = 0>
14869 const bool add_prefix)
14873 oa->write_character(get_ubjson_float_prefix(n));
14879 template<
typename NumberType,
typename std::enable_if<
14880 std::is_unsigned<NumberType>::value,
int>::type = 0>
14882 const bool add_prefix)
14884 if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14888 oa->write_character(to_char_type(
'i'));
14890 write_number(
static_cast<std::uint8_t
>(n));
14892 else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14896 oa->write_character(to_char_type(
'U'));
14898 write_number(
static_cast<std::uint8_t
>(n));
14900 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14904 oa->write_character(to_char_type(
'I'));
14906 write_number(
static_cast<std::int16_t
>(n));
14908 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14912 oa->write_character(to_char_type(
'l'));
14914 write_number(
static_cast<std::int32_t
>(n));
14916 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14920 oa->write_character(to_char_type(
'L'));
14922 write_number(
static_cast<std::int64_t
>(n));
14928 oa->write_character(to_char_type(
'H'));
14931 const auto number = BasicJsonType(n).dump();
14932 write_number_with_ubjson_prefix(number.size(),
true);
14933 for (std::size_t i = 0; i < number.size(); ++i)
14935 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14941 template <
typename NumberType,
typename std::enable_if <
14942 std::is_signed<NumberType>::value&&
14943 !std::is_floating_point<NumberType>::value,
int >::type = 0 >
14945 const bool add_prefix)
14947 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14951 oa->write_character(to_char_type(
'i'));
14953 write_number(
static_cast<std::int8_t
>(n));
14955 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)()))
14959 oa->write_character(to_char_type(
'U'));
14961 write_number(
static_cast<std::uint8_t
>(n));
14963 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14967 oa->write_character(to_char_type(
'I'));
14969 write_number(
static_cast<std::int16_t
>(n));
14971 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14975 oa->write_character(to_char_type(
'l'));
14977 write_number(
static_cast<std::int32_t
>(n));
14979 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14983 oa->write_character(to_char_type(
'L'));
14985 write_number(
static_cast<std::int64_t
>(n));
14992 oa->write_character(to_char_type(
'H'));
14995 const auto number = BasicJsonType(n).dump();
14996 write_number_with_ubjson_prefix(number.size(),
true);
14997 for (std::size_t i = 0; i < number.size(); ++i)
14999 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
15012 case value_t::null:
15015 case value_t::boolean:
15016 return j.m_value.boolean ?
'T' :
'F';
15018 case value_t::number_integer:
15020 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)())
15024 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)())
15028 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)())
15032 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)())
15036 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)())
15044 case value_t::number_unsigned:
15046 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
15050 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::uint8_t>::max)()))
15054 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
15058 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
15062 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
15070 case value_t::number_float:
15071 return get_ubjson_float_prefix(j.m_value.number_float);
15073 case value_t::string:
15076 case value_t::array:
15077 case value_t::binary:
15080 case value_t::object:
15083 case value_t::discarded:
15114 template<
typename NumberType,
bool OutputIsLittleEndian = false>
15118 std::array<CharType,
sizeof(NumberType)> vec{};
15119 std::memcpy(vec.data(), &n,
sizeof(NumberType));
15122 if (is_little_endian != OutputIsLittleEndian)
15125 std::reverse(vec.begin(), vec.end());
15128 oa->write_characters(vec.data(),
sizeof(NumberType));
15134#pragma GCC diagnostic push
15135#pragma GCC diagnostic ignored "-Wfloat-equal"
15137 if (
static_cast<double>(n) >=
static_cast<double>(std::numeric_limits<float>::lowest()) &&
15138 static_cast<double>(n) <=
static_cast<double>((std::numeric_limits<float>::max)()) &&
15139 static_cast<double>(
static_cast<float>(n)) ==
static_cast<double>(n))
15142 ? get_cbor_float_prefix(
static_cast<float>(n))
15143 : get_msgpack_float_prefix(
static_cast<float>(n)));
15144 write_number(
static_cast<float>(n));
15149 ? get_cbor_float_prefix(n)
15150 : get_msgpack_float_prefix(n));
15154#pragma GCC diagnostic pop
15163 template <
typename C = CharType,
15164 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * =
nullptr >
15167 return *
reinterpret_cast<char*
>(&x);
15170 template <
typename C = CharType,
15171 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * =
nullptr >
15174 static_assert(
sizeof(std::uint8_t) ==
sizeof(CharType),
"size of CharType must be equal to std::uint8_t");
15175 static_assert(std::is_trivial<CharType>::value,
"CharType must be trivial");
15177 std::memcpy(&result, &x,
sizeof(x));
15181 template<
typename C = CharType,
15188 template <
typename InputCharType,
typename C = CharType,
15190 std::is_signed<C>::value &&
15191 std::is_signed<char>::value &&
15192 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
15214#include <algorithm>
15223#include <type_traits>
15234#include <type_traits>
15266template<
typename Target,
typename Source>
15269 static_assert(
sizeof(Target) ==
sizeof(Source),
"size mismatch");
15272 std::memcpy(&target, &source,
sizeof(Source));
15283 constexpr diyfp(std::uint64_t f_,
int e_) noexcept :
f(f_),
e(e_) {}
15294 return {x.f - y.f, x.e};
15303 static_assert(
kPrecision == 64,
"internal error");
15328 const std::uint64_t u_lo = x.
f & 0xFFFFFFFFu;
15329 const std::uint64_t u_hi = x.f >> 32u;
15330 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
15331 const std::uint64_t v_hi = y.f >> 32u;
15333 const std::uint64_t p0 = u_lo * v_lo;
15334 const std::uint64_t p1 = u_lo * v_hi;
15335 const std::uint64_t p2 = u_hi * v_lo;
15336 const std::uint64_t p3 = u_hi * v_hi;
15338 const std::uint64_t p0_hi = p0 >> 32u;
15339 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
15340 const std::uint64_t p1_hi = p1 >> 32u;
15341 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
15342 const std::uint64_t p2_hi = p2 >> 32u;
15344 std::uint64_t Q = p0_hi + p1_lo + p2_lo;
15355 Q += std::uint64_t{1} << (64u - 32u - 1u);
15357 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
15359 return {h, x.e + y.e + 64};
15370 while ((x.f >> 63u) == 0)
15385 const int delta = x.
e - target_exponent;
15390 return {x.f << delta, target_exponent};
15407template<
typename FloatType>
15420 static_assert(std::numeric_limits<FloatType>::is_iec559,
15421 "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
15423 constexpr int kPrecision = std::numeric_limits<FloatType>::digits;
15424 constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
15425 constexpr int kMinExp = 1 - kBias;
15426 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1);
15428 using bits_type =
typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
15430 const auto bits =
static_cast<std::uint64_t
>(reinterpret_bits<bits_type>(
value));
15431 const std::uint64_t E = bits >> (kPrecision - 1);
15432 const std::uint64_t F = bits & (kHiddenBit - 1);
15434 const bool is_denormal = E == 0;
15435 const diyfp v = is_denormal
15436 ?
diyfp(F, kMinExp)
15437 :
diyfp(F + kHiddenBit,
static_cast<int>(E) - kBias);
15460 const bool lower_boundary_is_closer = F == 0 && E > 1;
15462 const diyfp m_minus = lower_boundary_is_closer
15463 ?
diyfp(4 * v.
f - 1, v.
e - 2)
15464 :
diyfp(2 * v.
f - 1, v.
e - 1);
15599 constexpr int kCachedPowersMinDecExp = -300;
15600 constexpr int kCachedPowersDecStep = 8;
15602 static constexpr std::array<cached_power, 79> kCachedPowers =
15605 { 0xAB70FE17C79AC6CA, -1060, -300 },
15606 { 0xFF77B1FCBEBCDC4F, -1034, -292 },
15607 { 0xBE5691EF416BD60C, -1007, -284 },
15608 { 0x8DD01FAD907FFC3C, -980, -276 },
15609 { 0xD3515C2831559A83, -954, -268 },
15610 { 0x9D71AC8FADA6C9B5, -927, -260 },
15611 { 0xEA9C227723EE8BCB, -901, -252 },
15612 { 0xAECC49914078536D, -874, -244 },
15613 { 0x823C12795DB6CE57, -847, -236 },
15614 { 0xC21094364DFB5637, -821, -228 },
15615 { 0x9096EA6F3848984F, -794, -220 },
15616 { 0xD77485CB25823AC7, -768, -212 },
15617 { 0xA086CFCD97BF97F4, -741, -204 },
15618 { 0xEF340A98172AACE5, -715, -196 },
15619 { 0xB23867FB2A35B28E, -688, -188 },
15620 { 0x84C8D4DFD2C63F3B, -661, -180 },
15621 { 0xC5DD44271AD3CDBA, -635, -172 },
15622 { 0x936B9FCEBB25C996, -608, -164 },
15623 { 0xDBAC6C247D62A584, -582, -156 },
15624 { 0xA3AB66580D5FDAF6, -555, -148 },
15625 { 0xF3E2F893DEC3F126, -529, -140 },
15626 { 0xB5B5ADA8AAFF80B8, -502, -132 },
15627 { 0x87625F056C7C4A8B, -475, -124 },
15628 { 0xC9BCFF6034C13053, -449, -116 },
15629 { 0x964E858C91BA2655, -422, -108 },
15630 { 0xDFF9772470297EBD, -396, -100 },
15631 { 0xA6DFBD9FB8E5B88F, -369, -92 },
15632 { 0xF8A95FCF88747D94, -343, -84 },
15633 { 0xB94470938FA89BCF, -316, -76 },
15634 { 0x8A08F0F8BF0F156B, -289, -68 },
15635 { 0xCDB02555653131B6, -263, -60 },
15636 { 0x993FE2C6D07B7FAC, -236, -52 },
15637 { 0xE45C10C42A2B3B06, -210, -44 },
15638 { 0xAA242499697392D3, -183, -36 },
15639 { 0xFD87B5F28300CA0E, -157, -28 },
15640 { 0xBCE5086492111AEB, -130, -20 },
15641 { 0x8CBCCC096F5088CC, -103, -12 },
15642 { 0xD1B71758E219652C, -77, -4 },
15643 { 0x9C40000000000000, -50, 4 },
15644 { 0xE8D4A51000000000, -24, 12 },
15645 { 0xAD78EBC5AC620000, 3, 20 },
15646 { 0x813F3978F8940984, 30, 28 },
15647 { 0xC097CE7BC90715B3, 56, 36 },
15648 { 0x8F7E32CE7BEA5C70, 83, 44 },
15649 { 0xD5D238A4ABE98068, 109, 52 },
15650 { 0x9F4F2726179A2245, 136, 60 },
15651 { 0xED63A231D4C4FB27, 162, 68 },
15652 { 0xB0DE65388CC8ADA8, 189, 76 },
15653 { 0x83C7088E1AAB65DB, 216, 84 },
15654 { 0xC45D1DF942711D9A, 242, 92 },
15655 { 0x924D692CA61BE758, 269, 100 },
15656 { 0xDA01EE641A708DEA, 295, 108 },
15657 { 0xA26DA3999AEF774A, 322, 116 },
15658 { 0xF209787BB47D6B85, 348, 124 },
15659 { 0xB454E4A179DD1877, 375, 132 },
15660 { 0x865B86925B9BC5C2, 402, 140 },
15661 { 0xC83553C5C8965D3D, 428, 148 },
15662 { 0x952AB45CFA97A0B3, 455, 156 },
15663 { 0xDE469FBD99A05FE3, 481, 164 },
15664 { 0xA59BC234DB398C25, 508, 172 },
15665 { 0xF6C69A72A3989F5C, 534, 180 },
15666 { 0xB7DCBF5354E9BECE, 561, 188 },
15667 { 0x88FCF317F22241E2, 588, 196 },
15668 { 0xCC20CE9BD35C78A5, 614, 204 },
15669 { 0x98165AF37B2153DF, 641, 212 },
15670 { 0xE2A0B5DC971F303A, 667, 220 },
15671 { 0xA8D9D1535CE3B396, 694, 228 },
15672 { 0xFB9B7CD9A4A7443C, 720, 236 },
15673 { 0xBB764C4CA7A44410, 747, 244 },
15674 { 0x8BAB8EEFB6409C1A, 774, 252 },
15675 { 0xD01FEF10A657842C, 800, 260 },
15676 { 0x9B10A4E5E9913129, 827, 268 },
15677 { 0xE7109BFBA19C0C9D, 853, 276 },
15678 { 0xAC2820D9623BF429, 880, 284 },
15679 { 0x80444B5E7AA7CF85, 907, 292 },
15680 { 0xBF21E44003ACDD2D, 933, 300 },
15681 { 0x8E679C2F5E44FF8F, 960, 308 },
15682 { 0xD433179D9C8CB841, 986, 316 },
15683 { 0x9E19DB92B4E31BA9, 1013, 324 },
15693 const int f =
kAlpha - e - 1;
15694 const int k = (f * 78913) / (1 << 18) +
static_cast<int>(f > 0);
15696 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
15698 JSON_ASSERT(
static_cast<std::size_t
>(index) < kCachedPowers.size());
15700 const cached_power cached = kCachedPowers[
static_cast<std::size_t
>(index)];
15714 if (n >= 1000000000)
15716 pow10 = 1000000000;
15720 if (n >= 100000000)
15765inline void grisu2_round(
char* buf,
int len, std::uint64_t dist, std::uint64_t delta,
15766 std::uint64_t rest, std::uint64_t ten_k)
15793 && delta - rest >= ten_k
15794 && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
15809 static_assert(
kAlpha >= -60,
"internal error");
15810 static_assert(
kGamma <= -32,
"internal error");
15827 std::uint64_t delta =
diyfp::sub(M_plus, M_minus).
f;
15837 const diyfp one(std::uint64_t{1} << -M_plus.
e, M_plus.
e);
15839 auto p1 =
static_cast<std::uint32_t
>(M_plus.
f >> -one.e);
15840 std::uint64_t p2 = M_plus.
f & (one.f - 1);
15848 std::uint32_t pow10{};
15876 const std::uint32_t d = p1 / pow10;
15877 const std::uint32_t r = p1 % pow10;
15883 buffer[length++] =
static_cast<char>(
'0' + d);
15902 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15907 decimal_exponent += n;
15918 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15919 grisu2_round(buffer, length, dist, delta, rest, ten_n);
15980 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15982 const std::uint64_t d = p2 >> -one.e;
15983 const std::uint64_t r = p2 & (one.f - 1);
15990 buffer[length++] =
static_cast<char>(
'0' + d);
16015 decimal_exponent -= m;
16023 const std::uint64_t ten_m = one.f;
16047inline
void grisu2(
char* buf,
int& len,
int& decimal_exponent,
16064 const diyfp c_minus_k(cached.
f, cached.
e);
16092 const diyfp M_minus(w_minus.
f + 1, w_minus.
e);
16093 const diyfp M_plus (w_plus.
f - 1, w_plus.
e );
16095 decimal_exponent = -cached.
k;
16105template<
typename FloatType>
16110 "internal error: not enough precision");
16162 auto k =
static_cast<std::uint32_t
>(e);
16168 *buf++ =
static_cast<char>(
'0' + k);
16172 *buf++ =
static_cast<char>(
'0' + k / 10);
16174 *buf++ =
static_cast<char>(
'0' + k);
16178 *buf++ =
static_cast<char>(
'0' + k / 100);
16180 *buf++ =
static_cast<char>(
'0' + k / 10);
16182 *buf++ =
static_cast<char>(
'0' + k);
16200 int min_exp,
int max_exp)
16206 const int n = len + decimal_exponent;
16212 if (k <= n && n <= max_exp)
16217 std::memset(buf + k,
'0',
static_cast<size_t>(n) -
static_cast<size_t>(k));
16221 return buf + (
static_cast<size_t>(n) + 2);
16224 if (0 < n && n <= max_exp)
16231 std::memmove(buf + (
static_cast<size_t>(n) + 1), buf + n,
static_cast<size_t>(k) -
static_cast<size_t>(n));
16233 return buf + (
static_cast<size_t>(k) + 1U);
16236 if (min_exp < n && n <= 0)
16241 std::memmove(buf + (2 +
static_cast<size_t>(-n)), buf,
static_cast<size_t>(k));
16244 std::memset(buf + 2,
'0',
static_cast<size_t>(-n));
16245 return buf + (2U +
static_cast<size_t>(-n) +
static_cast<size_t>(k));
16260 std::memmove(buf + 2, buf + 1,
static_cast<size_t>(k) - 1);
16262 buf += 1 +
static_cast<size_t>(k);
16281template<
typename FloatType>
16286 static_cast<void>(last);
16290 if (std::signbit(
value))
16297#pragma GCC diagnostic push
16298#pragma GCC diagnostic ignored "-Wfloat-equal"
16309#pragma GCC diagnostic pop
16312 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
16319 int decimal_exponent = 0;
16322 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
16325 constexpr int kMinExp = -4;
16327 constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
16330 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
16331 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
16368template<
typename BasicJsonType>
16388 ,
loc(
std::localeconv())
16426 const bool pretty_print,
16428 const unsigned int indent_step,
16429 const unsigned int current_indent = 0)
16431 switch (val.m_type)
16435 if (val.m_value.object->empty())
16437 o->write_characters(
"{}", 2);
16443 o->write_characters(
"{\n", 2);
16446 const auto new_indent = current_indent + indent_step;
16453 auto i = val.m_value.object->cbegin();
16454 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16457 o->write_character(
'\"');
16459 o->write_characters(
"\": ", 3);
16461 o->write_characters(
",\n", 2);
16466 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16468 o->write_character(
'\"');
16470 o->write_characters(
"\": ", 3);
16473 o->write_character(
'\n');
16474 o->write_characters(
indent_string.c_str(), current_indent);
16475 o->write_character(
'}');
16479 o->write_character(
'{');
16482 auto i = val.m_value.object->cbegin();
16483 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16485 o->write_character(
'\"');
16487 o->write_characters(
"\":", 2);
16489 o->write_character(
',');
16494 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16495 o->write_character(
'\"');
16497 o->write_characters(
"\":", 2);
16500 o->write_character(
'}');
16508 if (val.m_value.array->empty())
16510 o->write_characters(
"[]", 2);
16516 o->write_characters(
"[\n", 2);
16519 const auto new_indent = current_indent + indent_step;
16526 for (
auto i = val.m_value.array->cbegin();
16527 i != val.m_value.array->cend() - 1; ++i)
16531 o->write_characters(
",\n", 2);
16537 dump(val.m_value.array->back(),
true,
ensure_ascii, indent_step, new_indent);
16539 o->write_character(
'\n');
16540 o->write_characters(
indent_string.c_str(), current_indent);
16541 o->write_character(
']');
16545 o->write_character(
'[');
16548 for (
auto i = val.m_value.array->cbegin();
16549 i != val.m_value.array->cend() - 1; ++i)
16552 o->write_character(
',');
16557 dump(val.m_value.array->back(),
false,
ensure_ascii, indent_step, current_indent);
16559 o->write_character(
']');
16567 o->write_character(
'\"');
16569 o->write_character(
'\"');
16577 o->write_characters(
"{\n", 2);
16580 const auto new_indent = current_indent + indent_step;
16588 o->write_characters(
"\"bytes\": [", 10);
16590 if (!val.m_value.binary->empty())
16592 for (
auto i = val.m_value.binary->cbegin();
16593 i != val.m_value.binary->cend() - 1; ++i)
16596 o->write_characters(
", ", 2);
16598 dump_integer(val.m_value.binary->back());
16601 o->write_characters(
"],\n", 3);
16604 o->write_characters(
"\"subtype\": ", 11);
16605 if (val.m_value.binary->has_subtype())
16607 dump_integer(val.m_value.binary->subtype());
16611 o->write_characters(
"null", 4);
16613 o->write_character(
'\n');
16614 o->write_characters(
indent_string.c_str(), current_indent);
16615 o->write_character(
'}');
16619 o->write_characters(
"{\"bytes\":[", 10);
16621 if (!val.m_value.binary->empty())
16623 for (
auto i = val.m_value.binary->cbegin();
16624 i != val.m_value.binary->cend() - 1; ++i)
16627 o->write_character(
',');
16629 dump_integer(val.m_value.binary->back());
16632 o->write_characters(
"],\"subtype\":", 12);
16633 if (val.m_value.binary->has_subtype())
16635 dump_integer(val.m_value.binary->subtype());
16636 o->write_character(
'}');
16640 o->write_characters(
"null}", 5);
16648 if (val.m_value.boolean)
16650 o->write_characters(
"true", 4);
16654 o->write_characters(
"false", 5);
16661 dump_integer(val.m_value.number_integer);
16667 dump_integer(val.m_value.number_unsigned);
16673 dump_float(val.m_value.number_float);
16679 o->write_characters(
"<discarded>", 11);
16685 o->write_characters(
"null", 4);
16711 std::uint32_t codepoint{};
16719 for (std::size_t i = 0; i < s.size(); ++i)
16721 const auto byte =
static_cast<std::uint8_t
>(s[i]);
16723 switch (decode(
state, codepoint,
byte))
16782 if ((codepoint <= 0x1F) || (
ensure_ascii && (codepoint >= 0x7F)))
16784 if (codepoint <= 0xFFFF)
16788 static_cast<std::uint16_t
>(codepoint));
16795 static_cast<std::uint16_t
>(0xD7C0u + (codepoint >> 10u)),
16796 static_cast<std::uint16_t
>(0xDC00u + (codepoint & 0x3FFu)));
16831 std::string sn(9,
'\0');
16833 (std::snprintf)(&sn[0], sn.size(),
"%.2X", byte);
16926 std::string sn(9,
'\0');
16928 (std::snprintf)(&sn[0], sn.size(),
"%.2X",
static_cast<std::uint8_t
>(s.back()));
16946 o->write_characters(
"\\ufffd", 6);
16950 o->write_characters(
"\xEF\xBF\xBD", 3);
16972 unsigned int n_digits = 1;
16981 return n_digits + 1;
16985 return n_digits + 2;
16989 return n_digits + 3;
17006 std::is_integral<NumberType>::value ||
17007 std::is_same<NumberType, number_unsigned_t>::value ||
17008 std::is_same<NumberType, number_integer_t>::value ||
17009 std::is_same<NumberType, binary_char_t>::value,
17011 void dump_integer(NumberType x)
17013 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
17016 {{
'0',
'0'}}, {{
'0',
'1'}}, {{
'0',
'2'}}, {{
'0',
'3'}}, {{
'0',
'4'}}, {{
'0',
'5'}}, {{
'0',
'6'}}, {{
'0',
'7'}}, {{
'0',
'8'}}, {{
'0',
'9'}},
17017 {{
'1',
'0'}}, {{
'1',
'1'}}, {{
'1',
'2'}}, {{
'1',
'3'}}, {{
'1',
'4'}}, {{
'1',
'5'}}, {{
'1',
'6'}}, {{
'1',
'7'}}, {{
'1',
'8'}}, {{
'1',
'9'}},
17018 {{
'2',
'0'}}, {{
'2',
'1'}}, {{
'2',
'2'}}, {{
'2',
'3'}}, {{
'2',
'4'}}, {{
'2',
'5'}}, {{
'2',
'6'}}, {{
'2',
'7'}}, {{
'2',
'8'}}, {{
'2',
'9'}},
17019 {{
'3',
'0'}}, {{
'3',
'1'}}, {{
'3',
'2'}}, {{
'3',
'3'}}, {{
'3',
'4'}}, {{
'3',
'5'}}, {{
'3',
'6'}}, {{
'3',
'7'}}, {{
'3',
'8'}}, {{
'3',
'9'}},
17020 {{
'4',
'0'}}, {{
'4',
'1'}}, {{
'4',
'2'}}, {{
'4',
'3'}}, {{
'4',
'4'}}, {{
'4',
'5'}}, {{
'4',
'6'}}, {{
'4',
'7'}}, {{
'4',
'8'}}, {{
'4',
'9'}},
17021 {{
'5',
'0'}}, {{
'5',
'1'}}, {{
'5',
'2'}}, {{
'5',
'3'}}, {{
'5',
'4'}}, {{
'5',
'5'}}, {{
'5',
'6'}}, {{
'5',
'7'}}, {{
'5',
'8'}}, {{
'5',
'9'}},
17022 {{
'6',
'0'}}, {{
'6',
'1'}}, {{
'6',
'2'}}, {{
'6',
'3'}}, {{
'6',
'4'}}, {{
'6',
'5'}}, {{
'6',
'6'}}, {{
'6',
'7'}}, {{
'6',
'8'}}, {{
'6',
'9'}},
17023 {{
'7',
'0'}}, {{
'7',
'1'}}, {{
'7',
'2'}}, {{
'7',
'3'}}, {{
'7',
'4'}}, {{
'7',
'5'}}, {{
'7',
'6'}}, {{
'7',
'7'}}, {{
'7',
'8'}}, {{
'7',
'9'}},
17024 {{
'8',
'0'}}, {{
'8',
'1'}}, {{
'8',
'2'}}, {{
'8',
'3'}}, {{
'8',
'4'}}, {{
'8',
'5'}}, {{
'8',
'6'}}, {{
'8',
'7'}}, {{
'8',
'8'}}, {{
'8',
'9'}},
17025 {{
'9',
'0'}}, {{
'9',
'1'}}, {{
'9',
'2'}}, {{
'9',
'3'}}, {{
'9',
'4'}}, {{
'9',
'5'}}, {{
'9',
'6'}}, {{
'9',
'7'}}, {{
'9',
'8'}}, {{
'9',
'9'}},
17032 o->write_character(
'0');
17039 const bool is_negative = std::is_signed<NumberType>::value && !(x >= 0);
17042 unsigned int n_chars{};
17050 n_chars = 1 + count_digits(abs_value);
17055 n_chars = count_digits(abs_value);
17063 buffer_ptr += n_chars;
17067 while (abs_value >= 100)
17069 const auto digits_index =
static_cast<unsigned>((abs_value % 100));
17071 *(--buffer_ptr) = digits_to_99[digits_index][1];
17072 *(--buffer_ptr) = digits_to_99[digits_index][0];
17075 if (abs_value >= 10)
17077 const auto digits_index =
static_cast<unsigned>(abs_value);
17078 *(--buffer_ptr) = digits_to_99[digits_index][1];
17079 *(--buffer_ptr) = digits_to_99[digits_index][0];
17083 *(--buffer_ptr) =
static_cast<char>(
'0' + abs_value);
17100 if (!std::isfinite(x))
17102 o->write_characters(
"null", 4);
17111 static constexpr bool is_ieee_single_or_double
17112 = (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) ||
17113 (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);
17115 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
17123 o->write_characters(begin,
static_cast<size_t>(end - begin));
17129 static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
17160 o->write_characters(
number_buffer.data(),
static_cast<std::size_t
>(len));
17163 const bool value_is_int_like =
17167 return c ==
'.' || c ==
'e';
17170 if (value_is_int_like)
17172 o->write_characters(
".0", 2);
17197 static std::uint8_t decode(std::uint8_t&
state, std::uint32_t& codep,
const std::uint8_t
byte)
noexcept
17199 static const std::array<std::uint8_t, 400> utf8d =
17202 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,
17203 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,
17204 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,
17205 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,
17206 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,
17207 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,
17208 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,
17209 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3,
17210 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
17211 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1,
17212 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,
17213 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,
17214 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,
17215 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
17220 const std::uint8_t type = utf8d[byte];
17223 ? (
byte & 0x3fu) | (codep << 6u)
17224 : (0xFFu >> type) & (byte);
17226 std::size_t index = 256u +
static_cast<size_t>(
state) * 16u +
static_cast<size_t>(type);
17228 state = utf8d[index];
17254 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
17260 output_adapter_t<char> o =
nullptr;
17293#include <functional>
17294#include <initializer_list>
17297#include <stdexcept>
17298#include <type_traits>
17310template <
class Key,
class T,
class IgnoredLess = std::less<Key>,
17311 class Allocator = std::allocator<std::pair<const Key, T>>>
17316 using Container = std::vector<std::pair<const Key, T>, Allocator>;
17317 using typename Container::iterator;
17318 using typename Container::const_iterator;
17319 using typename Container::size_type;
17320 using typename Container::value_type;
17325 template <
class It>
17328 ordered_map(std::initializer_list<T> init,
const Allocator& alloc = Allocator() )
17333 for (
auto it = this->begin(); it != this->end(); ++it)
17335 if (it->first == key)
17337 return {it,
false};
17340 Container::emplace_back(key, t);
17341 return {--this->end(),
true};
17346 return emplace(key, T{}).first->second;
17356 for (
auto it = this->begin(); it != this->end(); ++it)
17358 if (it->first == key)
17364 JSON_THROW(std::out_of_range(
"key not found"));
17367 const T&
at(
const Key& key)
const
17369 for (
auto it = this->begin(); it != this->end(); ++it)
17371 if (it->first == key)
17377 JSON_THROW(std::out_of_range(
"key not found"));
17382 for (
auto it = this->begin(); it != this->end(); ++it)
17384 if (it->first == key)
17387 for (
auto next = it; ++next != this->end(); ++it)
17390 new (&*it) value_type{std::move(*next)};
17392 Container::pop_back();
17404 for (
auto next = it; ++next != this->end(); ++it)
17407 new (&*it) value_type{std::move(*next)};
17409 Container::pop_back();
17415 for (
auto it = this->begin(); it != this->end(); ++it)
17417 if (it->first == key)
17427 for (
auto it = this->begin(); it != this->end(); ++it)
17429 if (it->first == key)
17434 return Container::end();
17437 const_iterator
find(
const Key& key)
const
17439 for (
auto it = this->begin(); it != this->end(); ++it)
17441 if (it->first == key)
17446 return Container::end();
17449 std::pair<iterator, bool>
insert( value_type&& value )
17451 return emplace(value.first, std::move(value.second));
17454 std::pair<iterator, bool>
insert(
const value_type& value )
17456 for (
auto it = this->begin(); it != this->end(); ++it)
17458 if (it->first == value.first)
17460 return {it,
false};
17463 Container::push_back(value);
17464 return {--this->end(),
true};
17467 template<
typename InputIt>
17468 using require_input_iter =
typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
17469 std::input_iterator_tag>::value>::type;
17471 template<
typename InputIt,
typename = require_input_iter<InputIt>>
17474 for (
auto it = first; it != last; ++it)
17484#if defined(JSON_HAS_CPP_17)
17485 #include <string_view>
17585 friend ::nlohmann::json_pointer<basic_json>;
17587 template<
typename BasicJsonType,
typename InputType>
17588 friend class ::nlohmann::detail::parser;
17589 friend ::nlohmann::detail::serializer<basic_json>;
17590 template<
typename BasicJsonType>
17591 friend class ::nlohmann::detail::iter_impl;
17592 template<
typename BasicJsonType,
typename CharType>
17593 friend class ::nlohmann::detail::binary_writer;
17594 template<
typename BasicJsonType,
typename InputType,
typename SAX>
17595 friend class ::nlohmann::detail::binary_reader;
17596 template<
typename BasicJsonType>
17597 friend class ::nlohmann::detail::json_sax_dom_parser;
17598 template<
typename BasicJsonType>
17599 friend class ::nlohmann::detail::json_sax_dom_callback_parser;
17600 friend class ::nlohmann::detail::exception;
17609 template<
typename InputAdapterType>
17610 static ::nlohmann::detail::parser<basic_json, InputAdapterType>
parser(
17611 InputAdapterType adapter,
17613 const bool allow_exceptions =
true,
17614 const bool ignore_comments =
false
17617 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
17618 std::move(cb), allow_exceptions, ignore_comments);
17623 template<
typename BasicJsonType>
17625 template<
typename BasicJsonType>
17627 template<
typename Iterator>
17631 template<
typename CharType>
17634 template<
typename InputType>
17645 template<
typename T,
typename SFINAE>
17708 using pointer =
typename std::allocator_traits<allocator_type>::pointer;
17710 using const_pointer =
typename std::allocator_traits<allocator_type>::const_pointer;
17763 result[
"copyright"] =
"(C) 2013-2021 Niels Lohmann";
17764 result[
"name"] =
"JSON for Modern C++";
17765 result[
"url"] =
"https://github.com/nlohmann/json";
17766 result[
"version"][
"string"] =
17775 result[
"platform"] =
"win32";
17776#elif defined __linux__
17777 result[
"platform"] =
"linux";
17778#elif defined __APPLE__
17779 result[
"platform"] =
"apple";
17780#elif defined __unix__
17781 result[
"platform"] =
"unix";
17783 result[
"platform"] =
"unknown";
17786#if defined(__ICC) || defined(__INTEL_COMPILER)
17787 result[
"compiler"] = {{
"family",
"icc"}, {
"version", __INTEL_COMPILER}};
17788#elif defined(__clang__)
17789 result[
"compiler"] = {{
"family",
"clang"}, {
"version", __clang_version__}};
17790#elif defined(__GNUC__) || defined(__GNUG__)
17791 result[
"compiler"] = {{
"family",
"gcc"}, {
"version", std::to_string(__GNUC__) +
"." + std::to_string(__GNUC_MINOR__) +
"." + std::to_string(__GNUC_PATCHLEVEL__)}};
17792#elif defined(__HP_cc) || defined(__HP_aCC)
17793 result[
"compiler"] =
"hp"
17794#elif defined(__IBMCPP__)
17795 result[
"compiler"] = {{
"family",
"ilecpp"}, {
"version", __IBMCPP__}};
17796#elif defined(_MSC_VER)
17797 result[
"compiler"] = {{
"family",
"msvc"}, {
"version", _MSC_VER}};
17798#elif defined(__PGI)
17799 result[
"compiler"] = {{
"family",
"pgcpp"}, {
"version", __PGI}};
17800#elif defined(__SUNPRO_CC)
17801 result[
"compiler"] = {{
"family",
"sunpro"}, {
"version", __SUNPRO_CC}};
17803 result[
"compiler"] = {{
"family",
"unknown"}, {
"version",
"unknown"}};
17807 result[
"compiler"][
"c++"] = std::to_string(__cplusplus);
17809 result[
"compiler"][
"c++"] =
"unknown";
17824#if defined(JSON_HAS_CPP_14)
17918 AllocatorType<std::pair<
const StringType,
17965 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
18332 template<
typename T,
typename... Args>
18336 AllocatorType<T> alloc;
18337 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
18339 auto deleter = [&](T * obj)
18341 AllocatorTraits::deallocate(alloc, obj, 1);
18343 std::unique_ptr<T,
decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
18344 AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
18346 return obj.release();
18413 case value_t::object:
18415 object = create<object_t>();
18419 case value_t::array:
18421 array = create<array_t>();
18425 case value_t::string:
18427 string = create<string_t>(
"");
18431 case value_t::binary:
18433 binary = create<binary_t>();
18437 case value_t::boolean:
18443 case value_t::number_integer:
18449 case value_t::number_unsigned:
18455 case value_t::number_float:
18461 case value_t::null:
18467 case value_t::discarded:
18483 string = create<string_t>(
value);
18489 string = create<string_t>(std::move(
value));
18495 object = create<object_t>(
value);
18501 object = create<object_t>(std::move(
value));
18542 if (t == value_t::array || t == value_t::object)
18545 std::vector<basic_json> stack;
18548 if (t == value_t::array)
18550 stack.reserve(
array->size());
18551 std::move(
array->begin(),
array->end(), std::back_inserter(stack));
18556 for (
auto&& it : *
object)
18558 stack.push_back(std::move(it.second));
18562 while (!stack.empty())
18565 basic_json current_item(std::move(stack.back()));
18572 std::move(current_item.
m_value.array->begin(), current_item.
m_value.array->end(), std::back_inserter(stack));
18574 current_item.
m_value.array->clear();
18578 for (
auto&& it : *current_item.
m_value.object)
18580 stack.push_back(std::move(it.second));
18583 current_item.
m_value.object->clear();
18593 case value_t::object:
18595 AllocatorType<object_t> alloc;
18596 std::allocator_traits<
decltype(alloc)>
::destroy(alloc,
object);
18597 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
object, 1);
18601 case value_t::array:
18603 AllocatorType<array_t> alloc;
18605 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
array, 1);
18609 case value_t::string:
18611 AllocatorType<string_t> alloc;
18612 std::allocator_traits<
decltype(alloc)>
::destroy(alloc,
string);
18613 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
string, 1);
18617 case value_t::binary:
18619 AllocatorType<binary_t> alloc;
18621 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
binary, 1);
18625 case value_t::null:
18626 case value_t::boolean:
18627 case value_t::number_integer:
18628 case value_t::number_unsigned:
18629 case value_t::number_float:
18630 case value_t::discarded:
18665#if JSON_DIAGNOSTICS
18671 return j.m_parent ==
this;
18676 static_cast<void>(check_parents);
18681#if JSON_DIAGNOSTICS
18684 case value_t::array:
18686 for (
auto& element : *
m_value.array)
18688 element.m_parent =
this;
18693 case value_t::object:
18695 for (
auto& element : *
m_value.object)
18697 element.second.m_parent =
this;
18702 case value_t::null:
18703 case value_t::string:
18704 case value_t::boolean:
18705 case value_t::number_integer:
18706 case value_t::number_unsigned:
18707 case value_t::number_float:
18708 case value_t::binary:
18709 case value_t::discarded:
18718#if JSON_DIAGNOSTICS
18721 (it + i)->m_parent =
this;
18724 static_cast<void>(
count);
18731#if JSON_DIAGNOSTICS
18732 if (old_capacity != std::size_t(-1))
18746#ifdef JSON_HEDLEY_MSVC_VERSION
18747#pragma warning(push )
18748#pragma warning(disable : 4127)
18755#ifdef JSON_HEDLEY_MSVC_VERSION
18756#pragma warning( pop )
18761 static_cast<void>(j);
18762 static_cast<void>(old_capacity);
18971 template <
typename CompatibleType,
18976 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
18977 std::forward<CompatibleType>(val))))
18979 JSONSerializer<U>::to_json(*
this, std::forward<CompatibleType>(val));
19010 template <
typename BasicJsonType,
19015 using other_boolean_t =
typename BasicJsonType::boolean_t;
19016 using other_number_float_t =
typename BasicJsonType::number_float_t;
19017 using other_number_integer_t =
typename BasicJsonType::number_integer_t;
19018 using other_number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
19019 using other_string_t =
typename BasicJsonType::string_t;
19020 using other_object_t =
typename BasicJsonType::object_t;
19021 using other_array_t =
typename BasicJsonType::array_t;
19022 using other_binary_t =
typename BasicJsonType::binary_t;
19024 switch (val.type())
19026 case value_t::boolean:
19027 JSONSerializer<other_boolean_t>::to_json(*
this, val.template get<other_boolean_t>());
19029 case value_t::number_float:
19030 JSONSerializer<other_number_float_t>::to_json(*
this, val.template get<other_number_float_t>());
19032 case value_t::number_integer:
19033 JSONSerializer<other_number_integer_t>::to_json(*
this, val.template get<other_number_integer_t>());
19035 case value_t::number_unsigned:
19036 JSONSerializer<other_number_unsigned_t>::to_json(*
this, val.template get<other_number_unsigned_t>());
19038 case value_t::string:
19039 JSONSerializer<other_string_t>::to_json(*
this, val.template get_ref<const other_string_t&>());
19041 case value_t::object:
19042 JSONSerializer<other_object_t>::to_json(*
this, val.template get_ref<const other_object_t&>());
19044 case value_t::array:
19045 JSONSerializer<other_array_t>::to_json(*
this, val.template get_ref<const other_array_t&>());
19047 case value_t::binary:
19048 JSONSerializer<other_binary_t>::to_json(*
this, val.template get_ref<const other_binary_t&>());
19050 case value_t::null:
19053 case value_t::discarded:
19054 m_type = value_t::discarded;
19138 bool type_deduction =
true,
19139 value_t manual_type = value_t::array)
19143 bool is_an_object = std::all_of(init.begin(), init.end(),
19146 return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
19150 if (!type_deduction)
19153 if (manual_type == value_t::array)
19155 is_an_object =
false;
19168 m_type = value_t::object;
19171 for (
auto& element_ref : init)
19175 std::move(*((*element.m_value.array)[0].m_value.string)),
19176 std::move((*element.m_value.array)[1]));
19182 m_type = value_t::array;
19183 m_value.array = create<array_t>(init.begin(), init.end());
19221 res.m_type = value_t::binary;
19222 res.m_value = init;
19258 res.m_type = value_t::binary;
19259 res.m_value =
binary_t(init, subtype);
19268 res.m_type = value_t::binary;
19269 res.m_value = std::move(init);
19278 res.m_type = value_t::binary;
19279 res.m_value =
binary_t(std::move(init), subtype);
19323 return basic_json(init,
false, value_t::array);
19367 return basic_json(init,
false, value_t::object);
19395 m_value.array = create<array_t>(cnt, val);
19455 template <
class InputIT,
typename std::enable_if <
19456 std::is_same<InputIT, typename basic_json_t::iterator>::value ||
19457 std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
int >
::type = 0 >
19470 m_type = first.m_object->m_type;
19475 case value_t::boolean:
19476 case value_t::number_float:
19477 case value_t::number_integer:
19478 case value_t::number_unsigned:
19479 case value_t::string:
19482 || !last.m_it.primitive_iterator.is_end()))
19489 case value_t::null:
19490 case value_t::object:
19491 case value_t::array:
19492 case value_t::binary:
19493 case value_t::discarded:
19500 case value_t::number_integer:
19502 m_value.number_integer = first.m_object->m_value.number_integer;
19506 case value_t::number_unsigned:
19508 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
19512 case value_t::number_float:
19514 m_value.number_float = first.m_object->m_value.number_float;
19518 case value_t::boolean:
19520 m_value.boolean = first.m_object->m_value.boolean;
19524 case value_t::string:
19526 m_value = *first.m_object->m_value.string;
19530 case value_t::object:
19532 m_value.object = create<object_t>(first.m_it.object_iterator,
19533 last.m_it.object_iterator);
19537 case value_t::array:
19539 m_value.array = create<array_t>(first.m_it.array_iterator,
19540 last.m_it.array_iterator);
19544 case value_t::binary:
19546 m_value = *first.m_object->m_value.binary;
19550 case value_t::null:
19551 case value_t::discarded:
19565 template<
typename JsonRef,
19567 std::is_same<typename JsonRef::value_type, basic_json>>
::value,
int> = 0 >
19596 : m_type(other.m_type)
19603 case value_t::object:
19609 case value_t::array:
19615 case value_t::string:
19621 case value_t::boolean:
19627 case value_t::number_integer:
19633 case value_t::number_unsigned:
19639 case value_t::number_float:
19645 case value_t::binary:
19651 case value_t::null:
19652 case value_t::discarded:
19688 : m_type(std::move(other.m_type)),
19689 m_value(std::move(other.m_value))
19692 other.assert_invariant(
false);
19695 other.m_type = value_t::null;
19696 other.m_value = {};
19726 std::is_nothrow_move_constructible<value_t>::value&&
19727 std::is_nothrow_move_assignable<value_t>::value&&
19728 std::is_nothrow_move_constructible<json_value>::value&&
19729 std::is_nothrow_move_assignable<json_value>::value
19736 swap(m_type, other.m_type);
19824 const char indent_char =
' ',
19825 const bool ensure_ascii =
false,
19833 s.dump(*
this,
true, ensure_ascii,
static_cast<unsigned int>(indent));
19837 s.dump(*
this,
false, ensure_ascii, 0);
19958 return m_type == value_t::null;
19980 return m_type == value_t::boolean;
20039 return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
20067 return m_type == value_t::number_unsigned;
20095 return m_type == value_t::number_float;
20117 return m_type == value_t::object;
20139 return m_type == value_t::array;
20161 return m_type == value_t::string;
20183 return m_type == value_t::binary;
20210 return m_type == value_t::discarded;
20364 template<
typename ReferenceType,
typename ThisType>
20368 auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
20409 template<
typename PointerType,
typename std::enable_if<
20410 std::is_pointer<PointerType>::value,
int>
::type = 0>
20414 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20421 template <
typename PointerType,
typename std::enable_if <
20422 std::is_pointer<PointerType>::value&&
20423 std::is_const<typename std::remove_pointer<PointerType>::type>
::value,
int >
::type = 0 >
20427 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20469 template <
typename ValueType,
20475 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20478 JSONSerializer<ValueType>::from_json(*
this, ret);
20512 template <
typename ValueType,
20517 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20519 return JSONSerializer<ValueType>::from_json(*
this);
20537 template <
typename BasicJsonType,
20560 template<
typename BasicJsonType,
20562 std::is_same<BasicJsonType, basic_json_t>::value,
20573 template<
typename PointerType,
20575 std::is_pointer<PointerType>::value,
20578 ->
decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
20581 return get_ptr<PointerType>();
20608 template <
typename ValueTypeCV,
typename ValueType = detail::uncvref_t<ValueTypeCV>>
20609#if defined(JSON_HAS_CPP_14)
20619 static_assert(!std::is_reference<ValueTypeCV>::value,
20620 "get() cannot be used with reference types, you might want to use get_ref()");
20621 return get_impl<ValueType>(detail::priority_tag<4> {});
20651 template<
typename PointerType,
typename std::enable_if<
20652 std::is_pointer<PointerType>::value,
int>
::type = 0>
20656 return get_ptr<PointerType>();
20692 template <
typename ValueType,
20697 ValueType &
get_to(ValueType& v)
const noexcept(
noexcept(
20698 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
20700 JSONSerializer<ValueType>::from_json(*
this, v);
20706 template<
typename ValueType,
20717 typename T, std::size_t N,
20718 typename Array = T (&)[N],
20722 noexcept(
noexcept(JSONSerializer<Array>::from_json(
20723 std::declval<const basic_json_t&>(), v)))
20725 JSONSerializer<Array>::from_json(*
this, v);
20755 template<
typename ReferenceType,
typename std::enable_if<
20756 std::is_reference<ReferenceType>::value,
int>
::type = 0>
20760 return get_ref_impl<ReferenceType>(*
this);
20767 template <
typename ReferenceType,
typename std::enable_if <
20768 std::is_reference<ReferenceType>::value&&
20769 std::is_const<typename std::remove_reference<ReferenceType>::type>
::value,
int >
::type = 0 >
20773 return get_ref_impl<ReferenceType>(*
this);
20805 template <
typename ValueType,
typename std::enable_if <
20813#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
20821 return get<ValueType>();
20840 return *get_ptr<binary_t*>();
20851 return *get_ptr<const binary_t*>();
21091 m_type = value_t::array;
21100 if (idx >=
m_value.array->size())
21102#if JSON_DIAGNOSTICS
21104 const auto previous_size =
m_value.array->size();
21106 m_value.array->resize(idx + 1);
21108#if JSON_DIAGNOSTICS
21114 return m_value.array->operator[](idx);
21182 m_type = value_t::object;
21232 return m_value.object->find(key)->second;
21265 template<
typename T>
21272 m_type = value_t::object;
21316 template<
typename T>
21324 return m_value.object->find(key)->second;
21381 template <
class ValueType,
typename std::enable_if <
21383 && !std::is_same<value_t, ValueType>::value,
int >
::type = 0 >
21384 ValueType
value(
const typename object_t::key_type& key,
const ValueType& default_value)
const
21390 const auto it =
find(key);
21393 return it->template get<ValueType>();
21396 return default_value;
21406 string_t value(
const typename object_t::key_type& key,
const char* default_value)
const
21454 template<
class ValueType,
typename std::enable_if<
21464 return ptr.
get_checked(
this).template get<ValueType>();
21468 return default_value;
21617 template <
class IteratorType,
typename std::enable_if <
21618 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21619 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21629 IteratorType result =
end();
21633 case value_t::boolean:
21634 case value_t::number_float:
21635 case value_t::number_integer:
21636 case value_t::number_unsigned:
21637 case value_t::string:
21638 case value_t::binary:
21647 AllocatorType<string_t> alloc;
21649 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21654 AllocatorType<binary_t> alloc;
21656 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21660 m_type = value_t::null;
21665 case value_t::object:
21667 result.m_it.object_iterator =
m_value.object->erase(pos.m_it.object_iterator);
21671 case value_t::array:
21673 result.m_it.array_iterator =
m_value.array->erase(pos.m_it.array_iterator);
21677 case value_t::null:
21678 case value_t::discarded:
21732 template <
class IteratorType,
typename std::enable_if <
21733 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21734 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21736 IteratorType
erase(IteratorType first, IteratorType last)
21744 IteratorType result =
end();
21748 case value_t::boolean:
21749 case value_t::number_float:
21750 case value_t::number_integer:
21751 case value_t::number_unsigned:
21752 case value_t::string:
21753 case value_t::binary:
21756 || !last.m_it.primitive_iterator.is_end()))
21763 AllocatorType<string_t> alloc;
21765 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21770 AllocatorType<binary_t> alloc;
21772 std::allocator_traits<
decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21776 m_type = value_t::null;
21781 case value_t::object:
21783 result.m_it.object_iterator =
m_value.object->erase(first.m_it.object_iterator,
21784 last.m_it.object_iterator);
21788 case value_t::array:
21790 result.m_it.array_iterator =
m_value.array->erase(first.m_it.array_iterator,
21791 last.m_it.array_iterator);
21795 case value_t::null:
21796 case value_t::discarded:
21838 return m_value.object->erase(key);
21920 template<
typename KeyT>
21923 auto result =
end();
21927 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
21937 template<
typename KeyT>
21940 auto result =
cend();
21944 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
21971 template<
typename KeyT>
22003 template <
typename KeyT,
typename std::enable_if <
22078 result.set_begin();
22118 result.set_begin();
22385 return ref.items();
22394 return ref.items();
22534 case value_t::null:
22540 case value_t::array:
22543 return m_value.array->empty();
22546 case value_t::object:
22549 return m_value.object->empty();
22552 case value_t::string:
22553 case value_t::boolean:
22554 case value_t::number_integer:
22555 case value_t::number_unsigned:
22556 case value_t::number_float:
22557 case value_t::binary:
22558 case value_t::discarded:
22614 case value_t::null:
22620 case value_t::array:
22623 return m_value.array->size();
22626 case value_t::object:
22629 return m_value.object->size();
22632 case value_t::string:
22633 case value_t::boolean:
22634 case value_t::number_integer:
22635 case value_t::number_unsigned:
22636 case value_t::number_float:
22637 case value_t::binary:
22638 case value_t::discarded:
22692 case value_t::array:
22695 return m_value.array->max_size();
22698 case value_t::object:
22701 return m_value.object->max_size();
22704 case value_t::null:
22705 case value_t::string:
22706 case value_t::boolean:
22707 case value_t::number_integer:
22708 case value_t::number_unsigned:
22709 case value_t::number_float:
22710 case value_t::binary:
22711 case value_t::discarded:
22771 case value_t::number_integer:
22777 case value_t::number_unsigned:
22783 case value_t::number_float:
22789 case value_t::boolean:
22795 case value_t::string:
22801 case value_t::binary:
22807 case value_t::array:
22813 case value_t::object:
22819 case value_t::null:
22820 case value_t::discarded:
22857 m_type = value_t::array;
22863 const auto old_capacity =
m_value.array->capacity();
22864 m_value.array->push_back(std::move(val));
22894 m_type = value_t::array;
22900 const auto old_capacity =
m_value.array->capacity();
22901 m_value.array->push_back(val);
22946 m_type = value_t::object;
22952 auto res =
m_value.object->insert(val);
22993 if (
is_object() && init.size() == 2 && (*init.begin())->is_string())
22995 basic_json&& key = init.begin()->moved_or_copied();
22996 push_back(
typename object_t::value_type(
22997 std::move(key.get_ref<
string_t&>()), (init.begin() + 1)->moved_or_copied()));
23038 template<
class... Args>
23050 m_type = value_t::array;
23056 const auto old_capacity =
m_value.array->capacity();
23057 m_value.array->emplace_back(std::forward<Args>(args)...);
23088 template<
class... Args>
23100 m_type = value_t::object;
23106 auto res =
m_value.object->emplace(std::forward<Args>(args)...);
23111 it.m_it.object_iterator = res.first;
23114 return {it, res.second};
23120 template<
typename... Args>
23184 return insert(pos, val);
23400 m_type = value_t::object;
23401 m_value.object = create<object_t>();
23414 for (
auto it = j.
cbegin(); it != j.
cend(); ++it)
23416 m_value.object->operator[](it.key()) = it.value();
23451 m_type = value_t::object;
23452 m_value.object = create<object_t>();
23469 || !last.m_object->is_object()))
23474 for (
auto it = first; it != last; ++it)
23476 m_value.object->operator[](it.key()) = it.value();
23498 std::is_nothrow_move_constructible<value_t>::value&&
23499 std::is_nothrow_move_assignable<value_t>::value&&
23500 std::is_nothrow_move_constructible<json_value>::value&&
23501 std::is_nothrow_move_assignable<json_value>::value
23504 std::swap(m_type, other.m_type);
23505 std::swap(
m_value, other.m_value);
23508 other.set_parents();
23531 std::is_nothrow_move_constructible<value_t>::value&&
23532 std::is_nothrow_move_assignable<value_t>::value&&
23533 std::is_nothrow_move_constructible<json_value>::value&&
23534 std::is_nothrow_move_assignable<json_value>::value
23565 std::swap(*(
m_value.array), other);
23598 std::swap(*(
m_value.object), other);
23631 std::swap(*(
m_value.string), other);
23664 std::swap(*(
m_value.binary), other);
23678 std::swap(*(
m_value.binary), other);
23754#pragma GCC diagnostic push
23755#pragma GCC diagnostic ignored "-Wfloat-equal"
23757 const auto lhs_type = lhs.type();
23758 const auto rhs_type = rhs.type();
23760 if (lhs_type == rhs_type)
23764 case value_t::array:
23765 return *lhs.m_value.array == *rhs.m_value.array;
23767 case value_t::object:
23768 return *lhs.m_value.object == *rhs.m_value.object;
23770 case value_t::null:
23773 case value_t::string:
23774 return *lhs.m_value.string == *rhs.m_value.string;
23776 case value_t::boolean:
23777 return lhs.m_value.boolean == rhs.m_value.boolean;
23779 case value_t::number_integer:
23780 return lhs.m_value.number_integer == rhs.m_value.number_integer;
23782 case value_t::number_unsigned:
23783 return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
23785 case value_t::number_float:
23786 return lhs.m_value.number_float == rhs.m_value.number_float;
23788 case value_t::binary:
23789 return *lhs.m_value.binary == *rhs.m_value.binary;
23791 case value_t::discarded:
23796 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23798 return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
23800 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23802 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_integer);
23804 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23806 return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
23808 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23810 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23812 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23814 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
23816 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23818 return lhs.m_value.number_integer ==
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23823#pragma GCC diagnostic pop
23831 template<
typename ScalarType,
typename std::enable_if<
23832 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23842 template<
typename ScalarType,
typename std::enable_if<
23843 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23869 return !(lhs == rhs);
23876 template<
typename ScalarType,
typename std::enable_if<
23877 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23887 template<
typename ScalarType,
typename std::enable_if<
23888 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23922 const auto lhs_type = lhs.type();
23923 const auto rhs_type = rhs.type();
23925 if (lhs_type == rhs_type)
23929 case value_t::array:
23932 return (*lhs.m_value.array) < (*rhs.m_value.array);
23934 case value_t::object:
23935 return (*lhs.m_value.object) < (*rhs.m_value.object);
23937 case value_t::null:
23940 case value_t::string:
23941 return (*lhs.m_value.string) < (*rhs.m_value.string);
23943 case value_t::boolean:
23944 return (lhs.m_value.boolean) < (rhs.m_value.boolean);
23946 case value_t::number_integer:
23947 return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
23949 case value_t::number_unsigned:
23950 return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
23952 case value_t::number_float:
23953 return (lhs.m_value.number_float) < (rhs.m_value.number_float);
23955 case value_t::binary:
23956 return (*lhs.m_value.binary) < (*rhs.m_value.binary);
23958 case value_t::discarded:
23963 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23965 return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
23967 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23969 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_integer);
23971 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23973 return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
23975 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23977 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23979 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23981 return lhs.m_value.number_integer <
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23983 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23985 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
23998 template<
typename ScalarType,
typename std::enable_if<
23999 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24009 template<
typename ScalarType,
typename std::enable_if<
24010 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24037 return !(rhs < lhs);
24044 template<
typename ScalarType,
typename std::enable_if<
24045 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24055 template<
typename ScalarType,
typename std::enable_if<
24056 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24083 return !(lhs <= rhs);
24090 template<
typename ScalarType,
typename std::enable_if<
24091 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24101 template<
typename ScalarType,
typename std::enable_if<
24102 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24129 return !(lhs < rhs);
24136 template<
typename ScalarType,
typename std::enable_if<
24137 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24147 template<
typename ScalarType,
typename std::enable_if<
24148 std::is_scalar<ScalarType>::value,
int>
::type = 0>
24197 const bool pretty_print = o.width() > 0;
24198 const auto indentation = pretty_print ? o.width() : 0;
24205 s.dump(j, pretty_print,
false,
static_cast<unsigned int>(indentation));
24284 template<
typename InputType>
24288 const bool allow_exceptions =
true,
24289 const bool ignore_comments =
false)
24322 template<
typename IteratorType>
24327 const bool allow_exceptions =
true,
24328 const bool ignore_comments =
false)
24339 const
bool allow_exceptions = true,
24340 const
bool ignore_comments = false)
24343 parser(i.get(), cb, allow_exceptions, ignore_comments).
parse(
true, result);
24377 template<
typename InputType>
24379 const bool ignore_comments =
false)
24384 template<
typename IteratorType>
24385 static bool accept(IteratorType first, IteratorType last,
24386 const bool ignore_comments =
false)
24393 static
bool accept(detail::span_input_adapter&& i,
24394 const
bool ignore_comments = false)
24396 return parser(i.get(),
nullptr,
false, ignore_comments).accept(
true);
24439 template <
typename InputType,
typename SAX>
24443 const
bool strict = true,
24444 const
bool ignore_comments = false)
24447 return format == input_format_t::json
24448 ?
parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24452 template<
class IteratorType,
class SAX>
24454 static
bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
24456 const
bool strict = true,
24457 const
bool ignore_comments = false)
24460 return format == input_format_t::json
24461 ?
parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24465 template <
typename SAX>
24470 const
bool strict = true,
24471 const
bool ignore_comments = false)
24474 return format == input_format_t::json
24476 ?
parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24569 case value_t::null:
24571 case value_t::object:
24573 case value_t::array:
24575 case value_t::string:
24577 case value_t::boolean:
24579 case value_t::binary:
24581 case value_t::discarded:
24582 return "discarded";
24583 case value_t::number_integer:
24584 case value_t::number_unsigned:
24585 case value_t::number_float:
24599 value_t m_type = value_t::null;
24604#if JSON_DIAGNOSTICS
24717 std::vector<std::uint8_t> result;
24812 std::vector<std::uint8_t> result;
24914 const bool use_size =
false,
24915 const bool use_type =
false)
24917 std::vector<std::uint8_t> result;
24918 to_ubjson(j, result, use_size, use_type);
24923 const bool use_size =
false,
const bool use_type =
false)
24929 const bool use_size =
false,
const bool use_type =
false)
24993 std::vector<std::uint8_t> result;
25122 template<
typename InputType>
25125 const bool strict =
true,
25126 const bool allow_exceptions =
true,
25133 return res ? result :
basic_json(value_t::discarded);
25139 template<
typename IteratorType>
25142 const bool strict =
true,
25143 const bool allow_exceptions =
true,
25150 return res ? result :
basic_json(value_t::discarded);
25153 template<
typename T>
25157 const
bool strict = true,
25158 const
bool allow_exceptions = true,
25161 return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
25168 const
bool strict = true,
25169 const
bool allow_exceptions = true,
25177 return res ? result :
basic_json(value_t::discarded);
25266 template<
typename InputType>
25269 const bool strict =
true,
25270 const bool allow_exceptions =
true)
25276 return res ? result :
basic_json(value_t::discarded);
25282 template<
typename IteratorType>
25285 const bool strict =
true,
25286 const bool allow_exceptions =
true)
25292 return res ? result :
basic_json(value_t::discarded);
25296 template<
typename T>
25300 const
bool strict = true,
25301 const
bool allow_exceptions = true)
25303 return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
25309 const
bool strict = true,
25310 const
bool allow_exceptions = true)
25317 return res ? result :
basic_json(value_t::discarded);
25383 template<
typename InputType>
25386 const bool strict =
true,
25387 const bool allow_exceptions =
true)
25393 return res ? result :
basic_json(value_t::discarded);
25399 template<
typename IteratorType>
25402 const bool strict =
true,
25403 const bool allow_exceptions =
true)
25409 return res ? result :
basic_json(value_t::discarded);
25412 template<
typename T>
25416 const
bool strict = true,
25417 const
bool allow_exceptions = true)
25419 return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
25425 const
bool strict = true,
25426 const
bool allow_exceptions = true)
25433 return res ? result :
basic_json(value_t::discarded);
25497 template<
typename InputType>
25500 const bool strict =
true,
25501 const bool allow_exceptions =
true)
25507 return res ? result :
basic_json(value_t::discarded);
25513 template<
typename IteratorType>
25516 const bool strict =
true,
25517 const bool allow_exceptions =
true)
25523 return res ? result :
basic_json(value_t::discarded);
25526 template<
typename T>
25530 const
bool strict = true,
25531 const
bool allow_exceptions = true)
25533 return from_bson(ptr, ptr + len, strict, allow_exceptions);
25539 const
bool strict = true,
25540 const
bool allow_exceptions = true)
25547 return res ? result :
basic_json(value_t::discarded);
25836 enum class patch_operations {add, remove, replace, move, copy, test, invalid};
25838 const auto get_op = [](
const std::string & op)
25842 return patch_operations::add;
25844 if (op ==
"remove")
25846 return patch_operations::remove;
25848 if (op ==
"replace")
25850 return patch_operations::replace;
25854 return patch_operations::move;
25858 return patch_operations::copy;
25862 return patch_operations::test;
25865 return patch_operations::invalid;
25880 if (top_pointer != ptr)
25882 result.
at(top_pointer);
25886 const auto last_path = ptr.
back();
25890 switch (parent.m_type)
25892 case value_t::null:
25893 case value_t::object:
25896 parent[last_path] = val;
25900 case value_t::array:
25902 if (last_path ==
"-")
25923 case value_t::string:
25924 case value_t::boolean:
25925 case value_t::number_integer:
25926 case value_t::number_unsigned:
25927 case value_t::number_float:
25928 case value_t::binary:
25929 case value_t::discarded:
25936 const auto operation_remove = [
this, &result](
json_pointer & ptr)
25939 const auto last_path = ptr.
back();
25947 auto it = parent.
find(last_path);
25971 for (
const auto& val : json_patch)
25974 const auto get_value = [&val](
const std::string & op,
25975 const std::string & member,
25979 auto it = val.
m_value.object->find(member);
25982 const auto error_msg = (op ==
"op") ?
"operation" :
"operation '" + op +
"'";
26009 const auto op = get_value(
"op",
"op",
true).template get<std::string>();
26010 const auto path = get_value(op,
"path",
true).template get<std::string>();
26013 switch (get_op(op))
26015 case patch_operations::add:
26017 operation_add(ptr, get_value(
"add",
"value",
false));
26021 case patch_operations::remove:
26023 operation_remove(ptr);
26027 case patch_operations::replace:
26030 result.
at(ptr) = get_value(
"replace",
"value",
false);
26034 case patch_operations::move:
26036 const auto from_path = get_value(
"move",
"from",
true).template get<std::string>();
26046 operation_remove(from_ptr);
26047 operation_add(ptr, v);
26051 case patch_operations::copy:
26053 const auto from_path = get_value(
"copy",
"from",
true).template get<std::string>();
26062 operation_add(ptr, v);
26066 case patch_operations::test:
26068 bool success =
false;
26073 success = (result.
at(ptr) == get_value(
"test",
"value",
false));
26089 case patch_operations::invalid:
26137 const std::string& path =
"")
26143 if (source == target)
26148 if (source.
type() != target.
type())
26153 {
"op",
"replace"}, {
"path", path}, {
"value", target}
26158 switch (source.
type())
26160 case value_t::array:
26164 while (i < source.
size() && i < target.
size())
26167 auto temp_diff =
diff(source[i], target[i], path +
"/" + std::to_string(i));
26168 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
26177 while (i < source.
size())
26184 {
"path", path +
"/" + std::to_string(i)}
26190 while (i < target.
size())
26195 {
"path", path +
"/-"},
26196 {
"value", target[i]}
26204 case value_t::object:
26207 for (
auto it = source.
cbegin(); it != source.
cend(); ++it)
26212 if (target.
find(it.key()) != target.
end())
26215 auto temp_diff =
diff(it.value(), target[it.key()], path_key);
26216 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
26223 {
"op",
"remove"}, {
"path", path_key}
26229 for (
auto it = target.
cbegin(); it != target.
cend(); ++it)
26231 if (source.
find(it.key()) == source.
end())
26237 {
"op",
"add"}, {
"path", path_key},
26238 {
"value", it.value()}
26246 case value_t::null:
26247 case value_t::string:
26248 case value_t::boolean:
26249 case value_t::number_integer:
26250 case value_t::number_unsigned:
26251 case value_t::number_float:
26252 case value_t::binary:
26253 case value_t::discarded:
26259 {
"op",
"replace"}, {
"path", path}, {
"value", target}
26327 for (
auto it = apply_patch.
begin(); it != apply_patch.
end(); ++it)
26329 if (it.value().is_null())
26341 *
this = apply_patch;
26405#ifndef JSON_HAS_CPP_20
26414 is_nothrow_move_constructible<nlohmann::json>::value&&
26415 is_nothrow_move_assignable<nlohmann::json>::value
26467#if defined(__clang__)
26468 #pragma clang diagnostic pop
26473#undef JSON_INTERNAL_CATCH
26477#undef JSON_PRIVATE_UNLESS_TESTED
26478#undef JSON_HAS_CPP_11
26479#undef JSON_HAS_CPP_14
26480#undef JSON_HAS_CPP_17
26481#undef JSON_HAS_CPP_20
26482#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
26483#undef NLOHMANN_BASIC_JSON_TPL
26484#undef JSON_EXPLICIT
26489#undef JSON_HEDLEY_ALWAYS_INLINE
26490#undef JSON_HEDLEY_ARM_VERSION
26491#undef JSON_HEDLEY_ARM_VERSION_CHECK
26492#undef JSON_HEDLEY_ARRAY_PARAM
26493#undef JSON_HEDLEY_ASSUME
26494#undef JSON_HEDLEY_BEGIN_C_DECLS
26495#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
26496#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
26497#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
26498#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
26499#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
26500#undef JSON_HEDLEY_CLANG_HAS_FEATURE
26501#undef JSON_HEDLEY_CLANG_HAS_WARNING
26502#undef JSON_HEDLEY_COMPCERT_VERSION
26503#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
26504#undef JSON_HEDLEY_CONCAT
26505#undef JSON_HEDLEY_CONCAT3
26506#undef JSON_HEDLEY_CONCAT3_EX
26507#undef JSON_HEDLEY_CONCAT_EX
26508#undef JSON_HEDLEY_CONST
26509#undef JSON_HEDLEY_CONSTEXPR
26510#undef JSON_HEDLEY_CONST_CAST
26511#undef JSON_HEDLEY_CPP_CAST
26512#undef JSON_HEDLEY_CRAY_VERSION
26513#undef JSON_HEDLEY_CRAY_VERSION_CHECK
26514#undef JSON_HEDLEY_C_DECL
26515#undef JSON_HEDLEY_DEPRECATED
26516#undef JSON_HEDLEY_DEPRECATED_FOR
26517#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
26518#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
26519#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
26520#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
26521#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
26522#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
26523#undef JSON_HEDLEY_DIAGNOSTIC_POP
26524#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
26525#undef JSON_HEDLEY_DMC_VERSION
26526#undef JSON_HEDLEY_DMC_VERSION_CHECK
26527#undef JSON_HEDLEY_EMPTY_BASES
26528#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
26529#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
26530#undef JSON_HEDLEY_END_C_DECLS
26531#undef JSON_HEDLEY_FLAGS
26532#undef JSON_HEDLEY_FLAGS_CAST
26533#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
26534#undef JSON_HEDLEY_GCC_HAS_BUILTIN
26535#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
26536#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
26537#undef JSON_HEDLEY_GCC_HAS_EXTENSION
26538#undef JSON_HEDLEY_GCC_HAS_FEATURE
26539#undef JSON_HEDLEY_GCC_HAS_WARNING
26540#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
26541#undef JSON_HEDLEY_GCC_VERSION
26542#undef JSON_HEDLEY_GCC_VERSION_CHECK
26543#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
26544#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
26545#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
26546#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
26547#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
26548#undef JSON_HEDLEY_GNUC_HAS_FEATURE
26549#undef JSON_HEDLEY_GNUC_HAS_WARNING
26550#undef JSON_HEDLEY_GNUC_VERSION
26551#undef JSON_HEDLEY_GNUC_VERSION_CHECK
26552#undef JSON_HEDLEY_HAS_ATTRIBUTE
26553#undef JSON_HEDLEY_HAS_BUILTIN
26554#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
26555#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
26556#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
26557#undef JSON_HEDLEY_HAS_EXTENSION
26558#undef JSON_HEDLEY_HAS_FEATURE
26559#undef JSON_HEDLEY_HAS_WARNING
26560#undef JSON_HEDLEY_IAR_VERSION
26561#undef JSON_HEDLEY_IAR_VERSION_CHECK
26562#undef JSON_HEDLEY_IBM_VERSION
26563#undef JSON_HEDLEY_IBM_VERSION_CHECK
26564#undef JSON_HEDLEY_IMPORT
26565#undef JSON_HEDLEY_INLINE
26566#undef JSON_HEDLEY_INTEL_CL_VERSION
26567#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
26568#undef JSON_HEDLEY_INTEL_VERSION
26569#undef JSON_HEDLEY_INTEL_VERSION_CHECK
26570#undef JSON_HEDLEY_IS_CONSTANT
26571#undef JSON_HEDLEY_IS_CONSTEXPR_
26572#undef JSON_HEDLEY_LIKELY
26573#undef JSON_HEDLEY_MALLOC
26574#undef JSON_HEDLEY_MCST_LCC_VERSION
26575#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
26576#undef JSON_HEDLEY_MESSAGE
26577#undef JSON_HEDLEY_MSVC_VERSION
26578#undef JSON_HEDLEY_MSVC_VERSION_CHECK
26579#undef JSON_HEDLEY_NEVER_INLINE
26580#undef JSON_HEDLEY_NON_NULL
26581#undef JSON_HEDLEY_NO_ESCAPE
26582#undef JSON_HEDLEY_NO_RETURN
26583#undef JSON_HEDLEY_NO_THROW
26584#undef JSON_HEDLEY_NULL
26585#undef JSON_HEDLEY_PELLES_VERSION
26586#undef JSON_HEDLEY_PELLES_VERSION_CHECK
26587#undef JSON_HEDLEY_PGI_VERSION
26588#undef JSON_HEDLEY_PGI_VERSION_CHECK
26589#undef JSON_HEDLEY_PREDICT
26590#undef JSON_HEDLEY_PRINTF_FORMAT
26591#undef JSON_HEDLEY_PRIVATE
26592#undef JSON_HEDLEY_PUBLIC
26593#undef JSON_HEDLEY_PURE
26594#undef JSON_HEDLEY_REINTERPRET_CAST
26595#undef JSON_HEDLEY_REQUIRE
26596#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
26597#undef JSON_HEDLEY_REQUIRE_MSG
26598#undef JSON_HEDLEY_RESTRICT
26599#undef JSON_HEDLEY_RETURNS_NON_NULL
26600#undef JSON_HEDLEY_SENTINEL
26601#undef JSON_HEDLEY_STATIC_ASSERT
26602#undef JSON_HEDLEY_STATIC_CAST
26603#undef JSON_HEDLEY_STRINGIFY
26604#undef JSON_HEDLEY_STRINGIFY_EX
26605#undef JSON_HEDLEY_SUNPRO_VERSION
26606#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
26607#undef JSON_HEDLEY_TINYC_VERSION
26608#undef JSON_HEDLEY_TINYC_VERSION_CHECK
26609#undef JSON_HEDLEY_TI_ARMCL_VERSION
26610#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
26611#undef JSON_HEDLEY_TI_CL2000_VERSION
26612#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
26613#undef JSON_HEDLEY_TI_CL430_VERSION
26614#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
26615#undef JSON_HEDLEY_TI_CL6X_VERSION
26616#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
26617#undef JSON_HEDLEY_TI_CL7X_VERSION
26618#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
26619#undef JSON_HEDLEY_TI_CLPRU_VERSION
26620#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
26621#undef JSON_HEDLEY_TI_VERSION
26622#undef JSON_HEDLEY_TI_VERSION_CHECK
26623#undef JSON_HEDLEY_UNAVAILABLE
26624#undef JSON_HEDLEY_UNLIKELY
26625#undef JSON_HEDLEY_UNPREDICTABLE
26626#undef JSON_HEDLEY_UNREACHABLE
26627#undef JSON_HEDLEY_UNREACHABLE_RETURN
26628#undef JSON_HEDLEY_VERSION
26629#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
26630#undef JSON_HEDLEY_VERSION_DECODE_MINOR
26631#undef JSON_HEDLEY_VERSION_DECODE_REVISION
26632#undef JSON_HEDLEY_VERSION_ENCODE
26633#undef JSON_HEDLEY_WARNING
26634#undef JSON_HEDLEY_WARN_UNUSED_RESULT
26635#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
26636#undef JSON_HEDLEY_FALL_THROUGH
#define NLOHMANN_BASIC_JSON_TPL_DECLARATION
Definition XrdOucJson.hh:2339
#define JSON_HEDLEY_CONST
Definition XrdOucJson.hh:1670
#define JSON_HEDLEY_DIAGNOSTIC_PUSH
Definition XrdOucJson.hh:954
#define JSON_HEDLEY_WARN_UNUSED_RESULT
Definition XrdOucJson.hh:1300
#define JSON_PRIVATE_UNLESS_TESTED
Definition XrdOucJson.hh:2302
#define NLOHMANN_JSON_VERSION_PATCH
Definition XrdOucJson.hh:35
#define JSON_HEDLEY_LIKELY(expr)
Definition XrdOucJson.hh:1565
#define JSON_HEDLEY_NON_NULL(...)
Definition XrdOucJson.hh:1458
#define JSON_INTERNAL_CATCH(exception)
Definition XrdOucJson.hh:2269
#define JSON_HEDLEY_RETURNS_NON_NULL
Definition XrdOucJson.hh:1899
#define JSON_CATCH(exception)
Definition XrdOucJson.hh:2268
#define JSON_ASSERT(x)
Definition XrdOucJson.hh:2295
#define JSON_THROW(exception)
Definition XrdOucJson.hh:2266
#define NLOHMANN_JSON_VERSION_MAJOR
Definition XrdOucJson.hh:33
#define NLOHMANN_BASIC_JSON_TPL
Definition XrdOucJson.hh:2348
#define JSON_HEDLEY_UNLIKELY(expr)
Definition XrdOucJson.hh:1566
#define JSON_TRY
Definition XrdOucJson.hh:2267
#define NLOHMANN_JSON_VERSION_MINOR
Definition XrdOucJson.hh:34
#define JSON_HEDLEY_DIAGNOSTIC_POP
Definition XrdOucJson.hh:955
#define JSON_EXPLICIT
Definition XrdOucJson.hh:2512
#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
Definition XrdOucJson.hh:1248
#define JSON_HEDLEY_PURE
Definition XrdOucJson.hh:1639
a class to store JSON values
Definition XrdOucJson.hh:17582
ValueType & get_to(ValueType &v) const
Definition XrdOucJson.hh:20710
void insert(const_iterator first, const_iterator last)
inserts elements
Definition XrdOucJson.hh:23353
array_t * get_impl_ptr(array_t *) noexcept
get a pointer to the value (array)
Definition XrdOucJson.hh:20270
detail::parser_callback_t< basic_json > parser_callback_t
per-element parser callback type
Definition XrdOucJson.hh:18838
bool contains(KeyT &&key) const
check the existence of an element in a JSON object
Definition XrdOucJson.hh:22005
iteration_proxy< iterator > items() noexcept
helper to access iterator member functions in range-based for
Definition XrdOucJson.hh:22465
const_reverse_iterator crbegin() const noexcept
returns a const reverse iterator to the last element
Definition XrdOucJson.hh:22290
constexpr const number_unsigned_t * get_impl_ptr(const number_unsigned_t *) const noexcept
get a pointer to the value (unsigned number)
Definition XrdOucJson.hh:20324
number_unsigned_t number_unsigned
number (unsigned integer)
Definition XrdOucJson.hh:18394
const_reference operator[](const json_pointer &ptr) const
access specified element via JSON Pointer
Definition XrdOucJson.hh:25619
reference operator[](const json_pointer &ptr)
access specified element via JSON Pointer
Definition XrdOucJson.hh:25591
friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
comparison: equal
Definition XrdOucJson.hh:23833
ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const
access specified object element with default value
Definition XrdOucJson.hh:21384
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
Definition XrdOucJson.hh:20093
NumberIntegerType number_integer_t
a type for a number (integer)
Definition XrdOucJson.hh:18116
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
comparison: equal
Definition XrdOucJson.hh:23751
NLOHMANN_BASIC_JSON_TPL basic_json_t
workaround type for MSVC
Definition XrdOucJson.hh:17603
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
Definition XrdOucJson.hh:24441
ReferenceType get_ref()
get a reference value (implicit)
Definition XrdOucJson.hh:20757
static JSON_HEDLEY_WARN_UNUSED_RESULT 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
Definition XrdOucJson.hh:24286
reference emplace_back(Args &&... args)
add an object to an array
Definition XrdOucJson.hh:23039
const_iterator find(KeyT &&key) const
find an element in a JSON object
Definition XrdOucJson.hh:21938
basic_json(const value_t v)
create an empty value with a given type
Definition XrdOucJson.hh:18879
object_t * get_impl_ptr(object_t *) noexcept
get a pointer to the value (object)
Definition XrdOucJson.hh:20258
size_type max_size() const noexcept
returns the maximum possible number of elements
Definition XrdOucJson.hh:22688
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json diff(const basic_json &source, const basic_json &target, const std::string &path="")
creates a diff as a JSON patch
Definition XrdOucJson.hh:26136
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...
Definition XrdOucJson.hh:24991
void erase(const size_type idx)
remove element from a JSON array given an index
Definition XrdOucJson.hh:21868
const_reverse_iterator crend() const noexcept
returns a const reverse iterator to one before the first
Definition XrdOucJson.hh:22319
const_reference at(const typename object_t::key_type &key) const
access specified object element with bounds checking
Definition XrdOucJson.hh:21040
reference at(const typename object_t::key_type &key)
access specified object element with bounds checking
Definition XrdOucJson.hh:20989
iterator begin() noexcept
returns an iterator to the first element
Definition XrdOucJson.hh:22075
binary_t & get_binary()
Definition XrdOucJson.hh:20833
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
Definition XrdOucJson.hh:19458
static std::vector< std::uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
Definition XrdOucJson.hh:24810
friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
comparison: equal
Definition XrdOucJson.hh:23844
json_value(object_t &&value)
constructor for rvalue objects
Definition XrdOucJson.hh:18499
basic_json(const JsonRef &ref)
Definition XrdOucJson.hh:19568
static std::vector< std::uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
Definition XrdOucJson.hh:24715
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
Definition XrdOucJson.hh:19725
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json array(initializer_list_t init={})
explicitly create an array from an initializer list
Definition XrdOucJson.hh:19321
json_value(number_float_t v) noexcept
constructor for numbers (floating-point)
Definition XrdOucJson.hh:18407
const_reverse_iterator rend() const noexcept
returns a const reverse iterator to one before the first
Definition XrdOucJson.hh:22261
void assert_invariant(bool check_parents=true) const noexcept
checks the class invariants
Definition XrdOucJson.hh:18658
json_value(string_t &&value)
constructor for rvalue strings
Definition XrdOucJson.hh:18487
const_iterator cend() const noexcept
returns a const iterator to one past the last element
Definition XrdOucJson.hh:22186
json_value(number_integer_t v) noexcept
constructor for numbers (integer)
Definition XrdOucJson.hh:18403
number_unsigned_t * get_impl_ptr(number_unsigned_t *) noexcept
get a pointer to the value (unsigned number)
Definition XrdOucJson.hh:20318
reference back()
access the last element
Definition XrdOucJson.hh:21554
boolean_t * get_impl_ptr(boolean_t *) noexcept
get a pointer to the value (boolean)
Definition XrdOucJson.hh:20294
const binary_t & get_binary() const
Definition XrdOucJson.hh:20844
constexpr const boolean_t * get_impl_ptr(const boolean_t *) const noexcept
get a pointer to the value (boolean)
Definition XrdOucJson.hh:20300
static bool accept(InputType &&i, const bool ignore_comments=false)
check if the input is valid JSON
Definition XrdOucJson.hh:24378
StringType string_t
a type for a string
Definition XrdOucJson.hh:18018
size_type size() const noexcept
returns the number of elements
Definition XrdOucJson.hh:22610
void push_back(const basic_json &val)
add an object to an array
Definition XrdOucJson.hh:22883
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json meta()
returns version information on the library
Definition XrdOucJson.hh:17759
ValueType value(const json_pointer &ptr, const ValueType &default_value) const
access specified object element via JSON Pointer with default value
Definition XrdOucJson.hh:21456
void update(const_reference j)
updates a JSON object from another object, overwriting existing keys
Definition XrdOucJson.hh:23395
std::size_t size_type
a type to represent container sizes
Definition XrdOucJson.hh:17702
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
Definition XrdOucJson.hh:20697
std::ptrdiff_t difference_type
a type to represent differences between iterators
Definition XrdOucJson.hh:17700
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init)
explicitly create a binary array (without subtype)
Definition XrdOucJson.hh:19218
reference operator[](const typename object_t::key_type &key)
access specified object element
Definition XrdOucJson.hh:21177
json_value(number_unsigned_t v) noexcept
constructor for numbers (unsigned)
Definition XrdOucJson.hh:18405
reference operator+=(basic_json &&val)
add an object to an array
Definition XrdOucJson.hh:22873
basic_json(const BasicJsonType &val)
create a JSON value from an existing one
Definition XrdOucJson.hh:19013
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
Definition XrdOucJson.hh:17710
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
Create a JSON value from an input in BSON format.
Definition XrdOucJson.hh:25515
typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
Definition XrdOucJson.hh:17708
constexpr const binary_t * get_impl_ptr(const binary_t *) const noexcept
get a pointer to the value (binary)
Definition XrdOucJson.hh:20348
static JSON_HEDLEY_WARN_UNUSED_RESULT 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
Definition XrdOucJson.hh:25124
BooleanType boolean_t
a type for a boolean
Definition XrdOucJson.hh:18044
void push_back(initializer_list_t init)
add an object to an object
Definition XrdOucJson.hh:22991
boolean_t get_impl(boolean_t *) const
get a boolean (explicit)
Definition XrdOucJson.hh:20247
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
Definition XrdOucJson.hh:19823
static bool accept(IteratorType first, IteratorType last, const bool ignore_comments=false)
Definition XrdOucJson.hh:24385
IteratorType erase(IteratorType pos)
remove element given an iterator
Definition XrdOucJson.hh:21621
static void to_bson(const basic_json &j, detail::output_adapter< std::uint8_t > o)
Serializes the given JSON object j to BSON and forwards the corresponding BSON-representation to the ...
Definition XrdOucJson.hh:25006
friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
comparison: not equal
Definition XrdOucJson.hh:23878
static JSON_HEDLEY_WARN_UNUSED_RESULT 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.
Definition XrdOucJson.hh:25499
constexpr bool is_structured() const noexcept
return whether type is structured
Definition XrdOucJson.hh:19934
friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
comparison: less than or equal
Definition XrdOucJson.hh:24057
const_iterator begin() const noexcept
returns a const iterator to the first element
Definition XrdOucJson.hh:22085
friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
comparison: less than
Definition XrdOucJson.hh:24000
reference at(size_type idx)
access specified array element with bounds checking
Definition XrdOucJson.hh:20891
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init, typename binary_t::subtype_type subtype)
binary (stored with pointer to save storage)
Definition XrdOucJson.hh:19275
reference front()
access the first element
Definition XrdOucJson.hh:21510
constexpr bool is_primitive() const noexcept
return whether type is primitive
Definition XrdOucJson.hh:19907
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
Definition XrdOucJson.hh:20065
static void to_cbor(const basic_json &j, detail::output_adapter< char > o)
Definition XrdOucJson.hh:24727
void swap(object_t &other)
exchanges the values
Definition XrdOucJson.hh:23593
constexpr bool is_object() const noexcept
return whether value is an object
Definition XrdOucJson.hh:20115
const_reference front() const
access the first element
Definition XrdOucJson.hh:21518
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
Definition XrdOucJson.hh:19876
NumberFloatType number_float_t
a type for a number (floating-point)
Definition XrdOucJson.hh:18255
json_reverse_iterator< typename basic_json::iterator > reverse_iterator
a reverse iterator for a basic_json container
Definition XrdOucJson.hh:17717
friend std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
Definition XrdOucJson.hh:24194
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
comparison: less than or equal
Definition XrdOucJson.hh:24035
bool empty() const noexcept
checks whether the container is empty.
Definition XrdOucJson.hh:22530
json_value(value_t t)
constructor for empty values of a given type
Definition XrdOucJson.hh:18409
basic_json(const basic_json &other)
copy constructor
Definition XrdOucJson.hh:19595
~basic_json() noexcept
destructor
Definition XrdOucJson.hh:19759
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
Definition XrdOucJson.hh:24913
basic_json(basic_json &&other) noexcept
move constructor
Definition XrdOucJson.hh:19687
friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
comparison: greater than
Definition XrdOucJson.hh:24103
BasicJsonType get_impl(detail::priority_tag< 2 >) const
get special-case overload
Definition XrdOucJson.hh:20541
static void to_ubjson(const basic_json &j, detail::output_adapter< char > o, const bool use_size=false, const bool use_type=false)
Definition XrdOucJson.hh:24928
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
comparison: not equal
Definition XrdOucJson.hh:23867
iterator insert(const_iterator pos, size_type cnt, const basic_json &val)
inserts elements
Definition XrdOucJson.hh:23211
friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
comparison: less than
Definition XrdOucJson.hh:24011
json_value m_value
the value of the current element
Definition XrdOucJson.hh:24602
boolean_t boolean
boolean
Definition XrdOucJson.hh:18390
void swap(typename binary_t::container_type &other)
exchanges the values
Definition XrdOucJson.hh:23673
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
comparison: greater than or equal
Definition XrdOucJson.hh:24127
void swap(array_t &other)
exchanges the values
Definition XrdOucJson.hh:23560
ValueType get_impl(detail::priority_tag< 0 >) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), std::declval< ValueType & >())))
get a value (explicit)
Definition XrdOucJson.hh:20474
reverse_iterator rend() noexcept
returns an iterator to the reverse-end
Definition XrdOucJson.hh:22253
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init, typename binary_t::subtype_type subtype)
explicitly create a binary array (with subtype)
Definition XrdOucJson.hh:19255
static iteration_proxy< iterator > iterator_wrapper(reference ref) noexcept
wrapper to access iterator member functions in range-based for
Definition XrdOucJson.hh:22383
json_value(const string_t &value)
constructor for strings
Definition XrdOucJson.hh:18481
json_value(const binary_t &value)
constructor for binary arrays (internal type)
Definition XrdOucJson.hh:18529
ReferenceType get_ref() const
get a reference value (implicit)
Definition XrdOucJson.hh:20770
json_value(const array_t &value)
constructor for arrays
Definition XrdOucJson.hh:18505
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
inserts elements
Definition XrdOucJson.hh:23259
auto get() noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
Definition XrdOucJson.hh:20653
const_reference at(const json_pointer &ptr) const
access specified element via JSON Pointer
Definition XrdOucJson.hh:25705
const_iterator end() const noexcept
returns a const iterator to one past the last element
Definition XrdOucJson.hh:22156
void merge_patch(const basic_json &apply_patch)
applies a JSON Merge Patch
Definition XrdOucJson.hh:26319
auto get_ptr() noexcept -> decltype(std::declval< basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
Definition XrdOucJson.hh:20411
iteration_proxy< const_iterator > items() const noexcept
helper to access iterator member functions in range-based for
Definition XrdOucJson.hh:22473
iterator insert(const_iterator pos, initializer_list_t ilist)
inserts elements
Definition XrdOucJson.hh:23312
ArrayType< basic_json, AllocatorType< basic_json > > array_t
a type for an array
Definition XrdOucJson.hh:17965
Array get_to(T(&v)[N]) const noexcept(noexcept(JSONSerializer< Array >::from_json(std::declval< const basic_json_t & >(), v)))
Definition XrdOucJson.hh:20721
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
comparison: greater than
Definition XrdOucJson.hh:24081
constexpr const number_integer_t * get_impl_ptr(const number_integer_t *) const noexcept
get a pointer to the value (integer number)
Definition XrdOucJson.hh:20312
constexpr const string_t * get_impl_ptr(const string_t *) const noexcept
get a pointer to the value (string)
Definition XrdOucJson.hh:20288
void destroy(value_t t)
Definition XrdOucJson.hh:18540
json_value(const object_t &value)
constructor for objects
Definition XrdOucJson.hh:18493
IteratorType erase(IteratorType first, IteratorType last)
remove elements given an iterator range
Definition XrdOucJson.hh:21736
json_value(typename binary_t::container_type &&value)
constructor for rvalue binary arrays
Definition XrdOucJson.hh:18523
json_value(boolean_t v) noexcept
constructor for booleans
Definition XrdOucJson.hh:18401
constexpr bool is_boolean() const noexcept
return whether value is a boolean
Definition XrdOucJson.hh:19978
iterator end() noexcept
returns an iterator to one past the last element
Definition XrdOucJson.hh:22146
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
Definition XrdOucJson.hh:23497
void clear() noexcept
clears the contents
Definition XrdOucJson.hh:22767
friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
comparison: greater than or equal
Definition XrdOucJson.hh:24149
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in MessagePack format
Definition XrdOucJson.hh:25284
constexpr bool is_binary() const noexcept
return whether value is a binary array
Definition XrdOucJson.hh:20181
static JSON_HEDLEY_RETURNS_NON_NULL T * create(Args &&... args)
helper for exception-safe object creation
Definition XrdOucJson.hh:18334
binary_t * binary
binary (stored with pointer to save storage)
Definition XrdOucJson.hh:18388
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json object(initializer_list_t init={})
explicitly create an object from an initializer list
Definition XrdOucJson.hh:19365
iterator insert(const_iterator pos, basic_json &&val)
inserts element
Definition XrdOucJson.hh:23182
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in UBJSON format
Definition XrdOucJson.hh:25401
reference operator[](size_type idx)
access specified array element
Definition XrdOucJson.hh:21086
friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
comparison: greater than
Definition XrdOucJson.hh:24092
static void to_bson(const basic_json &j, detail::output_adapter< char > o)
Serializes the given JSON object j to BSON and forwards the corresponding BSON-representation to the ...
Definition XrdOucJson.hh:25014
void update(const_iterator first, const_iterator last)
updates a JSON object from another object, overwriting existing keys
Definition XrdOucJson.hh:23446
reference at(const json_pointer &ptr)
access specified element via JSON Pointer
Definition XrdOucJson.hh:25662
void swap(binary_t &other)
exchanges the values
Definition XrdOucJson.hh:23659
json_reverse_iterator< typename basic_json::const_iterator > const_reverse_iterator
a const reverse iterator for a basic_json container
Definition XrdOucJson.hh:17719
static JSON_HEDLEY_WARN_UNUSED_RESULT 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
Definition XrdOucJson.hh:25385
::nlohmann::json_pointer< basic_json > json_pointer
JSON Pointer, see nlohmann::json_pointer.
Definition XrdOucJson.hh:17644
friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
comparison: not equal
Definition XrdOucJson.hh:23889
static void to_ubjson(const basic_json &j, detail::output_adapter< std::uint8_t > o, const bool use_size=false, const bool use_type=false)
Definition XrdOucJson.hh:24922
const_reverse_iterator rbegin() const noexcept
returns a const reverse iterator to the last element
Definition XrdOucJson.hh:22224
void swap(string_t &other)
exchanges the values
Definition XrdOucJson.hh:23626
const_reference back() const
access the last element
Definition XrdOucJson.hh:21564
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
comparison: less than
Definition XrdOucJson.hh:23920
ValueType get_impl(detail::priority_tag< 1 >) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >())))
get a value (explicit); special case
Definition XrdOucJson.hh:20516
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init)
binary (stored with pointer to save storage)
Definition XrdOucJson.hh:19265
constexpr bool is_string() const noexcept
return whether value is a string
Definition XrdOucJson.hh:20159
number_integer_t * get_impl_ptr(number_integer_t *) noexcept
get a pointer to the value (integer number)
Definition XrdOucJson.hh:20306
constexpr bool is_array() const noexcept
return whether value is an array
Definition XrdOucJson.hh:20137
iterator insert_iterator(const_iterator pos, Args &&... args)
Definition XrdOucJson.hh:23121
basic_json flatten() const
return flattened JSON value
Definition XrdOucJson.hh:25732
constexpr const number_float_t * get_impl_ptr(const number_float_t *) const noexcept
get a pointer to the value (floating-point number)
Definition XrdOucJson.hh:20336
constexpr const array_t * get_impl_ptr(const array_t *) const noexcept
get a pointer to the value (array)
Definition XrdOucJson.hh:20276
friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
comparison: greater than or equal
Definition XrdOucJson.hh:24138
JSON_HEDLEY_RETURNS_NON_NULL const char * type_name() const noexcept
return the type as string
Definition XrdOucJson.hh:24564
void push_back(basic_json &&val)
add an object to an array
Definition XrdOucJson.hh:22846
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(IteratorType first, IteratorType last, 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
Definition XrdOucJson.hh:25141
size_type count(KeyT &&key) const
returns the number of occurrences of a key in a JSON object
Definition XrdOucJson.hh:21972
json_value(const typename binary_t::container_type &value)
constructor for binary arrays
Definition XrdOucJson.hh:18517
json_value()=default
default constructor (for null values)
constexpr bool is_number() const noexcept
return whether value is a number
Definition XrdOucJson.hh:20008
number_float_t number_float
number (floating-point)
Definition XrdOucJson.hh:18396
string_t * get_impl_ptr(string_t *) noexcept
get a pointer to the value (string)
Definition XrdOucJson.hh:20282
friend std::ostream & operator>>(const basic_json &j, std::ostream &o)
serialize to stream
Definition XrdOucJson.hh:24218
std::less< StringType > object_comparator_t
Definition XrdOucJson.hh:17829
string_t * string
string (stored with pointer to save storage)
Definition XrdOucJson.hh:18386
reference operator+=(initializer_list_t init)
add an object to an object
Definition XrdOucJson.hh:23009
::nlohmann::detail::output_adapter_t< CharType > output_adapter_t
Definition XrdOucJson.hh:17632
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
Definition XrdOucJson.hh:20037
std::initializer_list< detail::json_ref< basic_json > > initializer_list_t
helper type for initializer lists of basic_json values
Definition XrdOucJson.hh:17652
static void to_cbor(const basic_json &j, detail::output_adapter< std::uint8_t > o)
Definition XrdOucJson.hh:24722
detail::value_t value_t
Definition XrdOucJson.hh:17642
number_float_t * get_impl_ptr(number_float_t *) noexcept
get a pointer to the value (floating-point number)
Definition XrdOucJson.hh:20330
json_value(binary_t &&value)
constructor for rvalue binary arrays (internal type)
Definition XrdOucJson.hh:18535
friend class ::nlohmann::detail::parser
Definition XrdOucJson.hh:17588
static void to_msgpack(const basic_json &j, detail::output_adapter< char > o)
Definition XrdOucJson.hh:24822
const_reference operator[](const typename object_t::key_type &key) const
read-only access specified object element
Definition XrdOucJson.hh:21226
iterator set_parents(iterator it, typename iterator::difference_type count)
Definition XrdOucJson.hh:18716
iterator find(KeyT &&key)
find an element in a JSON object
Definition XrdOucJson.hh:21921
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
Definition XrdOucJson.hh:18903
const_reference operator[](size_type idx) const
access specified array element
Definition XrdOucJson.hh:21139
array_t * array
array (stored with pointer to save storage)
Definition XrdOucJson.hh:18384
AllocatorType< basic_json > allocator_type
the allocator type
Definition XrdOucJson.hh:17705
basic_json get_impl(detail::priority_tag< 3 >) const
get special-case overload
Definition XrdOucJson.hh:20564
nlohmann::byte_container_with_subtype< BinaryType > binary_t
a type for a packed binary type
Definition XrdOucJson.hh:18326
JSONSerializer< T, SFINAE > json_serializer
Definition XrdOucJson.hh:17646
void push_back(const typename object_t::value_type &val)
add an object to an object
Definition XrdOucJson.hh:22935
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a pair of character iterators
Definition XrdOucJson.hh:24324
number_integer_t number_integer
number (integer)
Definition XrdOucJson.hh:18392
bool contains(const json_pointer &ptr) const
check the existence of an element in a JSON object given a JSON pointer
Definition XrdOucJson.hh:22036
static JSON_HEDLEY_WARN_UNUSED_RESULT 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
Definition XrdOucJson.hh:25268
basic_json patch(const basic_json &json_patch) const
applies a JSON patch
Definition XrdOucJson.hh:25830
string_t value(const typename object_t::key_type &key, const char *default_value) const
overload for a default value of type const char*
Definition XrdOucJson.hh:21406
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
Definition XrdOucJson.hh:18975
void set_parents()
Definition XrdOucJson.hh:18679
basic_json unflatten() const
unflatten a previously flattened JSON value
Definition XrdOucJson.hh:25769
reference set_parent(reference j, std::size_t old_capacity=std::size_t(-1))
Definition XrdOucJson.hh:18729
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
Definition XrdOucJson.hh:18187
reference operator+=(const typename object_t::value_type &val)
add an object to an object
Definition XrdOucJson.hh:22960
const_iterator cbegin() const noexcept
returns a const iterator to the first element
Definition XrdOucJson.hh:22115
friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
comparison: less than or equal
Definition XrdOucJson.hh:24046
friend std::istream & operator>>(std::istream &i, basic_json &j)
deserialize from stream
Definition XrdOucJson.hh:24520
static ::nlohmann::detail::parser< basic_json, InputAdapterType > parser(InputAdapterType adapter, detail::parser_callback_t< basic_json >cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
Definition XrdOucJson.hh:17610
json_value(array_t &&value)
constructor for rvalue arrays
Definition XrdOucJson.hh:18511
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
Definition XrdOucJson.hh:19137
const_reference at(size_type idx) const
access specified array element with bounds checking
Definition XrdOucJson.hh:20938
iterator insert(const_iterator pos, const basic_json &val)
inserts element
Definition XrdOucJson.hh:23160
constexpr bool is_discarded() const noexcept
return whether value is discarded
Definition XrdOucJson.hh:20208
constexpr auto get_impl(detail::priority_tag< 4 >) const noexcept -> decltype(std::declval< const basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
Definition XrdOucJson.hh:20577
constexpr bool is_null() const noexcept
return whether value is null
Definition XrdOucJson.hh:19956
friend void swap(reference left, reference right) 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
Definition XrdOucJson.hh:23530
binary_t * get_impl_ptr(binary_t *) noexcept
get a pointer to the value (binary)
Definition XrdOucJson.hh:20342
ObjectType< StringType, basic_json, object_comparator_t, AllocatorType< std::pair< const StringType, basic_json > > > object_t
a type for an object
Definition XrdOucJson.hh:17919
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)
Definition XrdOucJson.hh:20612
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
Definition XrdOucJson.hh:23089
static void to_msgpack(const basic_json &j, detail::output_adapter< std::uint8_t > o)
Definition XrdOucJson.hh:24817
reference operator+=(const basic_json &val)
add an object to an array
Definition XrdOucJson.hh:22909
size_type erase(const typename object_t::key_type &key)
remove element from a JSON object given a key
Definition XrdOucJson.hh:21833
static ReferenceType get_ref_impl(ThisType &obj)
helper function to implement get_ref()
Definition XrdOucJson.hh:20365
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
Definition XrdOucJson.hh:19392
static allocator_type get_allocator()
returns the allocator associated with the container
Definition XrdOucJson.hh:17727
constexpr const object_t * get_impl_ptr(const object_t *) const noexcept
get a pointer to the value (object)
Definition XrdOucJson.hh:20264
constexpr auto get_ptr() const noexcept -> decltype(std::declval< const basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
Definition XrdOucJson.hh:20424
reverse_iterator rbegin() noexcept
returns an iterator to the reverse-beginning
Definition XrdOucJson.hh:22216
an internal type for a backed binary type
Definition XrdOucJson.hh:5033
byte_container_with_subtype(const container_type &b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
Definition XrdOucJson.hh:5052
BinaryType container_type
the type of the underlying container
Definition XrdOucJson.hh:5036
byte_container_with_subtype(const container_type &b) noexcept(noexcept(container_type(b)))
Definition XrdOucJson.hh:5044
bool m_has_subtype
Definition XrdOucJson.hh:5174
byte_container_with_subtype(container_type &&b) noexcept(noexcept(container_type(std::move(b))))
Definition XrdOucJson.hh:5048
bool operator!=(const byte_container_with_subtype &rhs) const
Definition XrdOucJson.hh:5070
void clear_subtype() noexcept
clears the binary subtype
Definition XrdOucJson.hh:5166
byte_container_with_subtype() noexcept(noexcept(container_type()))
Definition XrdOucJson.hh:5040
byte_container_with_subtype(container_type &&b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
Definition XrdOucJson.hh:5058
constexpr bool has_subtype() const noexcept
return whether the value has a subtype
Definition XrdOucJson.hh:5142
void set_subtype(subtype_type subtype_) noexcept
sets the binary subtype
Definition XrdOucJson.hh:5093
constexpr subtype_type subtype() const noexcept
return the binary subtype
Definition XrdOucJson.hh:5121
std::uint64_t subtype_type
the type of the subtype
Definition XrdOucJson.hh:5038
subtype_type m_subtype
Definition XrdOucJson.hh:5173
bool operator==(const byte_container_with_subtype &rhs) const
Definition XrdOucJson.hh:5064
deserialization of CBOR, MessagePack, and UBJSON values
Definition XrdOucJson.hh:8354
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:8356
bool get_msgpack_array(const std::size_t len)
Definition XrdOucJson.hh:10045
binary_reader & operator=(const binary_reader &)=delete
bool get_bson_string(const NumberType len, string_t &result)
Parses a zero-terminated string of length len from the BSON input.
Definition XrdOucJson.hh:8508
bool parse_bson_element_internal(const char_int_type element_type, const std::size_t element_type_parse_position)
Read a BSON document element of the given element_type.
Definition XrdOucJson.hh:8555
bool parse_bson_array()
Reads an array from the BSON input and passes it to the SAX-parser.
Definition XrdOucJson.hh:8671
char_int_type get_ignore_noop()
Definition XrdOucJson.hh:10618
bool get_ubjson_high_precision_number()
Definition XrdOucJson.hh:10533
binary_reader(InputAdapterType &&adapter) noexcept
create a binary reader
Definition XrdOucJson.hh:8370
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:8355
bool get_bson_cstr(string_t &result)
Parses a C-style string from the BSON input.
Definition XrdOucJson.hh:8478
bool get_cbor_array(const std::size_t len, const cbor_tag_handler_t tag_handler)
Definition XrdOucJson.hh:9378
bool get_msgpack_binary(binary_t &result)
reads a MessagePack byte array
Definition XrdOucJson.hh:9934
bool get_cbor_object(const std::size_t len, const cbor_tag_handler_t tag_handler)
Definition XrdOucJson.hh:9416
bool get_ubjson_string(string_t &result, const bool get_char=true)
reads a UBJSON string
Definition XrdOucJson.hh:10123
SAX json_sax_t
Definition XrdOucJson.hh:8360
bool parse_bson_element_list(const bool is_array)
Read a BSON element list (as specified in the BSON-spec)
Definition XrdOucJson.hh:8633
bool parse_cbor_internal(const bool get_char, const cbor_tag_handler_t tag_handler)
Definition XrdOucJson.hh:8701
bool get_string(const input_format_t format, const NumberType len, string_t &result)
create a string by reading characters from the input
Definition XrdOucJson.hh:10686
bool get_cbor_string(string_t &result)
reads a CBOR string
Definition XrdOucJson.hh:9189
InputAdapterType ia
input adapter
Definition XrdOucJson.hh:10803
bool get_binary(const input_format_t format, const NumberType len, binary_t &result)
create a byte array by reading bytes from the input
Definition XrdOucJson.hh:10719
bool parse_ubjson_internal(const bool get_char=true)
Definition XrdOucJson.hh:10104
bool unexpect_eof(const input_format_t format, const char *context) const
Definition XrdOucJson.hh:10743
binary_reader & operator=(binary_reader &&)=default
bool get_ubjson_size_type(std::pair< std::size_t, char_int_type > &result)
determine the type and size for a container
Definition XrdOucJson.hh:10254
std::string get_token_string() const
Definition XrdOucJson.hh:10756
bool get_ubjson_value(const char_int_type prefix)
Definition XrdOucJson.hh:10295
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:8358
bool get_msgpack_object(const std::size_t len)
Definition XrdOucJson.hh:10067
bool get_bson_binary(const NumberType len, binary_t &result)
Parses a byte array input of length len from the BSON input.
Definition XrdOucJson.hh:8529
std::string exception_message(const input_format_t format, const std::string &detail, const std::string &context) const
Definition XrdOucJson.hh:10769
std::size_t chars_read
the number of characters read
Definition XrdOucJson.hh:10809
typename std::char_traits< char_type >::int_type char_int_type
Definition XrdOucJson.hh:8362
binary_reader(const binary_reader &)=delete
char_int_type current
the current character
Definition XrdOucJson.hh:10806
bool sax_parse(const input_format_t format, json_sax_t *sax_, const bool strict=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
Definition XrdOucJson.hh:8391
json_sax_t * sax
the SAX parser
Definition XrdOucJson.hh:10815
bool get_ubjson_size_value(std::size_t &result)
Definition XrdOucJson.hh:10177
typename InputAdapterType::char_type char_type
Definition XrdOucJson.hh:8361
bool parse_bson_internal()
Reads in a BSON-object and passes it to the SAX-parser.
Definition XrdOucJson.hh:8453
bool get_number(const input_format_t format, NumberType &result)
Definition XrdOucJson.hh:10643
bool get_cbor_binary(binary_t &result)
reads a CBOR byte array
Definition XrdOucJson.hh:9284
binary_reader(binary_reader &&)=default
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:8359
char_int_type get()
get next character from the input
Definition XrdOucJson.hh:10609
const bool is_little_endian
whether we can assume little endianess
Definition XrdOucJson.hh:10812
bool get_msgpack_string(string_t &result)
reads a MessagePack string
Definition XrdOucJson.hh:9852
bool get_ubjson_object()
Definition XrdOucJson.hh:10458
bool parse_msgpack_internal()
Definition XrdOucJson.hh:9472
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:8357
bool get_ubjson_array()
Definition XrdOucJson.hh:10396
serialization to CBOR and MessagePack values
Definition XrdOucJson.hh:13601
void write_bson_array(const string_t &name, const typename BasicJsonType::array_t &value)
Writes a BSON element with key name and array value.
Definition XrdOucJson.hh:14677
void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix)
Definition XrdOucJson.hh:14868
void write_ubjson(const BasicJsonType &j, const bool use_count, const bool use_type, const bool add_prefix=true)
Definition XrdOucJson.hh:14299
static std::size_t calc_bson_entry_header_size(const string_t &name, const BasicJsonType &j)
Definition XrdOucJson.hh:14507
static constexpr CharType get_ubjson_float_prefix(double)
Definition XrdOucJson.hh:15094
void write_bson_entry_header(const string_t &name, const std::uint8_t element_type)
Writes the given element_type and name to the output adapter.
Definition XrdOucJson.hh:14522
static std::size_t calc_bson_element_size(const string_t &name, const BasicJsonType &j)
Calculates the size necessary to serialize the JSON value j with its name.
Definition XrdOucJson.hh:14711
void write_bson_double(const string_t &name, const double value)
Writes a BSON element with key name and double value value.
Definition XrdOucJson.hh:14544
void write_bson_object(const typename BasicJsonType::object_t &value)
Definition XrdOucJson.hh:14821
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:13602
static constexpr CharType get_cbor_float_prefix(float)
Definition XrdOucJson.hh:14837
static constexpr CharType to_char_type(InputCharType x) noexcept
Definition XrdOucJson.hh:15194
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:13603
binary_writer(output_adapter_t< CharType > adapter)
create a binary writer
Definition XrdOucJson.hh:13612
static constexpr CharType get_msgpack_float_prefix(double)
Definition XrdOucJson.hh:14856
CharType ubjson_prefix(const BasicJsonType &j) const noexcept
determine the type prefix of container values
Definition XrdOucJson.hh:15008
void write_bson_integer(const string_t &name, const std::int64_t value)
Writes a BSON element with key name and integer value.
Definition XrdOucJson.hh:14594
static CharType to_char_type(std::uint8_t x) noexcept
Definition XrdOucJson.hh:15172
void write_bson_string(const string_t &name, const string_t &value)
Writes a BSON element with key name and string value value.
Definition XrdOucJson.hh:14562
void write_bson_object_entry(const string_t &name, const typename BasicJsonType::object_t &value)
Writes a BSON element with key name and object value.
Definition XrdOucJson.hh:14644
static constexpr CharType get_ubjson_float_prefix(float)
Definition XrdOucJson.hh:15089
void write_number(const NumberType n)
Definition XrdOucJson.hh:15115
void write_bson_element(const string_t &name, const BasicJsonType &j)
Serializes the JSON value j to BSON and associates it with the key name.
Definition XrdOucJson.hh:14759
void write_bson_binary(const string_t &name, const binary_t &value)
Writes a BSON element with key name and binary value value.
Definition XrdOucJson.hh:14696
void write_bson_null(const string_t &name)
Writes a BSON element with key name and null value.
Definition XrdOucJson.hh:14576
static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t &value)
Definition XrdOucJson.hh:14669
void write_bson(const BasicJsonType &j)
Definition XrdOucJson.hh:13621
void write_cbor(const BasicJsonType &j)
Definition XrdOucJson.hh:13650
static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
Definition XrdOucJson.hh:14612
static constexpr CharType to_char_type(std::uint8_t x) noexcept
Definition XrdOucJson.hh:15165
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:13604
void write_bson_unsigned(const string_t &name, const BasicJsonType &j)
Writes a BSON element with key name and unsigned value.
Definition XrdOucJson.hh:14622
static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t &value)
Calculates the size of the BSON serialization of the given JSON-object j.
Definition XrdOucJson.hh:14806
static constexpr CharType get_msgpack_float_prefix(float)
Definition XrdOucJson.hh:14851
void write_bson_boolean(const string_t &name, const bool value)
Writes a BSON element with key name and boolean value value.
Definition XrdOucJson.hh:14534
void write_msgpack(const BasicJsonType &j)
Definition XrdOucJson.hh:13974
void write_compact_float(const number_float_t n, detail::input_format_t format)
Definition XrdOucJson.hh:15131
static std::size_t calc_bson_string_size(const string_t &value)
Definition XrdOucJson.hh:14554
static std::size_t calc_bson_integer_size(const std::int64_t value)
Definition XrdOucJson.hh:14584
static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t &value)
Definition XrdOucJson.hh:14654
static constexpr CharType get_cbor_float_prefix(double)
Definition XrdOucJson.hh:14842
general exception of the basic_json class
Definition XrdOucJson.hh:2650
const int id
the id of the exception
Definition XrdOucJson.hh:2659
static std::string diagnostics(const BasicJsonType &leaf_element)
Definition XrdOucJson.hh:2671
static std::string name(const std::string &ename, int id_)
Definition XrdOucJson.hh:2665
std::runtime_error m
an exception object as storage for error messages
Definition XrdOucJson.hh:2736
const char * what() const noexcept override
returns the explanatory string
Definition XrdOucJson.hh:2653
exception indicating errors with iterators
Definition XrdOucJson.hh:2873
static invalid_iterator create(int id_, const std::string &what_arg, const BasicJsonType &context)
Definition XrdOucJson.hh:2876
a template for a bidirectional iterator for the basic_json class This class implements a both iterato...
Definition XrdOucJson.hh:11531
bool operator<(const iter_impl &other) const
comparison: smaller
Definition XrdOucJson.hh:11994
iter_impl operator-(difference_type i) const
subtract from iterator
Definition XrdOucJson.hh:12124
bool operator!=(const IterImpl &other) const
comparison: not equal
Definition XrdOucJson.hh:11985
iter_impl const operator--(int)
post-decrement (it–)
Definition XrdOucJson.hh:11897
void set_end() noexcept
set the iterator past the last value
Definition XrdOucJson.hh:11721
typename BasicJsonType::difference_type difference_type
a type to represent differences between iterators
Definition XrdOucJson.hh:11558
iter_impl & operator--()
pre-decrement (–it)
Definition XrdOucJson.hh:11908
difference_type operator-(const iter_impl &other) const
return difference
Definition XrdOucJson.hh:12135
iter_impl & operator=(const iter_impl< const BasicJsonType > &other) noexcept
converting assignment
Definition XrdOucJson.hh:11640
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_reference, typename BasicJsonType::reference >::type reference
defines a reference to the type iterated over (value_type)
Definition XrdOucJson.hh:11567
reference operator*() const
return a reference to the value pointed to by the iterator
Definition XrdOucJson.hh:11760
iter_impl(iter_impl &&) noexcept=default
bool operator>=(const iter_impl &other) const
comparison: greater than or equal
Definition XrdOucJson.hh:12047
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_pointer, typename BasicJsonType::pointer >::type pointer
defines a pointer to the type iterated over (value_type)
Definition XrdOucJson.hh:11562
iter_impl & operator=(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting assignment
Definition XrdOucJson.hh:11665
pointer operator->() const
dereference the iterator
Definition XrdOucJson.hh:11804
iter_impl(const iter_impl< const BasicJsonType > &other) noexcept
const copy constructor
Definition XrdOucJson.hh:11630
iter_impl const operator++(int)
post-increment (it++)
Definition XrdOucJson.hh:11846
iter_impl(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting constructor
Definition XrdOucJson.hh:11655
internal_iterator< typename std::remove_const< BasicJsonType >::type > m_it
the actual iterator of the associated instance
Definition XrdOucJson.hh:12227
iter_impl operator+(difference_type i) const
add to iterator
Definition XrdOucJson.hh:12102
friend iter_impl operator+(difference_type i, const iter_impl &it)
addition of distance and iterator
Definition XrdOucJson.hh:12113
const object_t::key_type & key() const
return the key of an object iterator
Definition XrdOucJson.hh:12202
bool operator==(const IterImpl &other) const
comparison: equal
Definition XrdOucJson.hh:11949
bool operator>(const iter_impl &other) const
comparison: greater than
Definition XrdOucJson.hh:12038
typename BasicJsonType::value_type value_type
the type of the values when the iterator is dereferenced
Definition XrdOucJson.hh:11556
reference value() const
return the value of an iterator
Definition XrdOucJson.hh:12218
typename BasicJsonType::object_t object_t
Definition XrdOucJson.hh:11540
friend other_iter_impl
allow basic_json to access private members
Definition XrdOucJson.hh:11535
iter_impl & operator++()
pre-increment (++it)
Definition XrdOucJson.hh:11857
friend BasicJsonType
Definition XrdOucJson.hh:11536
reference operator[](difference_type n) const
access to successor
Definition XrdOucJson.hh:12164
bool operator<=(const iter_impl &other) const
comparison: less than or equal
Definition XrdOucJson.hh:12029
std::bidirectional_iterator_tag iterator_category
Definition XrdOucJson.hh:11553
iter_impl & operator+=(difference_type i)
add to iterator
Definition XrdOucJson.hh:12056
typename BasicJsonType::array_t array_t
Definition XrdOucJson.hh:11541
iter_impl & operator-=(difference_type i)
subtract from iterator
Definition XrdOucJson.hh:12093
Definition XrdOucJson.hh:4373
IteratorType anchor
the iterator
Definition XrdOucJson.hh:4384
std::input_iterator_tag iterator_category
Definition XrdOucJson.hh:4379
typename std::remove_cv< typename std::remove_reference< decltype(std::declval< IteratorType >().key()) >::type >::type string_type
Definition XrdOucJson.hh:4380
const string_type empty_str
an empty string (to return a reference for primitive values)
Definition XrdOucJson.hh:4392
iteration_proxy_value(IteratorType it) noexcept
Definition XrdOucJson.hh:4395
bool operator!=(const iteration_proxy_value &o) const
inequality operator (needed for range-based for)
Definition XrdOucJson.hh:4421
std::size_t array_index_last
last stringified array index
Definition XrdOucJson.hh:4388
string_type array_index_str
a string representation of the array index
Definition XrdOucJson.hh:4390
IteratorType::reference value() const
return value of the iterator
Definition XrdOucJson.hh:4463
iteration_proxy_value & operator++()
increment operator (needed for range-based for)
Definition XrdOucJson.hh:4406
std::size_t array_index
an index for arrays (used to create key names)
Definition XrdOucJson.hh:4386
iteration_proxy_value & operator*()
dereference operator (needed for range-based for)
Definition XrdOucJson.hh:4400
std::ptrdiff_t difference_type
Definition XrdOucJson.hh:4375
const string_type & key() const
return key of the iterator
Definition XrdOucJson.hh:4427
bool operator==(const iteration_proxy_value &o) const
equality operator (needed for InputIterator)
Definition XrdOucJson.hh:4415
proxy class for the items() function
Definition XrdOucJson.hh:4471
iteration_proxy_value< IteratorType > begin() noexcept
return iterator begin (needed for range-based for)
Definition XrdOucJson.hh:4482
iteration_proxy_value< IteratorType > end() noexcept
return iterator end (needed for range-based for)
Definition XrdOucJson.hh:4488
IteratorType::reference container
the container to iterate
Definition XrdOucJson.hh:4474
iteration_proxy(typename IteratorType::reference cont) noexcept
construct iteration proxy from a container
Definition XrdOucJson.hh:4478
Definition XrdOucJson.hh:13367
value_type const * value_ref
Definition XrdOucJson.hh:13418
json_ref(json_ref &&) noexcept=default
value_type owned_value
Definition XrdOucJson.hh:13417
value_type const & operator*() const
Definition XrdOucJson.hh:13406
BasicJsonType value_type
Definition XrdOucJson.hh:13369
json_ref(Args &&... args)
Definition XrdOucJson.hh:13386
json_ref(const value_type &value)
Definition XrdOucJson.hh:13375
value_type const * operator->() const
Definition XrdOucJson.hh:13411
json_ref(std::initializer_list< json_ref > init)
Definition XrdOucJson.hh:13379
json_ref(value_type &&value)
Definition XrdOucJson.hh:13371
value_type moved_or_copied() const
Definition XrdOucJson.hh:13397
a template for a reverse iterator class
Definition XrdOucJson.hh:12269
json_reverse_iterator(const typename base_iterator::iterator_type &it) noexcept
create reverse iterator from iterator
Definition XrdOucJson.hh:12278
json_reverse_iterator const operator--(int)
post-decrement (it–)
Definition XrdOucJson.hh:12297
typename Base::reference reference
the reference type for the pointed-to element
Definition XrdOucJson.hh:12275
json_reverse_iterator operator-(difference_type i) const
subtract from iterator
Definition XrdOucJson.hh:12321
json_reverse_iterator & operator+=(difference_type i)
add to iterator
Definition XrdOucJson.hh:12309
std::reverse_iterator< Base > base_iterator
shortcut to the reverse iterator adapter
Definition XrdOucJson.hh:12273
json_reverse_iterator(const base_iterator &it) noexcept
create reverse iterator from base class
Definition XrdOucJson.hh:12282
reference operator[](difference_type n) const
access to successor
Definition XrdOucJson.hh:12333
std::ptrdiff_t difference_type
Definition XrdOucJson.hh:12271
difference_type operator-(const json_reverse_iterator &other) const
return difference
Definition XrdOucJson.hh:12327
json_reverse_iterator operator+(difference_type i) const
add to iterator
Definition XrdOucJson.hh:12315
json_reverse_iterator const operator++(int)
post-increment (it++)
Definition XrdOucJson.hh:12285
auto key() const -> decltype(std::declval< Base >().key())
return the key of an object iterator
Definition XrdOucJson.hh:12339
json_reverse_iterator & operator--()
pre-decrement (–it)
Definition XrdOucJson.hh:12303
reference value() const
return the value of an iterator
Definition XrdOucJson.hh:12346
json_reverse_iterator & operator++()
pre-increment (++it)
Definition XrdOucJson.hh:12291
Definition XrdOucJson.hh:6454
bool end_array()
Definition XrdOucJson.hh:6517
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:6459
bool binary(binary_t &)
Definition XrdOucJson.hh:6492
bool boolean(bool)
Definition XrdOucJson.hh:6467
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:6456
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:6458
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:6460
bool key(string_t &)
Definition XrdOucJson.hh:6502
bool start_object(std::size_t=std::size_t(-1))
Definition XrdOucJson.hh:6497
bool start_array(std::size_t=std::size_t(-1))
Definition XrdOucJson.hh:6512
bool end_object()
Definition XrdOucJson.hh:6507
bool parse_error(std::size_t, const std::string &, const detail::exception &)
Definition XrdOucJson.hh:6522
bool number_integer(number_integer_t)
Definition XrdOucJson.hh:6472
bool string(string_t &)
Definition XrdOucJson.hh:6487
bool number_unsigned(number_unsigned_t)
Definition XrdOucJson.hh:6477
bool null()
Definition XrdOucJson.hh:6462
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:6457
bool number_float(number_float_t, const string_t &)
Definition XrdOucJson.hh:6482
Definition XrdOucJson.hh:6147
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:6152
json_sax_dom_callback_parser & operator=(const json_sax_dom_callback_parser &)=delete
bool start_object(std::size_t len)
Definition XrdOucJson.hh:6214
bool key(string_t &val)
Definition XrdOucJson.hh:6232
constexpr bool is_errored() const
Definition XrdOucJson.hh:6347
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:6150
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:6149
std::pair< bool, BasicJsonType * > handle_value(Value &&v, const bool skip_callback=false)
Definition XrdOucJson.hh:6369
bool null()
Definition XrdOucJson.hh:6172
typename BasicJsonType::parser_callback_t parser_callback_t
Definition XrdOucJson.hh:6154
bool start_array(std::size_t len)
Definition XrdOucJson.hh:6285
~json_sax_dom_callback_parser()=default
json_sax_dom_callback_parser(const json_sax_dom_callback_parser &)=delete
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:6153
bool binary(binary_t &val)
Definition XrdOucJson.hh:6208
bool number_integer(number_integer_t val)
Definition XrdOucJson.hh:6184
BasicJsonType & root
the parsed JSON value
Definition XrdOucJson.hh:6433
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:6151
bool end_array()
Definition XrdOucJson.hh:6302
typename BasicJsonType::parse_event_t parse_event_t
Definition XrdOucJson.hh:6155
bool boolean(bool val)
Definition XrdOucJson.hh:6178
bool number_unsigned(number_unsigned_t val)
Definition XrdOucJson.hh:6190
json_sax_dom_callback_parser & operator=(json_sax_dom_callback_parser &&)=default
bool string(string_t &val)
Definition XrdOucJson.hh:6202
bool number_float(number_float_t val, const string_t &)
Definition XrdOucJson.hh:6196
bool end_object()
Definition XrdOucJson.hh:6249
json_sax_dom_callback_parser(json_sax_dom_callback_parser &&)=default
bool parse_error(std::size_t, const std::string &, const Exception &ex)
Definition XrdOucJson.hh:6335
json_sax_dom_callback_parser(BasicJsonType &r, const parser_callback_t cb, const bool allow_exceptions_=true)
Definition XrdOucJson.hh:6157
SAX implementation to create a JSON value from SAX events.
Definition XrdOucJson.hh:5973
bool start_array(std::size_t len)
Definition XrdOucJson.hh:6065
json_sax_dom_parser(const json_sax_dom_parser &)=delete
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:5979
json_sax_dom_parser & operator=(json_sax_dom_parser &&)=default
bool number_unsigned(number_unsigned_t val)
Definition XrdOucJson.hh:6015
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:5975
bool boolean(bool val)
Definition XrdOucJson.hh:6003
~json_sax_dom_parser()=default
bool parse_error(std::size_t, const std::string &, const Exception &ex)
Definition XrdOucJson.hh:6085
JSON_HEDLEY_RETURNS_NON_NULL BasicJsonType * handle_value(Value &&v)
Definition XrdOucJson.hh:6111
bool string(string_t &val)
Definition XrdOucJson.hh:6027
bool end_object()
Definition XrdOucJson.hh:6058
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:5976
bool start_object(std::size_t len)
Definition XrdOucJson.hh:6039
bool null()
Definition XrdOucJson.hh:5997
bool binary(binary_t &val)
Definition XrdOucJson.hh:6033
constexpr bool is_errored() const
Definition XrdOucJson.hh:6097
bool key(string_t &val)
Definition XrdOucJson.hh:6051
json_sax_dom_parser(json_sax_dom_parser &&)=default
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:5977
json_sax_dom_parser & operator=(const json_sax_dom_parser &)=delete
BasicJsonType & root
the parsed JSON value
Definition XrdOucJson.hh:6134
bool number_float(number_float_t val, const string_t &)
Definition XrdOucJson.hh:6021
bool end_array()
Definition XrdOucJson.hh:6077
json_sax_dom_parser(BasicJsonType &r, const bool allow_exceptions_=true)
Definition XrdOucJson.hh:5986
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:5978
bool number_integer(number_integer_t val)
Definition XrdOucJson.hh:6009
Definition XrdOucJson.hh:6561
JSON_HEDLEY_RETURNS_NON_NULL static JSON_HEDLEY_CONST const char * token_type_name(const token_type t) noexcept
return name of values of type token_type (only used for errors)
Definition XrdOucJson.hh:6588
token_type
token types for the parser
Definition XrdOucJson.hh:6565
@ value_float
an floating point number – use get_number_float() for actual value
@ begin_array
the character for array begin [
@ value_string
a string – use get_string() for actual value
@ end_array
the character for array end ]
@ uninitialized
indicating the scanner is uninitialized
@ parse_error
indicating a parse error
@ value_integer
a signed integer – use get_number_integer() for actual value
@ value_separator
the value separator ,
@ end_object
the character for object end }
@ literal_true
the true literal
@ begin_object
the character for object begin {
@ value_unsigned
an unsigned integer – use get_number_unsigned() for actual value
@ literal_null
the null literal
@ end_of_input
indicating the end of the input buffer
@ name_separator
the name separator :
@ literal_or_value
a literal or the begin of a value (only for diagnostics)
@ literal_false
the false literal
lexical analysis
Definition XrdOucJson.hh:6638
string_t & get_string()
return current string value (implicitly resets the token; useful only once)
Definition XrdOucJson.hh:7956
number_float_t value_float
Definition XrdOucJson.hh:8151
const bool ignore_comments
whether comments should be ignored (true) or signaled as errors (false)
Definition XrdOucJson.hh:8128
void add(char_int_type c)
add a character to token_buffer
Definition XrdOucJson.hh:7927
void reset() noexcept
reset token_buffer; current character is beginning of token
Definition XrdOucJson.hh:7846
token_type scan()
Definition XrdOucJson.hh:8035
bool next_unget
whether the next get() call should just return current
Definition XrdOucJson.hh:8134
char_int_type current
the current character
Definition XrdOucJson.hh:8131
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:6641
void skip_whitespace()
Definition XrdOucJson.hh:8026
typename std::char_traits< char_type >::int_type char_int_type
Definition XrdOucJson.hh:6644
static JSON_HEDLEY_PURE char get_decimal_point() noexcept
return the locale-dependent decimal point
Definition XrdOucJson.hh:6669
number_integer_t value_integer
Definition XrdOucJson.hh:8149
InputAdapterType ia
input adapter
Definition XrdOucJson.hh:8125
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:6639
lexer & operator=(lexer &&)=default
static void strtof(float &f, const char *str, char **endptr) noexcept
Definition XrdOucJson.hh:7438
const char_int_type decimal_point_char
the decimal point
Definition XrdOucJson.hh:8154
bool skip_bom()
skip the UTF-8 byte order mark
Definition XrdOucJson.hh:8012
const char * error_message
a description of occurred lexer errors
Definition XrdOucJson.hh:8146
lexer(InputAdapterType &&adapter, bool ignore_comments_=false) noexcept
Definition XrdOucJson.hh:6649
position_t position
the start position of the current token
Definition XrdOucJson.hh:8137
constexpr position_t get_position() const noexcept
return position of last read token
Definition XrdOucJson.hh:7966
std::vector< char_type > token_string
raw input token string (for error messages)
Definition XrdOucJson.hh:8140
constexpr number_integer_t get_number_integer() const noexcept
return integer value
Definition XrdOucJson.hh:7938
typename lexer_base< BasicJsonType >::token_type token_type
Definition XrdOucJson.hh:6647
typename InputAdapterType::char_type char_type
Definition XrdOucJson.hh:6643
char_int_type get()
Definition XrdOucJson.hh:7863
token_type scan_number()
scan a number literal
Definition XrdOucJson.hh:7495
lexer & operator=(lexer &)=delete
void unget()
unget current character (read it again on next get)
Definition XrdOucJson.hh:7900
token_type scan_string()
scan a string literal
Definition XrdOucJson.hh:6780
lexer(const lexer &)=delete
constexpr number_unsigned_t get_number_unsigned() const noexcept
return unsigned integer value
Definition XrdOucJson.hh:7944
string_t token_buffer
buffer for variable-length tokens (numbers, strings)
Definition XrdOucJson.hh:8143
token_type scan_literal(const char_type *literal_text, const std::size_t length, token_type return_type)
Definition XrdOucJson.hh:7826
constexpr number_float_t get_number_float() const noexcept
return floating-point value
Definition XrdOucJson.hh:7950
int get_codepoint()
get codepoint from 4 hex characters following \u
Definition XrdOucJson.hh:6695
std::string get_token_string() const
Definition XrdOucJson.hh:7974
number_unsigned_t value_unsigned
Definition XrdOucJson.hh:8150
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:6640
bool next_byte_in_range(std::initializer_list< char_int_type > ranges)
check if the next byte(s) are inside a given range
Definition XrdOucJson.hh:6743
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:6642
bool scan_comment()
scan a comment
Definition XrdOucJson.hh:7370
JSON_HEDLEY_RETURNS_NON_NULL constexpr const char * get_error_message() const noexcept
return syntax error message
Definition XrdOucJson.hh:7999
exception indicating other library errors
Definition XrdOucJson.hh:3015
static other_error create(int id_, const std::string &what_arg, const BasicJsonType &context)
Definition XrdOucJson.hh:3018
exception indicating access out of the defined range
Definition XrdOucJson.hh:2976
static out_of_range create(int id_, const std::string &what_arg, const BasicJsonType &context)
Definition XrdOucJson.hh:2979
Definition XrdOucJson.hh:13563
output_adapter(std::vector< CharType > &vec)
Definition XrdOucJson.hh:13565
output_adapter(std::basic_ostream< CharType > &s)
Definition XrdOucJson.hh:13569
output_adapter(StringType &s)
Definition XrdOucJson.hh:13573
output adapter for output streams
Definition XrdOucJson.hh:13515
void write_character(CharType c) override
Definition XrdOucJson.hh:13521
std::basic_ostream< CharType > & stream
Definition XrdOucJson.hh:13533
output_stream_adapter(std::basic_ostream< CharType > &s) noexcept
Definition XrdOucJson.hh:13517
output adapter for basic_string
Definition XrdOucJson.hh:13540
void write_character(CharType c) override
Definition XrdOucJson.hh:13546
StringType & str
Definition XrdOucJson.hh:13558
output_string_adapter(StringType &s) noexcept
Definition XrdOucJson.hh:13542
output adapter for byte vectors
Definition XrdOucJson.hh:13490
std::vector< CharType > & v
Definition XrdOucJson.hh:13508
output_vector_adapter(std::vector< CharType > &vec) noexcept
Definition XrdOucJson.hh:13492
void write_character(CharType c) override
Definition XrdOucJson.hh:13496
exception indicating a parse error
Definition XrdOucJson.hh:2785
parse_error(int id_, std::size_t byte_, const char *what_arg)
Definition XrdOucJson.hh:2825
static parse_error create(int id_, std::size_t byte_, const std::string &what_arg, const BasicJsonType &context)
Definition XrdOucJson.hh:2805
const std::size_t byte
byte index of the parse error
Definition XrdOucJson.hh:2822
static parse_error create(int id_, const position_t &pos, const std::string &what_arg, const BasicJsonType &context)
create a parse error exception
Definition XrdOucJson.hh:2797
static std::string position_string(const position_t &pos)
Definition XrdOucJson.hh:2828
syntax analysis
Definition XrdOucJson.hh:10884
lexer_t m_lexer
the lexer
Definition XrdOucJson.hh:11324
bool sax_parse(SAX *sax, const bool strict=true)
Definition XrdOucJson.hh:10984
token_type get_token()
get next token from lexer
Definition XrdOucJson.hh:11284
token_type last_token
the type of the last read token
Definition XrdOucJson.hh:11322
parser(InputAdapterType &&adapter, const parser_callback_t< BasicJsonType > cb=nullptr, const bool allow_exceptions_=true, const bool skip_comments=false)
a parser reading from an input adapter
Definition XrdOucJson.hh:10894
bool accept(const bool strict=true)
public accept interface
Definition XrdOucJson.hh:10976
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:10888
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:10886
typename lexer_t::token_type token_type
Definition XrdOucJson.hh:10890
bool sax_parse_internal(SAX *sax)
Definition XrdOucJson.hh:11003
const parser_callback_t< BasicJsonType > callback
callback function
Definition XrdOucJson.hh:11320
void parse(const bool strict, BasicJsonType &result)
public parser interface
Definition XrdOucJson.hh:10916
std::string exception_message(const token_type expected, const std::string &context)
Definition XrdOucJson.hh:11289
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:10887
const bool allow_exceptions
whether to throw exceptions in case of errors
Definition XrdOucJson.hh:11326
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:10885
Definition XrdOucJson.hh:11358
primitive_iterator_t operator+(difference_type n) noexcept
Definition XrdOucJson.hh:11408
primitive_iterator_t & operator++() noexcept
Definition XrdOucJson.hh:11420
constexpr bool is_end() const noexcept
return whether the iterator is at end
Definition XrdOucJson.hh:11393
primitive_iterator_t & operator-=(difference_type n) noexcept
Definition XrdOucJson.hh:11452
constexpr bool is_begin() const noexcept
return whether the iterator can be dereferenced
Definition XrdOucJson.hh:11387
friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition XrdOucJson.hh:11403
void set_begin() noexcept
set iterator to a defined beginning
Definition XrdOucJson.hh:11375
primitive_iterator_t const operator++(int) noexcept
Definition XrdOucJson.hh:11426
static constexpr difference_type end_value
Definition XrdOucJson.hh:11362
friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition XrdOucJson.hh:11398
friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition XrdOucJson.hh:11415
primitive_iterator_t & operator--() noexcept
Definition XrdOucJson.hh:11433
void set_end() noexcept
set iterator to a defined past the end
Definition XrdOucJson.hh:11381
constexpr difference_type get_value() const noexcept
Definition XrdOucJson.hh:11369
primitive_iterator_t const operator--(int) noexcept
Definition XrdOucJson.hh:11439
std::ptrdiff_t difference_type
Definition XrdOucJson.hh:11360
primitive_iterator_t & operator+=(difference_type n) noexcept
Definition XrdOucJson.hh:11446
static constexpr difference_type begin_value
Definition XrdOucJson.hh:11361
Definition XrdOucJson.hh:16370
const error_handler_t error_handler
error_handler how to react on decoding errors
Definition XrdOucJson.hh:17281
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:16374
const std::lconv * loc
the locale
Definition XrdOucJson.hh:17266
std::array< char, 64 > number_buffer
a (hopefully) large enough character buffer
Definition XrdOucJson.hh:17263
static constexpr std::uint8_t UTF8_ACCEPT
Definition XrdOucJson.hh:16376
serializer(serializer &&)=delete
serializer & operator=(serializer &&)=delete
const char decimal_point
the locale's decimal point character
Definition XrdOucJson.hh:17270
std::uint8_t state
Definition XrdOucJson.hh:16712
std::size_t bytes
Definition XrdOucJson.hh:16713
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:16372
const char thousands_sep
the locale's thousand separator character
Definition XrdOucJson.hh:17268
serializer & operator=(const serializer &)=delete
std::size_t undumped_chars
Definition XrdOucJson.hh:16717
static constexpr std::uint8_t UTF8_REJECT
Definition XrdOucJson.hh:16377
void dump(const BasicJsonType &val, const bool pretty_print, const bool ensure_ascii, const unsigned int indent_step, const unsigned int current_indent=0)
internal implementation of the serialization function
Definition XrdOucJson.hh:16425
const char indent_char
the indentation character
Definition XrdOucJson.hh:17276
std::size_t bytes_after_last_accept
Definition XrdOucJson.hh:16716
std::array< char, 512 > string_buffer
string buffer
Definition XrdOucJson.hh:17273
typename BasicJsonType::binary_t::value_type binary_char_t
Definition XrdOucJson.hh:16375
JSON_PRIVATE_UNLESS_TESTED const bool ensure_ascii
Definition XrdOucJson.hh:16710
serializer(output_adapter_t< char > s, const char ichar, error_handler_t error_handler_=error_handler_t::strict)
Definition XrdOucJson.hh:16385
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:16371
serializer(const serializer &)=delete
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:16373
string_t indent_string
the indentation string
Definition XrdOucJson.hh:17278
exception indicating executing a member function with a wrong type
Definition XrdOucJson.hh:2928
static type_error create(int id_, const std::string &what_arg, const BasicJsonType &context)
Definition XrdOucJson.hh:2931
JSON Pointer.
Definition XrdOucJson.hh:12381
std::vector< std::string > reference_tokens
the reference tokens
Definition XrdOucJson.hh:13348
JSON_PRIVATE_UNLESS_TESTED JSON pointer has no BasicJsonType()))
json_pointer & operator/=(std::string token)
append an unescaped reference token at the end of this JSON pointer
Definition XrdOucJson.hh:12482
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
Definition XrdOucJson.hh:12458
std::string to_string() const
return a string representation of the JSON pointer
Definition XrdOucJson.hh:12426
const BasicJsonType & get_unchecked(const BasicJsonType *ptr) const
return a const reference to the pointed to value
Definition XrdOucJson.hh:12963
friend bool operator==(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for equality
Definition XrdOucJson.hh:13324
result reference_tokens
Definition XrdOucJson.hh:12747
void pop_back()
remove last reference token
Definition XrdOucJson.hh:12608
const std::string & back() const
return last reference token
Definition XrdOucJson.hh:12632
const BasicJsonType & get_checked(const BasicJsonType *ptr) const
Definition XrdOucJson.hh:13011
bool empty() const noexcept
return whether pointer points to the root document
Definition XrdOucJson.hh:12679
friend bool operator!=(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for inequality
Definition XrdOucJson.hh:13341
void push_back(const std::string &token)
append an unescaped token at the end of the reference pointer
Definition XrdOucJson.hh:12654
json_pointer(const std::string &s="")
create JSON pointer
Definition XrdOucJson.hh:12408
return result
Definition XrdOucJson.hh:12748
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
Definition XrdOucJson.hh:12524
bool contains(const BasicJsonType *ptr) const
Definition XrdOucJson.hh:13059
static BasicJsonType unflatten(const BasicJsonType &value)
Definition XrdOucJson.hh:13286
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
Definition XrdOucJson.hh:12545
BasicJsonType & get_and_create(BasicJsonType &j) const
create and return a reference to the pointed to value
Definition XrdOucJson.hh:12760
static void flatten(const std::string &reference_string, const BasicJsonType &value, BasicJsonType &result)
Definition XrdOucJson.hh:13215
void push_back(std::string &&token)
append an unescaped token at the end of the reference pointer
Definition XrdOucJson.hh:12660
BasicJsonType & get_checked(BasicJsonType *ptr) const
Definition XrdOucJson.hh:12906
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON pointer
Definition XrdOucJson.hh:12504
static BasicJsonType::size_type array_index(const std::string &s)
Definition XrdOucJson.hh:12695
json_pointer result
Definition XrdOucJson.hh:12746
BasicJsonType & get_unchecked(BasicJsonType *ptr) const
return a reference to the pointed to value
Definition XrdOucJson.hh:12839
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
Definition XrdOucJson.hh:12565
json_pointer parent_pointer() const
returns the parent of this JSON pointer
Definition XrdOucJson.hh:12583
static std::vector< std::string > split(const std::string &reference_string)
split the string input to reference tokens
Definition XrdOucJson.hh:13147
decltype(get< N >(std::declval< ::nlohmann::detail::iteration_proxy_value< IteratorType > >())) type
Definition XrdOucJson.hh:4533
void grisu2(char *buf, int &len, int &decimal_exponent, diyfp m_minus, diyfp v, diyfp m_plus)
Definition XrdOucJson.hh:16047
JSON_HEDLEY_RETURNS_NON_NULL char * format_buffer(char *buf, int len, int decimal_exponent, int min_exp, int max_exp)
prettify v = buf * 10^decimal_exponent
Definition XrdOucJson.hh:16199
Target reinterpret_bits(const Source source)
Definition XrdOucJson.hh:15267
boundaries compute_boundaries(FloatType value)
Definition XrdOucJson.hh:15408
int find_largest_pow10(const std::uint32_t n, std::uint32_t &pow10)
Definition XrdOucJson.hh:15711
constexpr int kGamma
Definition XrdOucJson.hh:15531
void grisu2_round(char *buf, int len, std::uint64_t dist, std::uint64_t delta, std::uint64_t rest, std::uint64_t ten_k)
Definition XrdOucJson.hh:15765
JSON_HEDLEY_RETURNS_NON_NULL char * append_exponent(char *buf, int e)
appends a decimal representation of e to buf
Definition XrdOucJson.hh:16147
void grisu2_digit_gen(char *buffer, int &length, int &decimal_exponent, diyfp M_minus, diyfp w, diyfp M_plus)
Definition XrdOucJson.hh:15806
constexpr int kAlpha
Definition XrdOucJson.hh:15530
cached_power get_cached_power_for_binary_exponent(int e)
Definition XrdOucJson.hh:15547
typename std::enable_if< B, T >::type enable_if_t
Definition XrdOucJson.hh:3063
typename T::reference reference_t
Definition XrdOucJson.hh:3490
bool operator<(const value_t lhs, const value_t rhs) noexcept
comparison operator for JSON types
Definition XrdOucJson.hh:147
static void unescape(std::string &s)
string unescaping as described in RFC 6901 (Sect. 4)
Definition XrdOucJson.hh:2572
decltype(T::from_json(std::declval< Args >()...)) from_json_function
Definition XrdOucJson.hh:3502
void to_json(BasicJsonType &j, T b) noexcept
Definition XrdOucJson.hh:4785
value_t
the JSON type enumeration
Definition XrdOucJson.hh:121
@ number_integer
number value (signed integer)
@ discarded
discarded by the parser callback function
@ binary
binary array (ordered collection of bytes)
@ object
object (unordered set of name/value pairs)
@ number_float
number value (floating-point)
@ number_unsigned
number value (unsigned integer)
@ array
array (ordered collection of values)
void from_json(const BasicJsonType &j, typename std::nullptr_t &n)
Definition XrdOucJson.hh:3894
make_index_sequence< sizeof...(Ts)> index_sequence_for
Definition XrdOucJson.hh:3167
decltype(std::declval< T & >().parse_error(std::declval< std::size_t >(), std::declval< const std::string & >(), std::declval< const Exception & >())) parse_error_function_t
Definition XrdOucJson.hh:8225
typename T::pointer pointer_t
Definition XrdOucJson.hh:3487
decltype(std::declval< T & >().string(std::declval< String & >())) string_function_t
Definition XrdOucJson.hh:8198
std::function< bool(int, parse_event_t, BasicJsonType &)> parser_callback_t
Definition XrdOucJson.hh:10875
typename T::difference_type difference_type_t
Definition XrdOucJson.hh:3484
typename detector< nonesuch, void, Op, Args... >::type detected_t
Definition XrdOucJson.hh:3329
void int_to_string(string_type &target, std::size_t value)
Definition XrdOucJson.hh:4366
void from_json_array_impl(const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag< 3 >)
Definition XrdOucJson.hh:4049
decltype(std::declval< T & >().key(std::declval< String & >())) key_function_t
Definition XrdOucJson.hh:8210
decltype(std::declval< T & >().boolean(std::declval< bool >())) boolean_function_t
Definition XrdOucJson.hh:8182
decltype(std::declval< T & >().binary(std::declval< Binary & >())) binary_function_t
Definition XrdOucJson.hh:8202
decltype(std::declval< T & >().number_integer(std::declval< Integer >())) number_integer_function_t
Definition XrdOucJson.hh:8186
JSON_HEDLEY_RETURNS_NON_NULL char * to_chars(char *first, const char *last, FloatType value)
generates a decimal representation of the floating-point number value in [first, last).
Definition XrdOucJson.hh:16284
void to_json_tuple_impl(BasicJsonType &j, const Tuple &t, index_sequence< Idx... >)
Definition XrdOucJson.hh:4908
std::is_convertible< detected_t< Op, Args... >, To > is_detected_convertible
Definition XrdOucJson.hh:3342
typename std::remove_cv< typename std::remove_reference< T >::type >::type uncvref_t
Definition XrdOucJson.hh:3049
cbor_tag_handler_t
how to treat CBOR tags
Definition XrdOucJson.hh:8326
@ store
store tags as binary type
@ error
throw a parse_error exception in case of a tag
parse_event_t
Definition XrdOucJson.hh:10858
@ value
the parser finished reading a JSON value
@ key
the parser read a key of a value in an object
@ array_end
the parser read ] and finished processing a JSON array
@ array_start
the parser read [ and started to process a JSON array
@ object_start
the parser read { and started to process a JSON object
@ object_end
the parser read } and finished processing a JSON object
error_handler_t
how to treat decoding errors
Definition XrdOucJson.hh:16362
@ strict
throw a type_error exception in case of invalid UTF-8
@ ignore
ignore invalid UTF-8 sequences
@ replace
replace invalid UTF-8 sequences with U+FFFD
decltype(std::declval< T & >().start_object(std::declval< std::size_t >())) start_object_function_t
Definition XrdOucJson.hh:8206
iterator_input_adapter_factory< IteratorType >::adapter_type input_adapter(IteratorType first, IteratorType last)
Definition XrdOucJson.hh:5703
typename T::key_type key_type_t
Definition XrdOucJson.hh:3478
std::size_t combine(std::size_t seed, std::size_t h) noexcept
Definition XrdOucJson.hh:5203
std::size_t hash(const BasicJsonType &j)
hash a JSON value
Definition XrdOucJson.hh:5221
typename utility_internal::Gen< T, N >::type make_integer_sequence
Definition XrdOucJson.hh:3151
decltype(std::declval< T & >().number_unsigned(std::declval< Unsigned >())) number_unsigned_function_t
Definition XrdOucJson.hh:8190
std::is_same< Expected, detected_t< Op, Args... > > is_detected_exact
Definition XrdOucJson.hh:3338
typename detected_or< Default, Op, Args... >::type detected_or_t
Definition XrdOucJson.hh:3335
decltype(std::declval< T & >().start_array(std::declval< std::size_t >())) start_array_function_t
Definition XrdOucJson.hh:8217
std::pair< A1, A2 > from_json_tuple_impl(BasicJsonType &&j, identity_tag< std::pair< A1, A2 > >, priority_tag< 0 >)
Definition XrdOucJson.hh:4238
void get_arithmetic_value(const BasicJsonType &j, ArithmeticType &val)
Definition XrdOucJson.hh:3908
typename detector< nonesuch, void, Op, Args... >::value_t is_detected
Definition XrdOucJson.hh:3323
typename make_void< Ts... >::type void_t
Definition XrdOucJson.hh:3226
make_integer_sequence< size_t, N > make_index_sequence
Definition XrdOucJson.hh:3159
std::shared_ptr< output_adapter_protocol< CharType > > output_adapter_t
a type to simplify interfaces
Definition XrdOucJson.hh:13485
typename T::mapped_type mapped_type_t
Definition XrdOucJson.hh:3475
std::string escape(std::string s)
string escaping as described in RFC 6901 (Sect. 4)
Definition XrdOucJson.hh:2558
typename T::iterator iterator_t
Definition XrdOucJson.hh:3496
input_format_t
the supported input formats
Definition XrdOucJson.hh:5357
std::tuple< Args... > from_json_tuple_impl_base(BasicJsonType &&j, index_sequence< Idx... >)
Definition XrdOucJson.hh:4232
decltype(std::declval< T >().template get< U >()) get_template_function
Definition XrdOucJson.hh:3505
std::array< T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType &&j, identity_tag< std::array< T, sizeof...(Idx)> >, index_sequence< Idx... >)
Definition XrdOucJson.hh:4132
decltype(input_adapter(std::declval< const char * >(), std::declval< const char * >())) contiguous_bytes_input_adapter
Definition XrdOucJson.hh:5760
decltype(std::declval< T & >().null()) null_function_t
Definition XrdOucJson.hh:8178
auto get(const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())
Definition XrdOucJson.hh:4497
void replace_substring(std::string &s, const std::string &f, const std::string &t)
replace all occurrences of a substring by another string
Definition XrdOucJson.hh:2540
typename T::iterator_category iterator_category_t
Definition XrdOucJson.hh:3493
static bool little_endianess(int num=1) noexcept
determine system byte order
Definition XrdOucJson.hh:8339
decltype(std::declval< T & >().number_float(std::declval< Float >(), std::declval< const String & >())) number_float_function_t
Definition XrdOucJson.hh:8194
decltype(std::declval< T & >().end_array()) end_array_function_t
Definition XrdOucJson.hh:8220
decltype(std::declval< T & >().end_object()) end_object_function_t
Definition XrdOucJson.hh:8213
T conditional_static_cast(U value)
Definition XrdOucJson.hh:3872
decltype(T::to_json(std::declval< Args >()...)) to_json_function
Definition XrdOucJson.hh:3499
typename T::value_type value_type_t
Definition XrdOucJson.hh:3481
namespace for Niels Lohmann
Definition XrdOucJson.hh:89
basic_json<> json
default JSON class
Definition XrdOucJson.hh:3408
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
Definition XrdOucJson.hh:26358
Definition XrdOucJson.hh:4517
default JSONSerializer template argument
Definition XrdOucJson.hh:4949
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
Definition XrdOucJson.hh:4962
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
Definition XrdOucJson.hh:4982
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
Definition XrdOucJson.hh:4999
Definition XrdOucJson.hh:3567
Op< Args... > type
Definition XrdOucJson.hh:3319
std::true_type value_t
Definition XrdOucJson.hh:3318
Definition XrdOucJson.hh:3310
Default type
Definition XrdOucJson.hh:3312
std::false_type value_t
Definition XrdOucJson.hh:3311
Definition XrdOucJson.hh:15395
diyfp plus
Definition XrdOucJson.hh:15398
diyfp w
Definition XrdOucJson.hh:15396
diyfp minus
Definition XrdOucJson.hh:15397
Definition XrdOucJson.hh:15534
std::uint64_t f
Definition XrdOucJson.hh:15535
int k
Definition XrdOucJson.hh:15537
int e
Definition XrdOucJson.hh:15536
Definition XrdOucJson.hh:15277
static constexpr int kPrecision
Definition XrdOucJson.hh:15278
static diyfp normalize(diyfp x) noexcept
normalize x such that the significand is >= 2^(q-1)
Definition XrdOucJson.hh:15366
static diyfp normalize_to(const diyfp &x, const int target_exponent) noexcept
normalize x such that the result has the exponent E
Definition XrdOucJson.hh:15383
static diyfp mul(const diyfp &x, const diyfp &y) noexcept
returns x * y
Definition XrdOucJson.hh:15301
constexpr diyfp(std::uint64_t f_, int e_) noexcept
Definition XrdOucJson.hh:15283
int e
Definition XrdOucJson.hh:15281
std::uint64_t f
Definition XrdOucJson.hh:15280
static diyfp sub(const diyfp &x, const diyfp &y) noexcept
returns x - y
Definition XrdOucJson.hh:15289
static void construct(BasicJsonType &j, const CompatibleArrayType &arr)
Definition XrdOucJson.hh:4697
static void construct(BasicJsonType &j, const std::valarray< T > &arr)
Definition XrdOucJson.hh:4726
static void construct(BasicJsonType &j, const std::vector< bool > &arr)
Definition XrdOucJson.hh:4710
static void construct(BasicJsonType &j, typename BasicJsonType::array_t &&arr)
Definition XrdOucJson.hh:4685
static void construct(BasicJsonType &j, const typename BasicJsonType::array_t &arr)
Definition XrdOucJson.hh:4675
static void construct(BasicJsonType &j, const typename BasicJsonType::binary_t &b)
Definition XrdOucJson.hh:4614
static void construct(BasicJsonType &j, typename BasicJsonType::binary_t &&b)
Definition XrdOucJson.hh:4623
static void construct(BasicJsonType &j, typename BasicJsonType::boolean_t b) noexcept
Definition XrdOucJson.hh:4568
static void construct(BasicJsonType &j, typename BasicJsonType::number_float_t val) noexcept
Definition XrdOucJson.hh:4636
static void construct(BasicJsonType &j, typename BasicJsonType::number_integer_t val) noexcept
Definition XrdOucJson.hh:4662
static void construct(BasicJsonType &j, typename BasicJsonType::number_unsigned_t val) noexcept
Definition XrdOucJson.hh:4649
static void construct(BasicJsonType &j, typename BasicJsonType::object_t &&obj)
Definition XrdOucJson.hh:4755
static void construct(BasicJsonType &j, const typename BasicJsonType::object_t &obj)
Definition XrdOucJson.hh:4745
static void construct(BasicJsonType &j, const CompatibleObjectType &obj)
Definition XrdOucJson.hh:4766
static void construct(BasicJsonType &j, typename BasicJsonType::string_t &&s)
Definition XrdOucJson.hh:4590
static void construct(BasicJsonType &j, const CompatibleStringType &str)
Definition XrdOucJson.hh:4601
static void construct(BasicJsonType &j, const typename BasicJsonType::string_t &s)
Definition XrdOucJson.hh:4581
Definition XrdOucJson.hh:4562
Definition XrdOucJson.hh:4315
auto operator()(const BasicJsonType &j, T &&val) const noexcept(noexcept(from_json(j, std::forward< T >(val)))) -> decltype(from_json(j, std::forward< T >(val)))
Definition XrdOucJson.hh:4317
typename BasicJsonType::template json_serializer< T, void > serializer
Definition XrdOucJson.hh:3524
Definition XrdOucJson.hh:3509
typename BasicJsonType::template json_serializer< T, void > serializer
Definition XrdOucJson.hh:3539
Definition XrdOucJson.hh:3534
typename BasicJsonType::template json_serializer< T, void > serializer
Definition XrdOucJson.hh:3554
Definition XrdOucJson.hh:3549
Definition XrdOucJson.hh:3198
Definition XrdOucJson.hh:3091
T value_type
Definition XrdOucJson.hh:3092
static constexpr std::size_t size() noexcept
Definition XrdOucJson.hh:3093
an iterator value
Definition XrdOucJson.hh:11473
primitive_iterator_t primitive_iterator
generic iterator for all other types
Definition XrdOucJson.hh:11479
BasicJsonType::array_t::iterator array_iterator
iterator for JSON arrays
Definition XrdOucJson.hh:11477
BasicJsonType::object_t::iterator object_iterator
iterator for JSON objects
Definition XrdOucJson.hh:11475
Definition XrdOucJson.hh:3452
Definition XrdOucJson.hh:3738
Definition XrdOucJson.hh:3758
std::numeric_limits< CompatibleNumberIntegerType > CompatibleLimits
Definition XrdOucJson.hh:3816
std::numeric_limits< RealIntegerType > RealLimits
Definition XrdOucJson.hh:3815
Definition XrdOucJson.hh:3805
Definition XrdOucJson.hh:3828
typename BasicJsonType::object_t object_t
Definition XrdOucJson.hh:3653
Definition XrdOucJson.hh:3645
Definition XrdOucJson.hh:3665
Definition XrdOucJson.hh:3702
Definition XrdOucJson.hh:3716
Definition XrdOucJson.hh:3831
Definition XrdOucJson.hh:3844
Definition XrdOucJson.hh:3638
Definition XrdOucJson.hh:3761
Definition XrdOucJson.hh:3801
typename BasicJsonType::object_t object_t
Definition XrdOucJson.hh:3677
Definition XrdOucJson.hh:3669
Definition XrdOucJson.hh:3698
Definition XrdOucJson.hh:3720
Definition XrdOucJson.hh:3735
Definition XrdOucJson.hh:3847
Definition XrdOucJson.hh:3600
Definition XrdOucJson.hh:3580
Definition XrdOucJson.hh:3326
Definition XrdOucJson.hh:3517
static constexpr bool value
Definition XrdOucJson.hh:3518
Definition XrdOucJson.hh:5679
typename std::iterator_traits< T >::value_type value_type
Definition XrdOucJson.hh:5680
Definition XrdOucJson.hh:3616
Definition XrdOucJson.hh:3465
Definition XrdOucJson.hh:3860
char x[2]
Definition XrdOucJson.hh:3861
Definition XrdOucJson.hh:3856
@ value
Definition XrdOucJson.hh:3867
char one
Definition XrdOucJson.hh:3857
static one test(decltype(&C::capacity))
Definition XrdOucJson.hh:8260
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:8268
typename BasicJsonType::exception exception_t
Definition XrdOucJson.hh:8270
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:8265
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:8267
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:8269
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:8266
Definition XrdOucJson.hh:8229
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:8236
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition XrdOucJson.hh:8235
typename BasicJsonType::exception exception_t
Definition XrdOucJson.hh:8239
static constexpr bool value
Definition XrdOucJson.hh:8242
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:8234
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:8237
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:8238
T & reference
Definition XrdOucJson.hh:3273
T * pointer
Definition XrdOucJson.hh:3272
T value_type
Definition XrdOucJson.hh:3270
std::random_access_iterator_tag iterator_category
Definition XrdOucJson.hh:3269
ptrdiff_t difference_type
Definition XrdOucJson.hh:3271
Definition XrdOucJson.hh:3257
typename It::difference_type difference_type
Definition XrdOucJson.hh:3246
typename It::reference reference
Definition XrdOucJson.hh:3249
typename It::iterator_category iterator_category
Definition XrdOucJson.hh:3250
typename It::pointer pointer
Definition XrdOucJson.hh:3248
typename It::value_type value_type
Definition XrdOucJson.hh:3247
Definition XrdOucJson.hh:3238
Definition XrdOucJson.hh:3223
void type
Definition XrdOucJson.hh:3224
Definition XrdOucJson.hh:3574
Definition XrdOucJson.hh:3296
nonesuch(nonesuch const &)=delete
void operator=(nonesuch &&)=delete
nonesuch(nonesuch const &&)=delete
void operator=(nonesuch const &)=delete
abstract output adapter interface
Definition XrdOucJson.hh:13471
virtual void write_characters(const CharType *s, std::size_t length)=0
virtual void write_character(CharType c)=0
output_adapter_protocol(output_adapter_protocol &&) noexcept=default
virtual ~output_adapter_protocol()=default
output_adapter_protocol(const output_adapter_protocol &)=default
output_adapter_protocol()=default
struct to capture the start position of the current token
Definition XrdOucJson.hh:2592
std::size_t lines_read
the number of lines read
Definition XrdOucJson.hh:2598
std::size_t chars_read_current_line
the number of characters read in the current line
Definition XrdOucJson.hh:2596
std::size_t chars_read_total
the total number of characters read
Definition XrdOucJson.hh:2594
Definition XrdOucJson.hh:3174
Definition XrdOucJson.hh:3180
static constexpr T value
Definition XrdOucJson.hh:3181
Definition XrdOucJson.hh:4920
auto operator()(BasicJsonType &j, T &&val) const noexcept(noexcept(to_json(j, std::forward< T >(val)))) -> decltype(to_json(j, std::forward< T >(val)), void())
Definition XrdOucJson.hh:4922
Definition XrdOucJson.hh:3111
Definition XrdOucJson.hh:3130
typename Extend< typename Gen< T, N/2 >::type, N/2, N % 2 >::type type
Definition XrdOucJson.hh:3132
SAX interface.
Definition XrdOucJson.hh:5842
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
virtual bool null()=0
a null value was read
typename BasicJsonType::number_integer_t number_integer_t
Definition XrdOucJson.hh:5843
typename BasicJsonType::binary_t binary_t
Definition XrdOucJson.hh:5847
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
Definition XrdOucJson.hh:5844
virtual bool binary(binary_t &val)=0
a binary string was read
typename BasicJsonType::number_float_t number_float_t
Definition XrdOucJson.hh:5845
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
json_sax(json_sax &&) noexcept=default
virtual bool boolean(bool val)=0
a boolean value was read
json_sax(const json_sax &)=default
virtual bool end_object()=0
the end of an object was read
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
typename BasicJsonType::string_t string_t
Definition XrdOucJson.hh:5846
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
Definition XrdOucJson.hh:17313
T & at(const Key &key)
Definition XrdOucJson.hh:17354
ordered_map(std::initializer_list< T > init, const Allocator &alloc=Allocator())
Definition XrdOucJson.hh:17328
std::vector< std::pair< const Key, T >, Allocator > Container
Definition XrdOucJson.hh:17316
T mapped_type
Definition XrdOucJson.hh:17315
const T & at(const Key &key) const
Definition XrdOucJson.hh:17367
iterator find(const Key &key)
Definition XrdOucJson.hh:17425
iterator erase(iterator pos)
Definition XrdOucJson.hh:17399
void insert(InputIt first, InputIt last)
Definition XrdOucJson.hh:17472
std::pair< iterator, bool > insert(value_type &&value)
Definition XrdOucJson.hh:17449
const_iterator find(const Key &key) const
Definition XrdOucJson.hh:17437
Key key_type
Definition XrdOucJson.hh:17314
size_type erase(const Key &key)
Definition XrdOucJson.hh:17380
T & operator[](const Key &key)
Definition XrdOucJson.hh:17344
ordered_map(const Allocator &alloc=Allocator())
Definition XrdOucJson.hh:17324
typename std::enable_if< std::is_convertible< typename std::iterator_traits< InputIt >::iterator_category, std::input_iterator_tag >::value >::type require_input_iter
Definition XrdOucJson.hh:17469
ordered_map(It first, It last, const Allocator &alloc=Allocator())
Definition XrdOucJson.hh:17326
std::pair< iterator, bool > insert(const value_type &value)
Definition XrdOucJson.hh:17454
size_type count(const Key &key) const
Definition XrdOucJson.hh:17413
std::pair< iterator, bool > emplace(const key_type &key, T &&t)
Definition XrdOucJson.hh:17331
const T & operator[](const Key &key) const
Definition XrdOucJson.hh:17349
std::size_t operator()(const nlohmann::json &j) const
return a hash value for a JSON object
Definition XrdOucJson.hh:26381
bool operator()(nlohmann::detail::value_t lhs, nlohmann::detail::value_t rhs) const noexcept
compare two value_t enum values
Definition XrdOucJson.hh:26397