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 9
35 #define NLOHMANN_JSON_VERSION_PATCH 1
40 #include <initializer_list>
54 #include <type_traits>
62 #include <forward_list>
67 #include <type_traits>
68 #include <unordered_map>
120 enum class value_t : std::uint8_t
147 inline bool operator<(
const value_t lhs,
const value_t rhs) noexcept
149 static constexpr std::array<std::uint8_t, 9> order = {{
156 const auto l_index =
static_cast<std::size_t
>(lhs);
157 const auto r_index =
static_cast<std::size_t
>(rhs);
158 return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
186 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
187 #if defined(JSON_HEDLEY_VERSION)
188 #undef JSON_HEDLEY_VERSION
190 #define JSON_HEDLEY_VERSION 15
192 #if defined(JSON_HEDLEY_STRINGIFY_EX)
193 #undef JSON_HEDLEY_STRINGIFY_EX
195 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
197 #if defined(JSON_HEDLEY_STRINGIFY)
198 #undef JSON_HEDLEY_STRINGIFY
200 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
202 #if defined(JSON_HEDLEY_CONCAT_EX)
203 #undef JSON_HEDLEY_CONCAT_EX
205 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
207 #if defined(JSON_HEDLEY_CONCAT)
208 #undef JSON_HEDLEY_CONCAT
210 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
212 #if defined(JSON_HEDLEY_CONCAT3_EX)
213 #undef JSON_HEDLEY_CONCAT3_EX
215 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
217 #if defined(JSON_HEDLEY_CONCAT3)
218 #undef JSON_HEDLEY_CONCAT3
220 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
222 #if defined(JSON_HEDLEY_VERSION_ENCODE)
223 #undef JSON_HEDLEY_VERSION_ENCODE
225 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
227 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
228 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
230 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
232 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
233 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
235 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
237 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
238 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
240 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
242 #if defined(JSON_HEDLEY_GNUC_VERSION)
243 #undef JSON_HEDLEY_GNUC_VERSION
245 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
246 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
247 #elif defined(__GNUC__)
248 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
251 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
252 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
254 #if defined(JSON_HEDLEY_GNUC_VERSION)
255 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
257 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
260 #if defined(JSON_HEDLEY_MSVC_VERSION)
261 #undef JSON_HEDLEY_MSVC_VERSION
263 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
264 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
265 #elif defined(_MSC_FULL_VER) && !defined(__ICL)
266 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
267 #elif defined(_MSC_VER) && !defined(__ICL)
268 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
271 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
272 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
274 #if !defined(JSON_HEDLEY_MSVC_VERSION)
275 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
276 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
277 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
278 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
279 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
281 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
284 #if defined(JSON_HEDLEY_INTEL_VERSION)
285 #undef JSON_HEDLEY_INTEL_VERSION
287 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
288 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
289 #elif defined(__INTEL_COMPILER) && !defined(__ICL)
290 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
293 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
294 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
296 #if defined(JSON_HEDLEY_INTEL_VERSION)
297 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
299 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
302 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
303 #undef JSON_HEDLEY_INTEL_CL_VERSION
305 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
306 #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
309 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
310 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
312 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
313 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
315 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
318 #if defined(JSON_HEDLEY_PGI_VERSION)
319 #undef JSON_HEDLEY_PGI_VERSION
321 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
322 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
325 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
326 #undef JSON_HEDLEY_PGI_VERSION_CHECK
328 #if defined(JSON_HEDLEY_PGI_VERSION)
329 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
331 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
334 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
335 #undef JSON_HEDLEY_SUNPRO_VERSION
337 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
338 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
339 #elif defined(__SUNPRO_C)
340 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
341 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
342 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
343 #elif defined(__SUNPRO_CC)
344 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
347 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
348 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
350 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
351 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
353 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
356 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
357 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
359 #if defined(__EMSCRIPTEN__)
360 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
363 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
364 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
366 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
367 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
369 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
372 #if defined(JSON_HEDLEY_ARM_VERSION)
373 #undef JSON_HEDLEY_ARM_VERSION
375 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
376 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
377 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
378 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
381 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
382 #undef JSON_HEDLEY_ARM_VERSION_CHECK
384 #if defined(JSON_HEDLEY_ARM_VERSION)
385 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
387 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
390 #if defined(JSON_HEDLEY_IBM_VERSION)
391 #undef JSON_HEDLEY_IBM_VERSION
393 #if defined(__ibmxl__)
394 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
395 #elif defined(__xlC__) && defined(__xlC_ver__)
396 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
397 #elif defined(__xlC__)
398 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
401 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
402 #undef JSON_HEDLEY_IBM_VERSION_CHECK
404 #if defined(JSON_HEDLEY_IBM_VERSION)
405 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
407 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
410 #if defined(JSON_HEDLEY_TI_VERSION)
411 #undef JSON_HEDLEY_TI_VERSION
414 defined(__TI_COMPILER_VERSION__) && \
416 defined(__TMS470__) || defined(__TI_ARM__) || \
417 defined(__MSP430__) || \
418 defined(__TMS320C2000__) \
420 #if (__TI_COMPILER_VERSION__ >= 16000000)
421 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
425 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
426 #undef JSON_HEDLEY_TI_VERSION_CHECK
428 #if defined(JSON_HEDLEY_TI_VERSION)
429 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
431 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
434 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
435 #undef JSON_HEDLEY_TI_CL2000_VERSION
437 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
438 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
441 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
442 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
444 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
445 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
447 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
450 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
451 #undef JSON_HEDLEY_TI_CL430_VERSION
453 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
454 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
457 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
458 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
460 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
461 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
463 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
466 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
467 #undef JSON_HEDLEY_TI_ARMCL_VERSION
469 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
470 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
473 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
474 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
476 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
477 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
479 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
482 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
483 #undef JSON_HEDLEY_TI_CL6X_VERSION
485 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
486 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
489 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
490 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
492 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
493 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
495 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
498 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
499 #undef JSON_HEDLEY_TI_CL7X_VERSION
501 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
502 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
505 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
506 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
508 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
509 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
511 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
514 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
515 #undef JSON_HEDLEY_TI_CLPRU_VERSION
517 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
518 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
521 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
522 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
524 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
525 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
527 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
530 #if defined(JSON_HEDLEY_CRAY_VERSION)
531 #undef JSON_HEDLEY_CRAY_VERSION
534 #if defined(_RELEASE_PATCHLEVEL)
535 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
537 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
541 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
542 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
544 #if defined(JSON_HEDLEY_CRAY_VERSION)
545 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
547 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
550 #if defined(JSON_HEDLEY_IAR_VERSION)
551 #undef JSON_HEDLEY_IAR_VERSION
553 #if defined(__IAR_SYSTEMS_ICC__)
555 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
557 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
561 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
562 #undef JSON_HEDLEY_IAR_VERSION_CHECK
564 #if defined(JSON_HEDLEY_IAR_VERSION)
565 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
567 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
570 #if defined(JSON_HEDLEY_TINYC_VERSION)
571 #undef JSON_HEDLEY_TINYC_VERSION
573 #if defined(__TINYC__)
574 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
577 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
578 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
580 #if defined(JSON_HEDLEY_TINYC_VERSION)
581 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
583 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
586 #if defined(JSON_HEDLEY_DMC_VERSION)
587 #undef JSON_HEDLEY_DMC_VERSION
590 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
593 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
594 #undef JSON_HEDLEY_DMC_VERSION_CHECK
596 #if defined(JSON_HEDLEY_DMC_VERSION)
597 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
599 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
602 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
603 #undef JSON_HEDLEY_COMPCERT_VERSION
605 #if defined(__COMPCERT_VERSION__)
606 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
609 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
610 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
612 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
613 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
615 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
618 #if defined(JSON_HEDLEY_PELLES_VERSION)
619 #undef JSON_HEDLEY_PELLES_VERSION
621 #if defined(__POCC__)
622 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
625 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
626 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
628 #if defined(JSON_HEDLEY_PELLES_VERSION)
629 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
631 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
634 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
635 #undef JSON_HEDLEY_MCST_LCC_VERSION
637 #if defined(__LCC__) && defined(__LCC_MINOR__)
638 #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
641 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
642 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
644 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
645 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
647 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
650 #if defined(JSON_HEDLEY_GCC_VERSION)
651 #undef JSON_HEDLEY_GCC_VERSION
654 defined(JSON_HEDLEY_GNUC_VERSION) && \
655 !defined(__clang__) && \
656 !defined(JSON_HEDLEY_INTEL_VERSION) && \
657 !defined(JSON_HEDLEY_PGI_VERSION) && \
658 !defined(JSON_HEDLEY_ARM_VERSION) && \
659 !defined(JSON_HEDLEY_CRAY_VERSION) && \
660 !defined(JSON_HEDLEY_TI_VERSION) && \
661 !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
662 !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
663 !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
664 !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
665 !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
666 !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
667 !defined(__COMPCERT__) && \
668 !defined(JSON_HEDLEY_MCST_LCC_VERSION)
669 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
672 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
673 #undef JSON_HEDLEY_GCC_VERSION_CHECK
675 #if defined(JSON_HEDLEY_GCC_VERSION)
676 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
678 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
681 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
682 #undef JSON_HEDLEY_HAS_ATTRIBUTE
685 defined(__has_attribute) && \
687 (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
689 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
691 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
694 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
695 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
697 #if defined(__has_attribute)
698 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
700 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
703 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
704 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
706 #if defined(__has_attribute)
707 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
709 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
712 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
713 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
716 defined(__has_cpp_attribute) && \
717 defined(__cplusplus) && \
718 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
719 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
721 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
724 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
725 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
727 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
728 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
730 !defined(JSON_HEDLEY_PGI_VERSION) && \
731 !defined(JSON_HEDLEY_IAR_VERSION) && \
732 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
733 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
734 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
736 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
739 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
740 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
742 #if defined(__has_cpp_attribute) && defined(__cplusplus)
743 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
745 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
748 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
749 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
751 #if defined(__has_cpp_attribute) && defined(__cplusplus)
752 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
754 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
757 #if defined(JSON_HEDLEY_HAS_BUILTIN)
758 #undef JSON_HEDLEY_HAS_BUILTIN
760 #if defined(__has_builtin)
761 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
763 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
766 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
767 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
769 #if defined(__has_builtin)
770 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
772 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
775 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
776 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
778 #if defined(__has_builtin)
779 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
781 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
784 #if defined(JSON_HEDLEY_HAS_FEATURE)
785 #undef JSON_HEDLEY_HAS_FEATURE
787 #if defined(__has_feature)
788 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
790 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
793 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
794 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
796 #if defined(__has_feature)
797 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
799 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
802 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
803 #undef JSON_HEDLEY_GCC_HAS_FEATURE
805 #if defined(__has_feature)
806 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
808 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
811 #if defined(JSON_HEDLEY_HAS_EXTENSION)
812 #undef JSON_HEDLEY_HAS_EXTENSION
814 #if defined(__has_extension)
815 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
817 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
820 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
821 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
823 #if defined(__has_extension)
824 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
826 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
829 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
830 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
832 #if defined(__has_extension)
833 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
835 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
838 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
839 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
841 #if defined(__has_declspec_attribute)
842 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
844 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
847 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
848 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
850 #if defined(__has_declspec_attribute)
851 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
853 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
856 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
857 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
859 #if defined(__has_declspec_attribute)
860 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
862 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
865 #if defined(JSON_HEDLEY_HAS_WARNING)
866 #undef JSON_HEDLEY_HAS_WARNING
868 #if defined(__has_warning)
869 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
871 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
874 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
875 #undef JSON_HEDLEY_GNUC_HAS_WARNING
877 #if defined(__has_warning)
878 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
880 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
883 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
884 #undef JSON_HEDLEY_GCC_HAS_WARNING
886 #if defined(__has_warning)
887 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
889 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
893 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
894 defined(__clang__) || \
895 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
896 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
897 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
898 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
899 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
900 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
901 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
902 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
903 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
904 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
905 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
906 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
907 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
908 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
909 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
910 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
911 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
912 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
913 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
915 #define JSON_HEDLEY_PRAGMA(value)
918 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
919 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
921 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
922 #undef JSON_HEDLEY_DIAGNOSTIC_POP
924 #if defined(__clang__)
925 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
926 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
927 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
928 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
929 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
930 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
931 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
932 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
934 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
935 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
936 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
937 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
938 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
939 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
940 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
942 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
943 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
944 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
945 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
946 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
947 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
948 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
949 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
950 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
951 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
952 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
954 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
955 #define JSON_HEDLEY_DIAGNOSTIC_POP
960 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
961 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
963 #if defined(__cplusplus)
964 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
965 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
966 # if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
967 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
968 JSON_HEDLEY_DIAGNOSTIC_PUSH \
969 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
970 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
971 _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
973 JSON_HEDLEY_DIAGNOSTIC_POP
975 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
976 JSON_HEDLEY_DIAGNOSTIC_PUSH \
977 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
978 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
980 JSON_HEDLEY_DIAGNOSTIC_POP
983 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
984 JSON_HEDLEY_DIAGNOSTIC_PUSH \
985 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
987 JSON_HEDLEY_DIAGNOSTIC_POP
991 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
992 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
995 #if defined(JSON_HEDLEY_CONST_CAST)
996 #undef JSON_HEDLEY_CONST_CAST
998 #if defined(__cplusplus)
999 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1001 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1002 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1003 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1004 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1005 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1006 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1008 JSON_HEDLEY_DIAGNOSTIC_POP \
1011 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1014 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
1015 #undef JSON_HEDLEY_REINTERPRET_CAST
1017 #if defined(__cplusplus)
1018 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1020 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1023 #if defined(JSON_HEDLEY_STATIC_CAST)
1024 #undef JSON_HEDLEY_STATIC_CAST
1026 #if defined(__cplusplus)
1027 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1029 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1032 #if defined(JSON_HEDLEY_CPP_CAST)
1033 #undef JSON_HEDLEY_CPP_CAST
1035 #if defined(__cplusplus)
1036 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1037 # define JSON_HEDLEY_CPP_CAST(T, expr) \
1038 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1039 _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1041 JSON_HEDLEY_DIAGNOSTIC_POP
1042 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1043 # define JSON_HEDLEY_CPP_CAST(T, expr) \
1044 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1045 _Pragma("diag_suppress=Pe137") \
1046 JSON_HEDLEY_DIAGNOSTIC_POP
1048 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1051 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1054 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1055 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1057 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1058 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1059 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1060 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1061 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1062 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1063 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1064 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1065 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1066 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1067 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1068 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1069 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1070 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1071 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1072 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1074 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1075 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1076 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1077 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1078 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1079 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1080 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1081 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1082 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1083 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1084 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1085 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1086 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1087 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1088 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1089 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1090 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1091 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1092 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1093 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1095 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1098 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1099 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1101 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1102 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1103 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1104 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1105 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1106 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1107 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1108 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1109 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1110 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1111 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1112 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1114 JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1115 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1116 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1117 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1118 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1119 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1120 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1121 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1122 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1123 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1124 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1126 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1129 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1130 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1132 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1133 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1134 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1135 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1136 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1137 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1138 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1139 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1140 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1141 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1142 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1143 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1144 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1145 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1146 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1147 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1149 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1150 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1151 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1152 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1153 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1154 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1155 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1156 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1158 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1161 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1162 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1164 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1165 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1166 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1167 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1168 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1169 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1171 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1174 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1175 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1177 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1178 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1179 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1180 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1181 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1182 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1183 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1184 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1186 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1189 #if defined(JSON_HEDLEY_DEPRECATED)
1190 #undef JSON_HEDLEY_DEPRECATED
1192 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1193 #undef JSON_HEDLEY_DEPRECATED_FOR
1196 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1197 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1198 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1199 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1201 (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1202 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1203 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1204 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1205 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1206 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1207 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1208 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1209 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1210 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1211 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1212 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1213 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1214 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1215 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1216 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1217 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1219 JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1220 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1221 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1222 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1223 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1224 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1225 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1226 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1227 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1228 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1229 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1230 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1231 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1232 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1233 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1234 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1235 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1236 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1238 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1239 JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1240 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1241 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1242 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1243 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1244 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1245 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1247 #define JSON_HEDLEY_DEPRECATED(since)
1248 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1251 #if defined(JSON_HEDLEY_UNAVAILABLE)
1252 #undef JSON_HEDLEY_UNAVAILABLE
1255 JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1256 JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1257 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1258 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1259 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1261 #define JSON_HEDLEY_UNAVAILABLE(available_since)
1271 JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1272 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1273 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1274 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1275 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1276 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1277 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1278 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1279 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1280 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1281 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1282 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1283 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1284 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1285 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1286 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1287 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1288 #define __attribute__((__warn_unused_result__))
1289 #define _MSG(msg) __attribute__((__warn_unused_result__))
1290 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1291 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1292 #define _MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1293 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1294 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1295 #define _MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1296 #elif defined(_Check_return_)
1297 #define _Check_return_
1298 #define _MSG(msg) _Check_return_
1304 #if defined(JSON_HEDLEY_SENTINEL)
1305 #undef JSON_HEDLEY_SENTINEL
1308 JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1309 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1310 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1311 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1312 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1313 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1315 #define JSON_HEDLEY_SENTINEL(position)
1318 #if defined(JSON_HEDLEY_NO_RETURN)
1319 #undef JSON_HEDLEY_NO_RETURN
1321 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1322 #define JSON_HEDLEY_NO_RETURN __noreturn
1324 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1325 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1326 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1327 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1328 #define JSON_HEDLEY_NO_RETURN _Noreturn
1329 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1330 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1332 JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1333 JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1334 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1335 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1336 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1337 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1338 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1339 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1340 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1341 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1342 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1343 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1344 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1345 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1346 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1347 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1348 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1349 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1350 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1351 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1353 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1354 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1355 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1356 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1357 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1358 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1359 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1360 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1361 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1363 #define JSON_HEDLEY_NO_RETURN
1366 #if defined(JSON_HEDLEY_NO_ESCAPE)
1367 #undef JSON_HEDLEY_NO_ESCAPE
1369 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1370 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1372 #define JSON_HEDLEY_NO_ESCAPE
1375 #if defined(JSON_HEDLEY_UNREACHABLE)
1376 #undef JSON_HEDLEY_UNREACHABLE
1378 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1379 #undef JSON_HEDLEY_UNREACHABLE_RETURN
1381 #if defined(JSON_HEDLEY_ASSUME)
1382 #undef JSON_HEDLEY_ASSUME
1385 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1386 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1387 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1388 #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1389 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1390 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1392 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1393 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1394 #if defined(__cplusplus)
1395 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1397 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1401 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1402 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1403 JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1404 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1405 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1406 JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1407 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1408 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1409 #elif defined(JSON_HEDLEY_ASSUME)
1410 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1412 #if !defined(JSON_HEDLEY_ASSUME)
1413 #if defined(JSON_HEDLEY_UNREACHABLE)
1414 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1416 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1419 #if defined(JSON_HEDLEY_UNREACHABLE)
1421 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1422 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1423 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1425 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1428 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1430 #if !defined(JSON_HEDLEY_UNREACHABLE)
1431 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1434 JSON_HEDLEY_DIAGNOSTIC_PUSH
1435 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1436 #pragma clang diagnostic ignored "-Wpedantic"
1438 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1439 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1441 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1442 #if defined(__clang__)
1443 #pragma clang diagnostic ignored "-Wvariadic-macros"
1444 #elif defined(JSON_HEDLEY_GCC_VERSION)
1445 #pragma GCC diagnostic ignored "-Wvariadic-macros"
1448 #if defined(JSON_HEDLEY_NON_NULL)
1449 #undef JSON_HEDLEY_NON_NULL
1452 JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1453 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1454 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1455 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1456 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1458 #define JSON_HEDLEY_NON_NULL(...)
1460 JSON_HEDLEY_DIAGNOSTIC_POP
1462 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1463 #undef JSON_HEDLEY_PRINTF_FORMAT
1465 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1466 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1467 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1468 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1470 JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1471 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1472 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1473 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1474 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1475 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1476 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1477 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1478 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1479 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1480 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1481 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1482 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1483 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1484 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1485 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1486 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1487 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1488 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1489 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1491 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1494 #if defined(JSON_HEDLEY_CONSTEXPR)
1495 #undef JSON_HEDLEY_CONSTEXPR
1497 #if defined(__cplusplus)
1498 #if __cplusplus >= 201103L
1499 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1502 #if !defined(JSON_HEDLEY_CONSTEXPR)
1503 #define JSON_HEDLEY_CONSTEXPR
1506 #if defined(JSON_HEDLEY_PREDICT)
1507 #undef JSON_HEDLEY_PREDICT
1509 #if defined(JSON_HEDLEY_LIKELY)
1510 #undef JSON_HEDLEY_LIKELY
1512 #if defined(JSON_HEDLEY_UNLIKELY)
1513 #undef JSON_HEDLEY_UNLIKELY
1515 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1516 #undef JSON_HEDLEY_UNPREDICTABLE
1518 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1519 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1522 (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1523 JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1524 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1525 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))
1526 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))
1527 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))
1528 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )
1529 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )
1531 (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1532 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1533 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1534 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1535 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1536 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1537 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1538 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1539 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1540 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1541 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1542 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1543 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1544 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1545 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1546 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1547 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1548 (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1549 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1551 double hedley_probability_ = (probability); \
1552 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1554 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1556 double hedley_probability_ = (probability); \
1557 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1559 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1560 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1562 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1563 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1564 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1565 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1566 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1568 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1569 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1572 #if defined(JSON_HEDLEY_MALLOC)
1573 #undef JSON_HEDLEY_MALLOC
1576 JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1577 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1578 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1579 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1580 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1581 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1582 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1583 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1584 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1585 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1586 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1587 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1588 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1589 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1590 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1591 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1592 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1593 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1594 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1595 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1596 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1598 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1599 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1600 #define JSON_HEDLEY_MALLOC __declspec(restrict)
1602 #define JSON_HEDLEY_MALLOC
1605 #if defined(JSON_HEDLEY_PURE)
1606 #undef JSON_HEDLEY_PURE
1609 JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1610 JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1611 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1612 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1613 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1614 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1615 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1616 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1617 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1618 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1619 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1620 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1621 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1622 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1623 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1624 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1625 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1626 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1627 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1628 # define JSON_HEDLEY_PURE __attribute__((__pure__))
1629 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1630 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1631 #elif defined(__cplusplus) && \
1633 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1634 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1635 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1637 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1639 # define JSON_HEDLEY_PURE
1642 #if defined(JSON_HEDLEY_CONST)
1643 #undef JSON_HEDLEY_CONST
1646 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1647 JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1648 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1649 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1650 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1651 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1652 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1653 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1654 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1655 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1656 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1657 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1658 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1659 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1660 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1661 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1662 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1663 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1664 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1665 #define JSON_HEDLEY_CONST __attribute__((__const__))
1667 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1668 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1670 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1673 #if defined(JSON_HEDLEY_RESTRICT)
1674 #undef JSON_HEDLEY_RESTRICT
1676 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1677 #define JSON_HEDLEY_RESTRICT restrict
1679 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1680 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1681 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1682 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1683 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1684 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1685 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1686 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1687 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1688 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1689 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1690 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1691 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1692 defined(__clang__) || \
1693 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1694 #define JSON_HEDLEY_RESTRICT __restrict
1695 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1696 #define JSON_HEDLEY_RESTRICT _Restrict
1698 #define JSON_HEDLEY_RESTRICT
1701 #if defined(JSON_HEDLEY_INLINE)
1702 #undef JSON_HEDLEY_INLINE
1705 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1706 (defined(__cplusplus) && (__cplusplus >= 199711L))
1707 #define JSON_HEDLEY_INLINE inline
1709 defined(JSON_HEDLEY_GCC_VERSION) || \
1710 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1711 #define JSON_HEDLEY_INLINE __inline__
1713 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1714 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1715 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1716 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1717 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1718 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1719 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1720 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1721 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1722 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1723 #define JSON_HEDLEY_INLINE __inline
1725 #define JSON_HEDLEY_INLINE
1728 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1729 #undef JSON_HEDLEY_ALWAYS_INLINE
1732 JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1733 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1734 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1735 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1736 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1737 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1738 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1739 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1740 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1741 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1742 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1743 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1744 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1745 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1746 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1747 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1748 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1749 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1750 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1751 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1753 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1754 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1755 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1756 #elif defined(__cplusplus) && \
1758 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1759 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1760 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1761 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1762 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1763 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1765 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1766 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1767 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1769 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1772 #if defined(JSON_HEDLEY_NEVER_INLINE)
1773 #undef JSON_HEDLEY_NEVER_INLINE
1776 JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1777 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1778 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1779 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1780 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1781 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1782 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1783 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1784 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1785 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1786 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1787 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1788 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1789 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1790 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1791 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1792 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1793 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1794 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1795 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1797 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1798 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1799 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1800 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1801 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1802 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1803 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1804 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1805 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1806 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1807 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1808 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1809 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1811 #define JSON_HEDLEY_NEVER_INLINE
1814 #if defined(JSON_HEDLEY_PRIVATE)
1815 #undef JSON_HEDLEY_PRIVATE
1817 #if defined(JSON_HEDLEY_PUBLIC)
1818 #undef JSON_HEDLEY_PUBLIC
1820 #if defined(JSON_HEDLEY_IMPORT)
1821 #undef JSON_HEDLEY_IMPORT
1823 #if defined(_WIN32) || defined(__CYGWIN__)
1824 # define JSON_HEDLEY_PRIVATE
1825 # define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1826 # define JSON_HEDLEY_IMPORT __declspec(dllimport)
1829 JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1830 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1831 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1832 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1833 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1834 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1836 defined(__TI_EABI__) && \
1838 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1839 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1842 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1843 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1844 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1846 # define JSON_HEDLEY_PRIVATE
1847 # define JSON_HEDLEY_PUBLIC
1849 # define JSON_HEDLEY_IMPORT extern
1852 #if defined(JSON_HEDLEY_NO_THROW)
1853 #undef JSON_HEDLEY_NO_THROW
1856 JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1857 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1858 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1859 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1860 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1862 JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1863 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1864 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1865 #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1867 #define JSON_HEDLEY_NO_THROW
1870 #if defined(JSON_HEDLEY_FALL_THROUGH)
1871 #undef JSON_HEDLEY_FALL_THROUGH
1874 JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1875 JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
1876 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1877 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1878 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1879 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1880 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1881 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1882 #elif defined(__fallthrough)
1883 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1885 #define JSON_HEDLEY_FALL_THROUGH
1892 JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1893 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1894 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1895 #define __attribute__((__returns_nonnull__))
1896 #elif defined(_Ret_notnull_)
1897 #define _Ret_notnull_
1902 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1903 #undef JSON_HEDLEY_ARRAY_PARAM
1906 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1907 !defined(__STDC_NO_VLA__) && \
1908 !defined(__cplusplus) && \
1909 !defined(JSON_HEDLEY_PGI_VERSION) && \
1910 !defined(JSON_HEDLEY_TINYC_VERSION)
1911 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1913 #define JSON_HEDLEY_ARRAY_PARAM(name)
1916 #if defined(JSON_HEDLEY_IS_CONSTANT)
1917 #undef JSON_HEDLEY_IS_CONSTANT
1919 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1920 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1924 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1925 #undef JSON_HEDLEY_IS_CONSTEXPR_
1928 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1929 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1930 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1931 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1932 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1933 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1934 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1935 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1936 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1937 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1938 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1940 #if !defined(__cplusplus)
1942 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1943 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1944 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1945 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1946 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1947 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1948 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1949 #if defined(__INTPTR_TYPE__)
1950 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1953 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1957 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1958 !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1959 !defined(JSON_HEDLEY_PGI_VERSION) && \
1960 !defined(JSON_HEDLEY_IAR_VERSION)) || \
1961 (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1962 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1963 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1964 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1965 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1966 #if defined(__INTPTR_TYPE__)
1967 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1970 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1973 defined(JSON_HEDLEY_GCC_VERSION) || \
1974 defined(JSON_HEDLEY_INTEL_VERSION) || \
1975 defined(JSON_HEDLEY_TINYC_VERSION) || \
1976 defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1977 JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1978 defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1979 defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1980 defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1981 defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1983 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1987 ((void*) ((expr) * 0L) ) : \
1988 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1994 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1995 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1996 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1998 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2000 #if !defined(JSON_HEDLEY_IS_CONSTANT)
2001 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2003 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2006 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2007 #undef JSON_HEDLEY_BEGIN_C_DECLS
2009 #if defined(JSON_HEDLEY_END_C_DECLS)
2010 #undef JSON_HEDLEY_END_C_DECLS
2012 #if defined(JSON_HEDLEY_C_DECL)
2013 #undef JSON_HEDLEY_C_DECL
2015 #if defined(__cplusplus)
2016 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2017 #define JSON_HEDLEY_END_C_DECLS }
2018 #define JSON_HEDLEY_C_DECL extern "C"
2020 #define JSON_HEDLEY_BEGIN_C_DECLS
2021 #define JSON_HEDLEY_END_C_DECLS
2022 #define JSON_HEDLEY_C_DECL
2025 #if defined(JSON_HEDLEY_STATIC_ASSERT)
2026 #undef JSON_HEDLEY_STATIC_ASSERT
2029 !defined(__cplusplus) && ( \
2030 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2031 (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2032 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2033 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2034 defined(_Static_assert) \
2036 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2038 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2039 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2040 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2041 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2043 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2046 #if defined(JSON_HEDLEY_NULL)
2047 #undef JSON_HEDLEY_NULL
2049 #if defined(__cplusplus)
2050 #if __cplusplus >= 201103L
2051 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2053 #define JSON_HEDLEY_NULL NULL
2055 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2058 #define JSON_HEDLEY_NULL NULL
2060 #define JSON_HEDLEY_NULL ((void*) 0)
2063 #if defined(JSON_HEDLEY_MESSAGE)
2064 #undef JSON_HEDLEY_MESSAGE
2066 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2067 # define JSON_HEDLEY_MESSAGE(msg) \
2068 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2069 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2070 JSON_HEDLEY_PRAGMA(message msg) \
2071 JSON_HEDLEY_DIAGNOSTIC_POP
2073 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2074 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2075 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2076 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2077 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2078 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2079 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2080 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2081 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2083 # define JSON_HEDLEY_MESSAGE(msg)
2086 #if defined(JSON_HEDLEY_WARNING)
2087 #undef JSON_HEDLEY_WARNING
2089 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2090 # define JSON_HEDLEY_WARNING(msg) \
2091 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2092 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2093 JSON_HEDLEY_PRAGMA(clang warning msg) \
2094 JSON_HEDLEY_DIAGNOSTIC_POP
2096 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2097 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2098 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2099 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2101 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2102 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2103 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2105 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2108 #if defined(JSON_HEDLEY_REQUIRE)
2109 #undef JSON_HEDLEY_REQUIRE
2111 #if defined(JSON_HEDLEY_REQUIRE_MSG)
2112 #undef JSON_HEDLEY_REQUIRE_MSG
2114 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2115 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2116 # define JSON_HEDLEY_REQUIRE(expr) \
2117 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2118 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2119 __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2120 JSON_HEDLEY_DIAGNOSTIC_POP
2121 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2122 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2123 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2124 __attribute__((diagnose_if(!(expr), msg, "error"))) \
2125 JSON_HEDLEY_DIAGNOSTIC_POP
2127 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2128 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2131 # define JSON_HEDLEY_REQUIRE(expr)
2132 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2135 #if defined(JSON_HEDLEY_FLAGS)
2136 #undef JSON_HEDLEY_FLAGS
2138 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2139 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2141 #define JSON_HEDLEY_FLAGS
2144 #if defined(JSON_HEDLEY_FLAGS_CAST)
2145 #undef JSON_HEDLEY_FLAGS_CAST
2147 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2148 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2149 JSON_HEDLEY_DIAGNOSTIC_PUSH \
2150 _Pragma("warning(disable:188)") \
2152 JSON_HEDLEY_DIAGNOSTIC_POP \
2155 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2158 #if defined(JSON_HEDLEY_EMPTY_BASES)
2159 #undef JSON_HEDLEY_EMPTY_BASES
2162 (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2163 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2164 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2166 #define JSON_HEDLEY_EMPTY_BASES
2171 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2172 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2174 #if defined(__clang__)
2175 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2177 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2180 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2181 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2183 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2185 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2186 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2188 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2190 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2191 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2193 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2195 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2196 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2198 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2200 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2201 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2203 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2205 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2206 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2208 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2210 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2211 #undef JSON_HEDLEY_CLANG_HAS_WARNING
2213 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2222 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2223 #if defined(__clang__)
2224 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2225 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2227 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2228 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2229 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2236 #if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2237 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2238 #define JSON_HAS_CPP_20
2239 #define JSON_HAS_CPP_17
2240 #define JSON_HAS_CPP_14
2241 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1)
2242 #define JSON_HAS_CPP_17
2243 #define JSON_HAS_CPP_14
2244 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2245 #define JSON_HAS_CPP_14
2248 #define JSON_HAS_CPP_11
2252 #if defined(__clang__)
2253 #pragma GCC diagnostic push
2254 #pragma GCC diagnostic ignored "-Wdocumentation"
2258 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2259 #define JSON_THROW(exception) throw exception
2260 #define JSON_TRY try
2261 #define JSON_CATCH(exception) catch(exception)
2262 #define JSON_INTERNAL_CATCH(exception) catch(exception)
2265 #define JSON_THROW(exception) std::abort()
2266 #define JSON_TRY if(true)
2267 #define JSON_CATCH(exception) if(false)
2268 #define JSON_INTERNAL_CATCH(exception) if(false)
2272 #if defined(JSON_THROW_USER)
2274 #define JSON_THROW JSON_THROW_USER
2276 #if defined(JSON_TRY_USER)
2278 #define JSON_TRY JSON_TRY_USER
2280 #if defined(JSON_CATCH_USER)
2282 #define JSON_CATCH JSON_CATCH_USER
2283 #undef JSON_INTERNAL_CATCH
2284 #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2286 #if defined(JSON_INTERNAL_CATCH_USER)
2287 #undef JSON_INTERNAL_CATCH
2288 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2292 #if !defined(JSON_ASSERT)
2294 #define JSON_ASSERT(x) assert(x)
2298 #if defined(JSON_TESTS_PRIVATE)
2299 #define JSON_PRIVATE_UNLESS_TESTED public
2301 #define JSON_PRIVATE_UNLESS_TESTED private
2309 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2310 template<typename BasicJsonType> \
2311 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2313 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2314 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2315 auto it = std::find_if(std::begin(m), std::end(m), \
2316 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2318 return ej_pair.first == e; \
2320 j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2322 template<typename BasicJsonType> \
2323 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2325 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2326 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2327 auto it = std::find_if(std::begin(m), std::end(m), \
2328 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2330 return ej_pair.second == j; \
2332 e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2338 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2339 template<template<typename, typename, typename...> class ObjectType, \
2340 template<typename, typename...> class ArrayType, \
2341 class StringType, class BooleanType, class NumberIntegerType, \
2342 class NumberUnsignedType, class NumberFloatType, \
2343 template<typename> class AllocatorType, \
2344 template<typename, typename = void> class JSONSerializer, \
2347 #define NLOHMANN_BASIC_JSON_TPL \
2348 basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2349 NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2350 AllocatorType, JSONSerializer, BinaryType>
2354 #define NLOHMANN_JSON_EXPAND( x ) x
2355 #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
2356 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2357 NLOHMANN_JSON_PASTE64, \
2358 NLOHMANN_JSON_PASTE63, \
2359 NLOHMANN_JSON_PASTE62, \
2360 NLOHMANN_JSON_PASTE61, \
2361 NLOHMANN_JSON_PASTE60, \
2362 NLOHMANN_JSON_PASTE59, \
2363 NLOHMANN_JSON_PASTE58, \
2364 NLOHMANN_JSON_PASTE57, \
2365 NLOHMANN_JSON_PASTE56, \
2366 NLOHMANN_JSON_PASTE55, \
2367 NLOHMANN_JSON_PASTE54, \
2368 NLOHMANN_JSON_PASTE53, \
2369 NLOHMANN_JSON_PASTE52, \
2370 NLOHMANN_JSON_PASTE51, \
2371 NLOHMANN_JSON_PASTE50, \
2372 NLOHMANN_JSON_PASTE49, \
2373 NLOHMANN_JSON_PASTE48, \
2374 NLOHMANN_JSON_PASTE47, \
2375 NLOHMANN_JSON_PASTE46, \
2376 NLOHMANN_JSON_PASTE45, \
2377 NLOHMANN_JSON_PASTE44, \
2378 NLOHMANN_JSON_PASTE43, \
2379 NLOHMANN_JSON_PASTE42, \
2380 NLOHMANN_JSON_PASTE41, \
2381 NLOHMANN_JSON_PASTE40, \
2382 NLOHMANN_JSON_PASTE39, \
2383 NLOHMANN_JSON_PASTE38, \
2384 NLOHMANN_JSON_PASTE37, \
2385 NLOHMANN_JSON_PASTE36, \
2386 NLOHMANN_JSON_PASTE35, \
2387 NLOHMANN_JSON_PASTE34, \
2388 NLOHMANN_JSON_PASTE33, \
2389 NLOHMANN_JSON_PASTE32, \
2390 NLOHMANN_JSON_PASTE31, \
2391 NLOHMANN_JSON_PASTE30, \
2392 NLOHMANN_JSON_PASTE29, \
2393 NLOHMANN_JSON_PASTE28, \
2394 NLOHMANN_JSON_PASTE27, \
2395 NLOHMANN_JSON_PASTE26, \
2396 NLOHMANN_JSON_PASTE25, \
2397 NLOHMANN_JSON_PASTE24, \
2398 NLOHMANN_JSON_PASTE23, \
2399 NLOHMANN_JSON_PASTE22, \
2400 NLOHMANN_JSON_PASTE21, \
2401 NLOHMANN_JSON_PASTE20, \
2402 NLOHMANN_JSON_PASTE19, \
2403 NLOHMANN_JSON_PASTE18, \
2404 NLOHMANN_JSON_PASTE17, \
2405 NLOHMANN_JSON_PASTE16, \
2406 NLOHMANN_JSON_PASTE15, \
2407 NLOHMANN_JSON_PASTE14, \
2408 NLOHMANN_JSON_PASTE13, \
2409 NLOHMANN_JSON_PASTE12, \
2410 NLOHMANN_JSON_PASTE11, \
2411 NLOHMANN_JSON_PASTE10, \
2412 NLOHMANN_JSON_PASTE9, \
2413 NLOHMANN_JSON_PASTE8, \
2414 NLOHMANN_JSON_PASTE7, \
2415 NLOHMANN_JSON_PASTE6, \
2416 NLOHMANN_JSON_PASTE5, \
2417 NLOHMANN_JSON_PASTE4, \
2418 NLOHMANN_JSON_PASTE3, \
2419 NLOHMANN_JSON_PASTE2, \
2420 NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2421 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2422 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2423 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2424 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2425 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2426 #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)
2427 #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)
2428 #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)
2429 #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)
2430 #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)
2431 #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)
2432 #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)
2433 #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)
2434 #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)
2435 #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)
2436 #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)
2437 #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)
2438 #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)
2439 #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)
2440 #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)
2441 #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)
2442 #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)
2443 #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)
2444 #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)
2445 #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)
2446 #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)
2447 #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)
2448 #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)
2449 #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)
2450 #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)
2451 #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)
2452 #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)
2453 #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)
2454 #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)
2455 #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)
2456 #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)
2457 #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)
2458 #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)
2459 #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)
2460 #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)
2461 #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)
2462 #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)
2463 #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)
2464 #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)
2465 #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)
2466 #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)
2467 #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)
2468 #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)
2469 #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)
2470 #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)
2471 #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)
2472 #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)
2473 #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)
2474 #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)
2475 #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)
2476 #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)
2477 #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)
2478 #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)
2479 #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)
2480 #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)
2481 #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)
2482 #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)
2483 #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)
2485 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2486 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2493 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2494 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__)) } \
2495 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__)) }
2502 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2503 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__)) } \
2504 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__)) }
2506 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2507 #define JSON_USE_IMPLICIT_CONVERSIONS 1
2510 #if JSON_USE_IMPLICIT_CONVERSIONS
2511 #define JSON_EXPLICIT
2513 #define JSON_EXPLICIT explicit
2535 inline void replace_substring(std::string& s,
const std::string& f,
2536 const std::string& t)
2538 JSON_ASSERT(!f.empty());
2539 for (
auto pos = s.find(f);
2540 pos != std::string::npos;
2541 s.replace(pos, f.size(), t),
2542 pos = s.find(f, pos + t.size()))
2553 inline std::string escape(std::string s)
2555 replace_substring(s,
"~",
"~0");
2556 replace_substring(s,
"/",
"~1");
2567 static void unescape(std::string& s)
2569 replace_substring(s,
"~1",
"/");
2570 replace_substring(s,
"~0",
"~");
2589 std::size_t chars_read_total = 0;
2591 std::size_t chars_read_current_line = 0;
2593 std::size_t lines_read = 0;
2596 constexpr
operator size_t()
const
2598 return chars_read_total;
2644 class exception :
public std::exception
2648 const char* what() const noexcept
override
2657 JSON_HEDLEY_NON_NULL(3)
2658 exception(
int id_, const
char* what_arg) :
id(id_), m(what_arg) {}
2660 static std::string name(
const std::string& ename,
int id_)
2662 return "[json.exception." + ename +
"." + std::to_string(id_) +
"] ";
2665 template<
typename BasicJsonType>
2666 static std::string diagnostics(
const BasicJsonType& leaf_element)
2668 #if JSON_DIAGNOSTICS
2669 std::vector<std::string> tokens;
2670 for (
const auto* current = &leaf_element; current->m_parent !=
nullptr; current = current->m_parent)
2672 switch (current->m_parent->type())
2674 case value_t::array:
2676 for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
2678 if (¤t->m_parent->m_value.array->operator[](i) == current)
2680 tokens.emplace_back(std::to_string(i));
2687 case value_t::object:
2689 for (
const auto& element : *current->m_parent->m_value.object)
2691 if (&element.second == current)
2693 tokens.emplace_back(element.first.c_str());
2710 return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
2711 [](
const std::string & a,
const std::string & b)
2713 return a +
"/" + detail::escape(b);
2716 static_cast<void>(leaf_element);
2723 std::runtime_error m;
2771 class parse_error :
public exception
2783 template<
typename BasicJsonType>
2784 static parse_error create(
int id_,
const position_t& pos,
const std::string& what_arg,
const BasicJsonType& context)
2786 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2787 position_string(pos) +
": " + exception::diagnostics(context) + what_arg;
2788 return parse_error(id_, pos.chars_read_total, w.c_str());
2791 template<
typename BasicJsonType>
2792 static parse_error create(
int id_, std::size_t byte_,
const std::string& what_arg,
const BasicJsonType& context)
2794 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2795 (byte_ != 0 ? (
" at byte " + std::to_string(byte_)) :
"") +
2796 ": " + exception::diagnostics(context) + what_arg;
2797 return parse_error(id_, byte_, w.c_str());
2809 const std::size_t byte;
2812 parse_error(
int id_, std::size_t byte_,
const char* what_arg)
2813 : exception(id_, what_arg), byte(byte_) {}
2815 static std::string position_string(
const position_t& pos)
2817 return " at line " + std::to_string(pos.lines_read + 1) +
2818 ", column " + std::to_string(pos.chars_read_current_line);
2859 class invalid_iterator :
public exception
2862 template<
typename BasicJsonType>
2863 static invalid_iterator create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2865 std::string w = exception::name(
"invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
2866 return invalid_iterator(id_, w.c_str());
2870 JSON_HEDLEY_NON_NULL(3)
2871 invalid_iterator(
int id_, const
char* what_arg)
2872 : exception(id_, what_arg) {}
2914 class type_error :
public exception
2917 template<
typename BasicJsonType>
2918 static type_error create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2920 std::string w = exception::name(
"type_error", id_) + exception::diagnostics(context) + what_arg;
2921 return type_error(id_, w.c_str());
2925 JSON_HEDLEY_NON_NULL(3)
2926 type_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
2962 class out_of_range :
public exception
2965 template<
typename BasicJsonType>
2966 static out_of_range create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
2968 std::string w = exception::name(
"out_of_range", id_) + exception::diagnostics(context) + what_arg;
2969 return out_of_range(id_, w.c_str());
2973 JSON_HEDLEY_NON_NULL(3)
2974 out_of_range(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3001 class other_error :
public exception
3004 template<
typename BasicJsonType>
3005 static other_error create(
int id_,
const std::string& what_arg,
const BasicJsonType& context)
3007 std::string w = exception::name(
"other_error", id_) + exception::diagnostics(context) + what_arg;
3008 return other_error(id_, w.c_str());
3012 JSON_HEDLEY_NON_NULL(3)
3013 other_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
3024 #include <type_traits>
3035 template<
typename T>
3036 using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3038 #ifdef JSON_HAS_CPP_14
3041 using std::enable_if_t;
3042 using std::index_sequence;
3043 using std::make_index_sequence;
3044 using std::index_sequence_for;
3049 template<
bool B,
typename T =
void>
3050 using enable_if_t =
typename std::enable_if<B, T>::type;
3076 template <
typename T, T... Ints>
3077 struct integer_sequence
3079 using value_type = T;
3080 static constexpr std::size_t size() noexcept
3082 return sizeof...(Ints);
3091 template <
size_t... Ints>
3092 using index_sequence = integer_sequence<size_t, Ints...>;
3094 namespace utility_internal
3097 template <
typename Seq,
size_t SeqSize,
size_t Rem>
3101 template <
typename T, T... Ints,
size_t SeqSize>
3102 struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3104 using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3107 template <
typename T, T... Ints,
size_t SeqSize>
3108 struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3110 using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3115 template <
typename T,
size_t N>
3119 typename Extend <
typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3122 template <
typename T>
3125 using type = integer_sequence<T>;
3137 template <
typename T, T N>
3138 using make_integer_sequence =
typename utility_internal::Gen<T, N>::type;
3146 using make_index_sequence = make_integer_sequence<size_t, N>;
3153 template <
typename... Ts>
3154 using index_sequence_for = make_index_sequence<
sizeof...(Ts)>;
3161 template<
unsigned N>
struct priority_tag : priority_tag < N - 1 > {};
3162 template<>
struct priority_tag<0> {};
3165 template<
typename T>
3168 static constexpr T value{};
3171 template<
typename T>
3172 constexpr T static_const<T>::value;
3185 template <
class T>
struct identity_tag {};
3193 #include <type_traits>
3209 template<
typename ...Ts>
struct make_void
3213 template<
typename ...Ts>
using void_t =
typename make_void<Ts...>::type;
3224 template<
typename It,
typename =
void>
3225 struct iterator_types {};
3227 template<
typename It>
3228 struct iterator_types <
3230 void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3231 typename It::reference, typename It::iterator_category >>
3233 using difference_type =
typename It::difference_type;
3234 using value_type =
typename It::value_type;
3235 using pointer =
typename It::pointer;
3236 using reference =
typename It::reference;
3237 using iterator_category =
typename It::iterator_category;
3242 template<
typename T,
typename =
void>
3243 struct iterator_traits
3247 template<
typename T>
3248 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3253 template<
typename T>
3254 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3256 using iterator_category = std::random_access_iterator_tag;
3257 using value_type = T;
3258 using difference_type = ptrdiff_t;
3260 using reference = T&;
3272 #include <type_traits>
3284 nonesuch() =
delete;
3285 ~nonesuch() =
delete;
3286 nonesuch(nonesuch
const&) =
delete;
3287 nonesuch(nonesuch
const&&) =
delete;
3288 void operator=(nonesuch
const&) =
delete;
3289 void operator=(nonesuch&&) =
delete;
3292 template<
class Default,
3294 template<
class...>
class Op,
3298 using value_t = std::false_type;
3299 using type = Default;
3302 template<
class Default,
template<
class...>
class Op,
class... Args>
3303 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
3305 using value_t = std::true_type;
3306 using type = Op<Args...>;
3309 template<
template<
class...>
class Op,
class... Args>
3310 using is_detected =
typename detector<nonesuch, void, Op, Args...>::value_t;
3312 template<
template<
class...>
class Op,
class... Args>
3313 using detected_t =
typename detector<nonesuch, void, Op, Args...>::type;
3315 template<
class Default,
template<
class...>
class Op,
class... Args>
3316 using detected_or = detector<Default, void, Op, Args...>;
3318 template<
class Default,
template<
class...>
class Op,
class... Args>
3319 using detected_or_t =
typename detected_or<Default, Op, Args...>::type;
3321 template<
class Expected,
template<
class...>
class Op,
class... Args>
3322 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
3324 template<
class To,
template<
class...>
class Op,
class... Args>
3325 using is_detected_convertible =
3326 std::is_convertible<detected_t<Op, Args...>, To>;
3331 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3332 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3354 template<
typename T =
void,
typename SFINAE =
void>
3355 struct adl_serializer;
3357 template<
template<
typename U,
typename V,
typename... Args>
class ObjectType =
3359 template<
typename U,
typename... Args>
class ArrayType = std::vector,
3360 class StringType = std::string,
class BooleanType = bool,
3361 class NumberIntegerType = std::int64_t,
3362 class NumberUnsignedType = std::uint64_t,
3363 class NumberFloatType = double,
3364 template<
typename U>
class AllocatorType = std::allocator,
3365 template<
typename T,
typename SFINAE =
void>
class JSONSerializer =
3367 class BinaryType = std::vector<std::uint8_t>>
3381 template<
typename BasicJsonType>
3394 template<
class Key,
class T,
class IgnoredLess,
class Allocator>
3436 template<
typename>
struct is_basic_json : std::false_type {};
3438 NLOHMANN_BASIC_JSON_TPL_DECLARATION
3439 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3449 struct is_json_ref : std::false_type {};
3451 template<
typename T>
3452 struct is_json_ref<json_ref<T>> : std::true_type {};
3458 template<
typename T>
3459 using mapped_type_t =
typename T::mapped_type;
3461 template<
typename T>
3462 using key_type_t =
typename T::key_type;
3464 template<
typename T>
3465 using value_type_t =
typename T::value_type;
3467 template<
typename T>
3468 using difference_type_t =
typename T::difference_type;
3470 template<
typename T>
3471 using pointer_t =
typename T::pointer;
3473 template<
typename T>
3474 using reference_t =
typename T::reference;
3476 template<
typename T>
3477 using iterator_category_t =
typename T::iterator_category;
3479 template<
typename T>
3480 using iterator_t =
typename T::iterator;
3482 template<
typename T,
typename... Args>
3483 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3485 template<
typename T,
typename... Args>
3486 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3488 template<
typename T,
typename U>
3489 using get_template_function = decltype(std::declval<T>().
template get<U>());
3492 template<
typename BasicJsonType,
typename T,
typename =
void>
3493 struct has_from_json : std::false_type {};
3499 template <
typename BasicJsonType,
typename T>
3502 static constexpr
bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3505 template<
typename BasicJsonType,
typename T>
3506 struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3508 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3510 static constexpr
bool value =
3511 is_detected_exact<void, from_json_function, serializer,
3512 const BasicJsonType&, T&>::value;
3517 template<
typename BasicJsonType,
typename T,
typename =
void>
3518 struct has_non_default_from_json : std::false_type {};
3520 template<
typename BasicJsonType,
typename T>
3521 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3523 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3525 static constexpr
bool value =
3526 is_detected_exact<T, from_json_function, serializer,
3527 const BasicJsonType&>::value;
3532 template<
typename BasicJsonType,
typename T,
typename =
void>
3533 struct has_to_json : std::false_type {};
3535 template<
typename BasicJsonType,
typename T>
3536 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3538 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3540 static constexpr
bool value =
3541 is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3551 template<
class...>
struct conjunction : std::true_type { };
3552 template<
class B1>
struct conjunction<B1> : B1 { };
3553 template<
class B1,
class... Bn>
3554 struct conjunction<B1, Bn...>
3555 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3560 template <
typename T>
3561 struct is_default_constructible : std::is_default_constructible<T> {};
3563 template <
typename T1,
typename T2>
3564 struct is_default_constructible<std::pair<T1, T2>>
3565 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3567 template <
typename T1,
typename T2>
3568 struct is_default_constructible<const std::pair<T1, T2>>
3569 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3571 template <
typename... Ts>
3572 struct is_default_constructible<std::tuple<Ts...>>
3573 : conjunction<is_default_constructible<Ts>...> {};
3575 template <
typename... Ts>
3576 struct is_default_constructible<const std::tuple<Ts...>>
3577 : conjunction<is_default_constructible<Ts>...> {};
3580 template <
typename T,
typename... Args>
3581 struct is_constructible : std::is_constructible<T, Args...> {};
3583 template <
typename T1,
typename T2>
3584 struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3586 template <
typename T1,
typename T2>
3587 struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3589 template <
typename... Ts>
3590 struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3592 template <
typename... Ts>
3593 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3596 template<
typename T,
typename =
void>
3597 struct is_iterator_traits : std::false_type {};
3599 template<
typename T>
3600 struct is_iterator_traits<iterator_traits<T>>
3603 using traits = iterator_traits<T>;
3606 static constexpr
auto value =
3607 is_detected<value_type_t, traits>::value &&
3608 is_detected<difference_type_t, traits>::value &&
3609 is_detected<pointer_t, traits>::value &&
3610 is_detected<iterator_category_t, traits>::value &&
3611 is_detected<reference_t, traits>::value;
3618 template<
typename T,
typename =
void>
3619 struct is_complete_type : std::false_type {};
3621 template<
typename T>
3622 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3624 template<
typename BasicJsonType,
typename CompatibleObjectType,
3626 struct is_compatible_object_type_impl : std::false_type {};
3628 template<
typename BasicJsonType,
typename CompatibleObjectType>
3629 struct is_compatible_object_type_impl <
3630 BasicJsonType, CompatibleObjectType,
3631 enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3632 is_detected<key_type_t, CompatibleObjectType>::value >>
3634 using object_t =
typename BasicJsonType::object_t;
3637 static constexpr
bool value =
3638 is_constructible<
typename object_t::key_type,
3639 typename CompatibleObjectType::key_type>::value &&
3640 is_constructible<
typename object_t::mapped_type,
3641 typename CompatibleObjectType::mapped_type>::value;
3644 template<
typename BasicJsonType,
typename CompatibleObjectType>
3645 struct is_compatible_object_type
3646 : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3648 template<
typename BasicJsonType,
typename ConstructibleObjectType,
3650 struct is_constructible_object_type_impl : std::false_type {};
3652 template<
typename BasicJsonType,
typename ConstructibleObjectType>
3653 struct is_constructible_object_type_impl <
3654 BasicJsonType, ConstructibleObjectType,
3655 enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3656 is_detected<key_type_t, ConstructibleObjectType>::value >>
3658 using object_t =
typename BasicJsonType::object_t;
3660 static constexpr
bool value =
3661 (is_default_constructible<ConstructibleObjectType>::value &&
3662 (std::is_move_assignable<ConstructibleObjectType>::value ||
3663 std::is_copy_assignable<ConstructibleObjectType>::value) &&
3664 (is_constructible<
typename ConstructibleObjectType::key_type,
3665 typename object_t::key_type>::value &&
3667 typename object_t::mapped_type,
3668 typename ConstructibleObjectType::mapped_type >::value)) ||
3669 (has_from_json<BasicJsonType,
3670 typename ConstructibleObjectType::mapped_type>::value ||
3671 has_non_default_from_json <
3673 typename ConstructibleObjectType::mapped_type >::value);
3676 template<
typename BasicJsonType,
typename ConstructibleObjectType>
3677 struct is_constructible_object_type
3678 : is_constructible_object_type_impl<BasicJsonType,
3679 ConstructibleObjectType> {};
3681 template<
typename BasicJsonType,
typename CompatibleStringType,
3683 struct is_compatible_string_type_impl : std::false_type {};
3685 template<
typename BasicJsonType,
typename CompatibleStringType>
3686 struct is_compatible_string_type_impl <
3687 BasicJsonType, CompatibleStringType,
3688 enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3689 value_type_t, CompatibleStringType>::value >>
3691 static constexpr
auto value =
3692 is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3695 template<
typename BasicJsonType,
typename ConstructibleStringType>
3696 struct is_compatible_string_type
3697 : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3699 template<
typename BasicJsonType,
typename ConstructibleStringType,
3701 struct is_constructible_string_type_impl : std::false_type {};
3703 template<
typename BasicJsonType,
typename ConstructibleStringType>
3704 struct is_constructible_string_type_impl <
3705 BasicJsonType, ConstructibleStringType,
3706 enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3707 value_type_t, ConstructibleStringType>::value >>
3709 static constexpr
auto value =
3710 is_constructible<ConstructibleStringType,
3711 typename BasicJsonType::string_t>::value;
3714 template<
typename BasicJsonType,
typename ConstructibleStringType>
3715 struct is_constructible_string_type
3716 : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3718 template<
typename BasicJsonType,
typename CompatibleArrayType,
typename =
void>
3719 struct is_compatible_array_type_impl : std::false_type {};
3721 template<
typename BasicJsonType,
typename CompatibleArrayType>
3722 struct is_compatible_array_type_impl <
3723 BasicJsonType, CompatibleArrayType,
3724 enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
3725 is_detected<iterator_t, CompatibleArrayType>::value&&
3729 !is_iterator_traits <
3730 iterator_traits<CompatibleArrayType >>::value >>
3732 static constexpr
bool value =
3733 is_constructible<BasicJsonType,
3734 typename CompatibleArrayType::value_type>::value;
3737 template<
typename BasicJsonType,
typename CompatibleArrayType>
3738 struct is_compatible_array_type
3739 : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3741 template<
typename BasicJsonType,
typename ConstructibleArrayType,
typename =
void>
3742 struct is_constructible_array_type_impl : std::false_type {};
3744 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3745 struct is_constructible_array_type_impl <
3746 BasicJsonType, ConstructibleArrayType,
3747 enable_if_t<std::is_same<ConstructibleArrayType,
3748 typename BasicJsonType::value_type>::value >>
3749 : std::true_type {};
3751 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3752 struct is_constructible_array_type_impl <
3753 BasicJsonType, ConstructibleArrayType,
3754 enable_if_t < !std::is_same<ConstructibleArrayType,
3755 typename BasicJsonType::value_type>::value&&
3756 is_default_constructible<ConstructibleArrayType>::value&&
3757 (std::is_move_assignable<ConstructibleArrayType>::value ||
3758 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3759 is_detected<value_type_t, ConstructibleArrayType>::value&&
3760 is_detected<iterator_t, ConstructibleArrayType>::value&&
3762 detected_t<value_type_t, ConstructibleArrayType >>::value >>
3764 static constexpr
bool value =
3770 !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
3772 (std::is_same<
typename ConstructibleArrayType::value_type,
3773 typename BasicJsonType::array_t::value_type>::value ||
3774 has_from_json<BasicJsonType,
3775 typename ConstructibleArrayType::value_type>::value ||
3776 has_non_default_from_json <
3777 BasicJsonType,
typename ConstructibleArrayType::value_type >::value);
3780 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3781 struct is_constructible_array_type
3782 : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3784 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType,
3786 struct is_compatible_integer_type_impl : std::false_type {};
3788 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3789 struct is_compatible_integer_type_impl <
3790 RealIntegerType, CompatibleNumberIntegerType,
3791 enable_if_t < std::is_integral<RealIntegerType>::value&&
3792 std::is_integral<CompatibleNumberIntegerType>::value&&
3793 !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3796 using RealLimits = std::numeric_limits<RealIntegerType>;
3797 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3799 static constexpr
auto value =
3800 is_constructible<RealIntegerType,
3801 CompatibleNumberIntegerType>::value &&
3802 CompatibleLimits::is_integer &&
3803 RealLimits::is_signed == CompatibleLimits::is_signed;
3806 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3807 struct is_compatible_integer_type
3808 : is_compatible_integer_type_impl<RealIntegerType,
3809 CompatibleNumberIntegerType> {};
3811 template<
typename BasicJsonType,
typename CompatibleType,
typename =
void>
3812 struct is_compatible_type_impl: std::false_type {};
3814 template<
typename BasicJsonType,
typename CompatibleType>
3815 struct is_compatible_type_impl <
3816 BasicJsonType, CompatibleType,
3817 enable_if_t<is_complete_type<CompatibleType>::value >>
3819 static constexpr
bool value =
3820 has_to_json<BasicJsonType, CompatibleType>::value;
3823 template<
typename BasicJsonType,
typename CompatibleType>
3824 struct is_compatible_type
3825 : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3827 template<
typename T1,
typename T2>
3828 struct is_constructible_tuple : std::false_type {};
3830 template<
typename T1,
typename... Args>
3831 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3842 template<
typename BasicJsonType>
3843 void from_json(
const BasicJsonType& j,
typename std::nullptr_t& n)
3845 if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3847 JSON_THROW(type_error::create(302,
"type must be null, but is " + std::string(j.type_name()), j));
3853 template <
typename BasicJsonType,
typename ArithmeticType,
3854 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3855 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3857 void get_arithmetic_value(
const BasicJsonType& j, ArithmeticType& val)
3859 switch (
static_cast<value_t
>(j))
3861 case value_t::number_unsigned:
3863 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3866 case value_t::number_integer:
3868 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3871 case value_t::number_float:
3873 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3878 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name()), j));
3882 template<
typename BasicJsonType>
3883 void from_json(
const BasicJsonType& j,
typename BasicJsonType::boolean_t& b)
3885 if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3887 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(j.type_name()), j));
3889 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3892 template<
typename BasicJsonType>
3893 void from_json(
const BasicJsonType& j,
typename BasicJsonType::string_t& s)
3895 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3897 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
3899 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3903 typename BasicJsonType,
typename ConstructibleStringType,
3905 is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3906 !std::is_same<
typename BasicJsonType::string_t,
3907 ConstructibleStringType>::value,
3909 void from_json(
const BasicJsonType& j, ConstructibleStringType& s)
3911 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3913 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name()), j));
3916 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3919 template<
typename BasicJsonType>
3920 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_float_t& val)
3922 get_arithmetic_value(j, val);
3925 template<
typename BasicJsonType>
3926 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_unsigned_t& val)
3928 get_arithmetic_value(j, val);
3931 template<
typename BasicJsonType>
3932 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_integer_t& val)
3934 get_arithmetic_value(j, val);
3937 template<
typename BasicJsonType,
typename EnumType,
3938 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
3939 void from_json(
const BasicJsonType& j, EnumType& e)
3941 typename std::underlying_type<EnumType>::type val;
3942 get_arithmetic_value(j, val);
3943 e =
static_cast<EnumType
>(val);
3947 template<
typename BasicJsonType,
typename T,
typename Allocator,
3948 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
3949 void from_json(
const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3951 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3953 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
3956 std::transform(j.rbegin(), j.rend(),
3957 std::front_inserter(l), [](
const BasicJsonType & i)
3959 return i.template get<T>();
3964 template<
typename BasicJsonType,
typename T,
3965 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
3966 void from_json(
const BasicJsonType& j, std::valarray<T>& l)
3968 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3970 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
3973 std::transform(j.begin(), j.end(), std::begin(l),
3974 [](
const BasicJsonType & elem)
3976 return elem.template get<T>();
3980 template<
typename BasicJsonType,
typename T, std::
size_t N>
3981 auto from_json(
const BasicJsonType& j, T (&arr)[N])
3982 -> decltype(j.template get<T>(),
void())
3984 for (std::size_t i = 0; i < N; ++i)
3986 arr[i] = j.at(i).template get<T>();
3990 template<
typename BasicJsonType>
3991 void from_json_array_impl(
const BasicJsonType& j,
typename BasicJsonType::array_t& arr, priority_tag<3> )
3993 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3996 template<
typename BasicJsonType,
typename T, std::
size_t N>
3997 auto from_json_array_impl(
const BasicJsonType& j, std::array<T, N>& arr,
3999 -> decltype(j.template get<T>(),
void())
4001 for (std::size_t i = 0; i < N; ++i)
4003 arr[i] = j.at(i).template get<T>();
4007 template<
typename BasicJsonType,
typename ConstructibleArrayType,
4009 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4011 auto from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> )
4013 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4014 j.template get<typename ConstructibleArrayType::value_type>(),
4019 ConstructibleArrayType ret;
4020 ret.reserve(j.size());
4021 std::transform(j.begin(), j.end(),
4022 std::inserter(ret, end(ret)), [](
const BasicJsonType & i)
4026 return i.template get<typename ConstructibleArrayType::value_type>();
4028 arr = std::move(ret);
4031 template<
typename BasicJsonType,
typename ConstructibleArrayType,
4033 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4035 void from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr,
4040 ConstructibleArrayType ret;
4042 j.begin(), j.end(), std::inserter(ret, end(ret)),
4043 [](
const BasicJsonType & i)
4047 return i.template get<typename ConstructibleArrayType::value_type>();
4049 arr = std::move(ret);
4052 template <
typename BasicJsonType,
typename ConstructibleArrayType,
4054 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
4055 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
4056 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4057 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4058 !is_basic_json<ConstructibleArrayType>::value,
4060 auto from_json(
const BasicJsonType& j, ConstructibleArrayType& arr)
4061 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
4062 j.template get<typename ConstructibleArrayType::value_type>(),
4065 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4067 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4070 from_json_array_impl(j, arr, priority_tag<3> {});
4073 template <
typename BasicJsonType,
typename T, std::size_t... Idx >
4074 std::array<T,
sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4075 identity_tag<std::array<T,
sizeof...(Idx)>> , index_sequence<Idx...> )
4077 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4080 template <
typename BasicJsonType,
typename T, std::
size_t N >
4081 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4082 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4084 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4086 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4089 return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4092 template<
typename BasicJsonType>
4093 void from_json(
const BasicJsonType& j,
typename BasicJsonType::binary_t& bin)
4095 if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
4097 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(j.type_name()), j));
4100 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4103 template<
typename BasicJsonType,
typename ConstructibleObjectType,
4104 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value,
int> = 0>
4105 void from_json(
const BasicJsonType& j, ConstructibleObjectType& obj)
4107 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
4109 JSON_THROW(type_error::create(302,
"type must be object, but is " + std::string(j.type_name()), j));
4112 ConstructibleObjectType ret;
4113 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4114 using value_type =
typename ConstructibleObjectType::value_type;
4116 inner_object->begin(), inner_object->end(),
4117 std::inserter(ret, ret.begin()),
4118 [](
typename BasicJsonType::object_t::value_type
const & p)
4120 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4122 obj = std::move(ret);
4129 template <
typename BasicJsonType,
typename ArithmeticType,
4131 std::is_arithmetic<ArithmeticType>::value&&
4132 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4133 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4134 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4135 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4137 void from_json(
const BasicJsonType& j, ArithmeticType& val)
4139 switch (
static_cast<value_t
>(j))
4141 case value_t::number_unsigned:
4143 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4146 case value_t::number_integer:
4148 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4151 case value_t::number_float:
4153 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4156 case value_t::boolean:
4158 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4163 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name()), j));
4167 template<
typename BasicJsonType,
typename... Args, std::size_t... Idx>
4168 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> )
4170 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).
template get<Args>()...);
4173 template <
typename BasicJsonType,
class A1,
class A2 >
4174 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> , priority_tag<0> )
4176 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4177 std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4180 template<
typename BasicJsonType,
typename A1,
typename A2>
4181 void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> )
4183 p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
4186 template<
typename BasicJsonType,
typename... Args>
4187 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> , priority_tag<2> )
4189 return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4192 template<
typename BasicJsonType,
typename... Args>
4193 void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> )
4195 t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4198 template<
typename BasicJsonType,
typename TupleRelated>
4199 auto from_json(BasicJsonType&& j, TupleRelated&& t)
4200 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
4202 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4204 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4207 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4210 template <
typename BasicJsonType,
typename Key,
typename Value,
typename Compare,
typename Allocator,
4211 typename = enable_if_t < !std::is_constructible <
4212 typename BasicJsonType::string_t, Key >::value >>
4213 void from_json(
const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4215 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4217 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4220 for (
const auto& p : j)
4222 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4224 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name()), j));
4226 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4230 template <
typename BasicJsonType,
typename Key,
typename Value,
typename Hash,
typename KeyEqual,
typename Allocator,
4231 typename = enable_if_t < !std::is_constructible <
4232 typename BasicJsonType::string_t, Key >::value >>
4233 void from_json(
const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
4235 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4237 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name()), j));
4240 for (
const auto& p : j)
4242 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4244 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name()), j));
4246 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4252 template<
typename BasicJsonType,
typename T>
4253 auto operator()(
const BasicJsonType& j, T&& val)
const
4254 noexcept(noexcept(
from_json(j, std::forward<T>(val))))
4255 -> decltype(
from_json(j, std::forward<T>(val)))
4257 return from_json(j, std::forward<T>(val));
4267 constexpr
const auto&
from_json = detail::static_const<detail::from_json_fn>::value;
4274 #include <algorithm>
4278 #include <type_traits>
4301 template<
typename string_type>
4302 void int_to_string( string_type& target, std::size_t value )
4305 using std::to_string;
4308 template<
typename IteratorType>
class iteration_proxy_value
4311 using difference_type = std::ptrdiff_t;
4312 using value_type = iteration_proxy_value;
4313 using pointer = value_type * ;
4314 using reference = value_type & ;
4315 using iterator_category = std::input_iterator_tag;
4316 using string_type =
typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
4320 IteratorType anchor;
4322 std::size_t array_index = 0;
4324 mutable std::size_t array_index_last = 0;
4326 mutable string_type array_index_str =
"0";
4328 const string_type empty_str{};
4331 explicit iteration_proxy_value(IteratorType it) noexcept
4332 : anchor(std::move(it))
4336 iteration_proxy_value& operator*()
4342 iteration_proxy_value& operator++()
4351 bool operator==(
const iteration_proxy_value& o)
const
4353 return anchor == o.anchor;
4357 bool operator!=(
const iteration_proxy_value& o)
const
4359 return anchor != o.anchor;
4363 const string_type& key()
const
4365 JSON_ASSERT(anchor.m_object !=
nullptr);
4367 switch (anchor.m_object->type())
4370 case value_t::array:
4372 if (array_index != array_index_last)
4374 int_to_string( array_index_str, array_index );
4375 array_index_last = array_index;
4377 return array_index_str;
4381 case value_t::object:
4382 return anchor.key();
4391 typename IteratorType::reference value()
const
4393 return anchor.value();
4398 template<
typename IteratorType>
class iteration_proxy
4402 typename IteratorType::reference container;
4406 explicit iteration_proxy(
typename IteratorType::reference cont) noexcept
4407 : container(cont) {}
4410 iteration_proxy_value<IteratorType> begin() noexcept
4412 return iteration_proxy_value<IteratorType>(container.begin());
4416 iteration_proxy_value<IteratorType> end() noexcept
4418 return iteration_proxy_value<IteratorType>(container.end());
4424 template<std::
size_t N,
typename IteratorType, enable_if_t<N == 0,
int> = 0>
4425 auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
4432 template<std::
size_t N,
typename IteratorType, enable_if_t<N == 1,
int> = 0>
4433 auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
4446 #if defined(__clang__)
4448 #pragma clang diagnostic push
4449 #pragma clang diagnostic ignored "-Wmismatched-tags"
4451 template<
typename IteratorType>
4452 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
4453 :
public std::integral_constant<std::size_t, 2> {};
4455 template<std::
size_t N,
typename IteratorType>
4456 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
4459 using type = decltype(
4460 get<N>(std::declval <
4461 ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
4463 #if defined(__clang__)
4464 #pragma clang diagnostic pop
4490 template<value_t>
struct external_constructor;
4493 struct external_constructor<value_t::boolean>
4495 template<
typename BasicJsonType>
4496 static void construct(BasicJsonType& j,
typename BasicJsonType::boolean_t b) noexcept
4498 j.m_value.destroy(j.m_type);
4499 j.m_type = value_t::boolean;
4501 j.assert_invariant();
4506 struct external_constructor<value_t::string>
4508 template<
typename BasicJsonType>
4509 static void construct(BasicJsonType& j,
const typename BasicJsonType::string_t& s)
4511 j.m_value.destroy(j.m_type);
4512 j.m_type = value_t::string;
4514 j.assert_invariant();
4517 template<
typename BasicJsonType>
4518 static void construct(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4520 j.m_value.destroy(j.m_type);
4521 j.m_type = value_t::string;
4522 j.m_value = std::move(s);
4523 j.assert_invariant();
4526 template <
typename BasicJsonType,
typename CompatibleStringType,
4527 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4529 static void construct(BasicJsonType& j,
const CompatibleStringType& str)
4531 j.m_value.destroy(j.m_type);
4532 j.m_type = value_t::string;
4533 j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4534 j.assert_invariant();
4539 struct external_constructor<value_t::binary>
4541 template<
typename BasicJsonType>
4542 static void construct(BasicJsonType& j,
const typename BasicJsonType::binary_t& b)
4544 j.m_value.destroy(j.m_type);
4545 j.m_type = value_t::binary;
4546 j.m_value =
typename BasicJsonType::binary_t(b);
4547 j.assert_invariant();
4550 template<
typename BasicJsonType>
4551 static void construct(BasicJsonType& j,
typename BasicJsonType::binary_t&& b)
4553 j.m_value.destroy(j.m_type);
4554 j.m_type = value_t::binary;
4555 j.m_value =
typename BasicJsonType::binary_t(std::move(b));;
4556 j.assert_invariant();
4561 struct external_constructor<value_t::number_float>
4563 template<
typename BasicJsonType>
4564 static void construct(BasicJsonType& j,
typename BasicJsonType::number_float_t val) noexcept
4566 j.m_value.destroy(j.m_type);
4567 j.m_type = value_t::number_float;
4569 j.assert_invariant();
4574 struct external_constructor<value_t::number_unsigned>
4576 template<
typename BasicJsonType>
4577 static void construct(BasicJsonType& j,
typename BasicJsonType::number_unsigned_t val) noexcept
4579 j.m_value.destroy(j.m_type);
4580 j.m_type = value_t::number_unsigned;
4582 j.assert_invariant();
4587 struct external_constructor<value_t::number_integer>
4589 template<
typename BasicJsonType>
4590 static void construct(BasicJsonType& j,
typename BasicJsonType::number_integer_t val) noexcept
4592 j.m_value.destroy(j.m_type);
4593 j.m_type = value_t::number_integer;
4595 j.assert_invariant();
4600 struct external_constructor<value_t::array>
4602 template<
typename BasicJsonType>
4603 static void construct(BasicJsonType& j,
const typename BasicJsonType::array_t& arr)
4605 j.m_value.destroy(j.m_type);
4606 j.m_type = value_t::array;
4609 j.assert_invariant();
4612 template<
typename BasicJsonType>
4613 static void construct(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4615 j.m_value.destroy(j.m_type);
4616 j.m_type = value_t::array;
4617 j.m_value = std::move(arr);
4619 j.assert_invariant();
4622 template <
typename BasicJsonType,
typename CompatibleArrayType,
4623 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4625 static void construct(BasicJsonType& j,
const CompatibleArrayType& arr)
4630 j.m_value.destroy(j.m_type);
4631 j.m_type = value_t::array;
4632 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4634 j.assert_invariant();
4637 template<
typename BasicJsonType>
4638 static void construct(BasicJsonType& j,
const std::vector<bool>& arr)
4640 j.m_value.destroy(j.m_type);
4641 j.m_type = value_t::array;
4642 j.m_value = value_t::array;
4643 j.m_value.array->reserve(arr.size());
4644 for (
const bool x : arr)
4646 j.m_value.array->push_back(x);
4647 j.set_parent(j.m_value.array->back());
4649 j.assert_invariant();
4652 template<
typename BasicJsonType,
typename T,
4653 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4654 static void construct(BasicJsonType& j,
const std::valarray<T>& arr)
4656 j.m_value.destroy(j.m_type);
4657 j.m_type = value_t::array;
4658 j.m_value = value_t::array;
4659 j.m_value.array->resize(arr.size());
4662 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4665 j.assert_invariant();
4670 struct external_constructor<value_t::object>
4672 template<
typename BasicJsonType>
4673 static void construct(BasicJsonType& j,
const typename BasicJsonType::object_t& obj)
4675 j.m_value.destroy(j.m_type);
4676 j.m_type = value_t::object;
4679 j.assert_invariant();
4682 template<
typename BasicJsonType>
4683 static void construct(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4685 j.m_value.destroy(j.m_type);
4686 j.m_type = value_t::object;
4687 j.m_value = std::move(obj);
4689 j.assert_invariant();
4692 template <
typename BasicJsonType,
typename CompatibleObjectType,
4693 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value,
int > = 0 >
4694 static void construct(BasicJsonType& j,
const CompatibleObjectType& obj)
4699 j.m_value.destroy(j.m_type);
4700 j.m_type = value_t::object;
4701 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4703 j.assert_invariant();
4711 template<
typename BasicJsonType,
typename T,
4712 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value,
int> = 0>
4713 void to_json(BasicJsonType& j, T b) noexcept
4715 external_constructor<value_t::boolean>::construct(j, b);
4718 template<
typename BasicJsonType,
typename CompatibleString,
4719 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value,
int> = 0>
4720 void to_json(BasicJsonType& j,
const CompatibleString& s)
4722 external_constructor<value_t::string>::construct(j, s);
4725 template<
typename BasicJsonType>
4726 void to_json(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4728 external_constructor<value_t::string>::construct(j, std::move(s));
4731 template<
typename BasicJsonType,
typename FloatType,
4732 enable_if_t<std::is_floating_point<FloatType>::value,
int> = 0>
4733 void to_json(BasicJsonType& j, FloatType val) noexcept
4735 external_constructor<value_t::number_float>::construct(j,
static_cast<typename BasicJsonType::number_float_t
>(val));
4738 template<
typename BasicJsonType,
typename CompatibleNumberUnsignedType,
4739 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value,
int> = 0>
4740 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4742 external_constructor<value_t::number_unsigned>::construct(j,
static_cast<typename BasicJsonType::number_unsigned_t
>(val));
4745 template<
typename BasicJsonType,
typename CompatibleNumberIntegerType,
4746 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value,
int> = 0>
4747 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4749 external_constructor<value_t::number_integer>::construct(j,
static_cast<typename BasicJsonType::number_integer_t
>(val));
4752 template<
typename BasicJsonType,
typename EnumType,
4753 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
4754 void to_json(BasicJsonType& j, EnumType e) noexcept
4756 using underlying_type =
typename std::underlying_type<EnumType>::type;
4757 external_constructor<value_t::number_integer>::construct(j,
static_cast<underlying_type
>(e));
4760 template<
typename BasicJsonType>
4761 void to_json(BasicJsonType& j,
const std::vector<bool>& e)
4763 external_constructor<value_t::array>::construct(j, e);
4766 template <
typename BasicJsonType,
typename CompatibleArrayType,
4767 enable_if_t < is_compatible_array_type<BasicJsonType,
4768 CompatibleArrayType>::value&&
4769 !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4770 !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4771 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4772 !is_basic_json<CompatibleArrayType>::value,
4774 void to_json(BasicJsonType& j,
const CompatibleArrayType& arr)
4776 external_constructor<value_t::array>::construct(j, arr);
4779 template<
typename BasicJsonType>
4780 void to_json(BasicJsonType& j,
const typename BasicJsonType::binary_t& bin)
4782 external_constructor<value_t::binary>::construct(j, bin);
4785 template<
typename BasicJsonType,
typename T,
4786 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4787 void to_json(BasicJsonType& j,
const std::valarray<T>& arr)
4789 external_constructor<value_t::array>::construct(j, std::move(arr));
4792 template<
typename BasicJsonType>
4793 void to_json(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4795 external_constructor<value_t::array>::construct(j, std::move(arr));
4798 template <
typename BasicJsonType,
typename CompatibleObjectType,
4799 enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value,
int > = 0 >
4800 void to_json(BasicJsonType& j,
const CompatibleObjectType& obj)
4802 external_constructor<value_t::object>::construct(j, obj);
4805 template<
typename BasicJsonType>
4806 void to_json(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4808 external_constructor<value_t::object>::construct(j, std::move(obj));
4812 typename BasicJsonType,
typename T, std::size_t N,
4813 enable_if_t < !std::is_constructible<
typename BasicJsonType::string_t,
4814 const T(&)[N]>::value,
4816 void to_json(BasicJsonType& j,
const T(&arr)[N])
4818 external_constructor<value_t::array>::construct(j, arr);
4821 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value,
int > = 0 >
4822 void to_json(BasicJsonType& j,
const std::pair<T1, T2>& p)
4824 j = { p.first, p.second };
4828 template<
typename BasicJsonType,
typename T,
4829 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value,
int> = 0>
4830 void to_json(BasicJsonType& j,
const T& b)
4832 j = { {b.key(), b.value()} };
4835 template<
typename BasicJsonType,
typename Tuple, std::size_t... Idx>
4836 void to_json_tuple_impl(BasicJsonType& j,
const Tuple& t, index_sequence<Idx...> )
4838 j = { std::get<Idx>(t)... };
4841 template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value,
int > = 0>
4842 void to_json(BasicJsonType& j,
const T& t)
4844 to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4849 template<
typename BasicJsonType,
typename T>
4850 auto operator()(BasicJsonType& j, T&& val)
const noexcept(noexcept(
to_json(j, std::forward<T>(val))))
4851 -> decltype(
to_json(j, std::forward<T>(val)),
void())
4853 return to_json(j, std::forward<T>(val));
4863 constexpr
const auto&
to_json = detail::static_const<detail::to_json_fn>::value;
4875 template<
typename ValueType,
typename>
4889 template<
typename BasicJsonType,
typename TargetType = ValueType>
4890 static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
4891 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4892 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val),
void())
4894 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4909 template<
typename BasicJsonType,
typename TargetType = ValueType>
4911 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
4912 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
4914 return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
4926 template<
typename BasicJsonType,
typename TargetType = ValueType>
4927 static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
4928 noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
4929 -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)),
void())
4931 ::nlohmann::to_json(j, std::forward<TargetType>(val));
4959 template<
typename BinaryType>
4980 , m_subtype(subtype_)
4981 , m_has_subtype(true)
4986 , m_subtype(subtype_)
4987 , m_has_subtype(true)
4992 return std::tie(
static_cast<const BinaryType&
>(*
this), m_subtype, m_has_subtype) ==
4993 std::tie(
static_cast<const BinaryType&
>(rhs), rhs.m_subtype, rhs.m_has_subtype);
4998 return !(rhs == *
this);
5021 m_subtype = subtype_;
5022 m_has_subtype =
true;
5069 return m_has_subtype;
5094 m_has_subtype =
false;
5098 std::uint8_t m_subtype = 0;
5099 bool m_has_subtype =
false;
5115 #include <functional>
5126 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
5128 seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
5143 template<
typename BasicJsonType>
5144 std::size_t hash(
const BasicJsonType& j)
5146 using string_t =
typename BasicJsonType::string_t;
5147 using number_integer_t =
typename BasicJsonType::number_integer_t;
5148 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5149 using number_float_t =
typename BasicJsonType::number_float_t;
5151 const auto type =
static_cast<std::size_t
>(j.type());
5154 case BasicJsonType::value_t::null:
5155 case BasicJsonType::value_t::discarded:
5157 return combine(type, 0);
5160 case BasicJsonType::value_t::object:
5162 auto seed = combine(type, j.size());
5163 for (
const auto& element : j.items())
5165 const auto h = std::hash<string_t> {}(element.key());
5166 seed = combine(seed, h);
5167 seed = combine(seed, hash(element.value()));
5172 case BasicJsonType::value_t::array:
5174 auto seed = combine(type, j.size());
5175 for (
const auto& element : j)
5177 seed = combine(seed, hash(element));
5182 case BasicJsonType::value_t::string:
5184 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5185 return combine(type, h);
5188 case BasicJsonType::value_t::boolean:
5190 const auto h = std::hash<bool> {}(j.template get<bool>());
5191 return combine(type, h);
5194 case BasicJsonType::value_t::number_integer:
5196 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
5197 return combine(type, h);
5200 case BasicJsonType::value_t::number_unsigned:
5202 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
5203 return combine(type, h);
5206 case BasicJsonType::value_t::number_float:
5208 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
5209 return combine(type, h);
5212 case BasicJsonType::value_t::binary:
5214 auto seed = combine(type, j.get_binary().size());
5215 const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
5216 seed = combine(seed, h);
5217 seed = combine(seed, j.get_binary().subtype());
5218 for (
const auto byte : j.get_binary())
5220 seed = combine(seed, std::hash<std::uint8_t> {}(byte));
5237 #include <algorithm>
5262 #include <type_traits>
5280 enum class input_format_t {
json, cbor, msgpack, ubjson, bson };
5291 class file_input_adapter
5294 using char_type = char;
5296 JSON_HEDLEY_NON_NULL(2)
5297 explicit file_input_adapter(std::FILE* f) noexcept
5302 file_input_adapter(
const file_input_adapter&) =
delete;
5303 file_input_adapter(file_input_adapter&&) noexcept = default;
5304 file_input_adapter& operator=(const file_input_adapter&) = delete;
5305 file_input_adapter& operator=(file_input_adapter&&) = delete;
5306 ~file_input_adapter() = default;
5308 std::char_traits<
char>::int_type get_character() noexcept
5310 return std::fgetc(m_file);
5328 class input_stream_adapter
5331 using char_type = char;
5333 ~input_stream_adapter()
5339 is->clear(is->rdstate() & std::ios::eofbit);
5343 explicit input_stream_adapter(std::istream& i)
5344 : is(&i), sb(i.rdbuf())
5348 input_stream_adapter(
const input_stream_adapter&) =
delete;
5349 input_stream_adapter& operator=(input_stream_adapter&) =
delete;
5350 input_stream_adapter& operator=(input_stream_adapter&&) =
delete;
5352 input_stream_adapter(input_stream_adapter&& rhs) noexcept
5353 : is(rhs.is), sb(rhs.sb)
5362 std::char_traits<char>::int_type get_character()
5364 auto res = sb->sbumpc();
5366 if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
5368 is->clear(is->rdstate() | std::ios::eofbit);
5375 std::istream* is =
nullptr;
5376 std::streambuf* sb =
nullptr;
5382 template<
typename IteratorType>
5383 class iterator_input_adapter
5386 using char_type =
typename std::iterator_traits<IteratorType>::value_type;
5388 iterator_input_adapter(IteratorType first, IteratorType last)
5389 : current(std::move(first)), end(std::move(last))
5392 typename std::char_traits<char_type>::int_type get_character()
5394 if (JSON_HEDLEY_LIKELY(current != end))
5396 auto result = std::char_traits<char_type>::to_int_type(*current);
5397 std::advance(current, 1);
5401 return std::char_traits<char_type>::eof();
5405 IteratorType current;
5408 template<
typename BaseInputAdapter,
size_t T>
5409 friend struct wide_string_input_helper;
5413 return current == end;
5418 template<
typename BaseInputAdapter,
size_t T>
5419 struct wide_string_input_helper;
5421 template<
typename BaseInputAdapter>
5422 struct wide_string_input_helper<BaseInputAdapter, 4>
5425 static void fill_buffer(BaseInputAdapter& input,
5426 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5427 size_t& utf8_bytes_index,
5428 size_t& utf8_bytes_filled)
5430 utf8_bytes_index = 0;
5432 if (JSON_HEDLEY_UNLIKELY(input.empty()))
5434 utf8_bytes[0] = std::char_traits<char>::eof();
5435 utf8_bytes_filled = 1;
5440 const auto wc = input.get_character();
5445 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5446 utf8_bytes_filled = 1;
5448 else if (wc <= 0x7FF)
5450 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
5451 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5452 utf8_bytes_filled = 2;
5454 else if (wc <= 0xFFFF)
5456 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
5457 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5458 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5459 utf8_bytes_filled = 3;
5461 else if (wc <= 0x10FFFF)
5463 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | ((
static_cast<unsigned int>(wc) >> 18u) & 0x07u));
5464 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
5465 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5466 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5467 utf8_bytes_filled = 4;
5472 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5473 utf8_bytes_filled = 1;
5479 template<
typename BaseInputAdapter>
5480 struct wide_string_input_helper<BaseInputAdapter, 2>
5483 static void fill_buffer(BaseInputAdapter& input,
5484 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5485 size_t& utf8_bytes_index,
5486 size_t& utf8_bytes_filled)
5488 utf8_bytes_index = 0;
5490 if (JSON_HEDLEY_UNLIKELY(input.empty()))
5492 utf8_bytes[0] = std::char_traits<char>::eof();
5493 utf8_bytes_filled = 1;
5498 const auto wc = input.get_character();
5503 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5504 utf8_bytes_filled = 1;
5506 else if (wc <= 0x7FF)
5508 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u)));
5509 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5510 utf8_bytes_filled = 2;
5512 else if (0xD800 > wc || wc >= 0xE000)
5514 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u)));
5515 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5516 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
5517 utf8_bytes_filled = 3;
5521 if (JSON_HEDLEY_UNLIKELY(!input.empty()))
5523 const auto wc2 =
static_cast<unsigned int>(input.get_character());
5524 const auto charcode = 0x10000u + (((
static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
5525 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | (charcode >> 18u));
5526 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 12u) & 0x3Fu));
5527 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 6u) & 0x3Fu));
5528 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (charcode & 0x3Fu));
5529 utf8_bytes_filled = 4;
5533 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
5534 utf8_bytes_filled = 1;
5542 template<
typename BaseInputAdapter,
typename W
ideCharType>
5543 class wide_string_input_adapter
5546 using char_type = char;
5548 wide_string_input_adapter(BaseInputAdapter base)
5549 : base_adapter(base) {}
5551 typename std::char_traits<char>::int_type get_character() noexcept
5554 if (utf8_bytes_index == utf8_bytes_filled)
5556 fill_buffer<sizeof(WideCharType)>();
5558 JSON_ASSERT(utf8_bytes_filled > 0);
5559 JSON_ASSERT(utf8_bytes_index == 0);
5563 JSON_ASSERT(utf8_bytes_filled > 0);
5564 JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5565 return utf8_bytes[utf8_bytes_index++];
5569 BaseInputAdapter base_adapter;
5574 wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
5578 std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5581 std::size_t utf8_bytes_index = 0;
5583 std::size_t utf8_bytes_filled = 0;
5587 template<
typename IteratorType,
typename Enable =
void>
5588 struct iterator_input_adapter_factory
5590 using iterator_type = IteratorType;
5591 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5592 using adapter_type = iterator_input_adapter<iterator_type>;
5594 static adapter_type create(IteratorType first, IteratorType last)
5596 return adapter_type(std::move(first), std::move(last));
5600 template<
typename T>
5601 struct is_iterator_of_multibyte
5603 using value_type =
typename std::iterator_traits<T>::value_type;
5606 value =
sizeof(value_type) > 1
5610 template<
typename IteratorType>
5611 struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5613 using iterator_type = IteratorType;
5614 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5615 using base_adapter_type = iterator_input_adapter<iterator_type>;
5616 using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
5618 static adapter_type create(IteratorType first, IteratorType last)
5620 return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5625 template<
typename IteratorType>
5626 typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5628 using factory_type = iterator_input_adapter_factory<IteratorType>;
5629 return factory_type::create(first, last);
5636 namespace container_input_adapter_factory_impl
5642 template<
typename ContainerType,
typename Enable =
void>
5643 struct container_input_adapter_factory {};
5645 template<
typename ContainerType>
5646 struct container_input_adapter_factory< ContainerType,
5647 void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
5649 using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
5651 static adapter_type create(
const ContainerType& container)
5653 return input_adapter(begin(container), end(container));
5659 template<
typename ContainerType>
5660 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(
const ContainerType& container)
5662 return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
5667 inline file_input_adapter input_adapter(std::FILE* file)
5669 return file_input_adapter(file);
5672 inline input_stream_adapter input_adapter(std::istream& stream)
5674 return input_stream_adapter(stream);
5677 inline input_stream_adapter input_adapter(std::istream&& stream)
5679 return input_stream_adapter(stream);
5683 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5686 template <
typename CharT,
5687 typename std::enable_if <
5688 std::is_pointer<CharT>::value&&
5689 !std::is_array<CharT>::value&&
5690 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5691 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5693 contiguous_bytes_input_adapter input_adapter(CharT b)
5695 auto length = std::strlen(
reinterpret_cast<const char*
>(b));
5696 const auto* ptr =
reinterpret_cast<const char*
>(b);
5697 return input_adapter(ptr, ptr + length);
5700 template<
typename T, std::
size_t N>
5701 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
5703 return input_adapter(array, array + N);
5709 class span_input_adapter
5712 template <
typename CharT,
5713 typename std::enable_if <
5714 std::is_pointer<CharT>::value&&
5715 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5716 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5718 span_input_adapter(CharT b, std::size_t l)
5719 : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5721 template<
class IteratorType,
5722 typename std::enable_if<
5723 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5725 span_input_adapter(IteratorType first, IteratorType last)
5726 : ia(input_adapter(first, last)) {}
5728 contiguous_bytes_input_adapter&& get()
5730 return std::move(ia);
5734 contiguous_bytes_input_adapter ia;
5763 template<
typename BasicJsonType>
5776 virtual bool null() = 0;
5867 const std::string& last_token,
5868 const detail::exception& ex) = 0;
5894 template<
typename BasicJsonType>
5895 class json_sax_dom_parser
5901 using string_t =
typename BasicJsonType::string_t;
5902 using binary_t =
typename BasicJsonType::binary_t;
5909 explicit json_sax_dom_parser(BasicJsonType& r,
const bool allow_exceptions_ =
true)
5910 : root(r), allow_exceptions(allow_exceptions_)
5914 json_sax_dom_parser(
const json_sax_dom_parser&) =
delete;
5915 json_sax_dom_parser(json_sax_dom_parser&&) =
default;
5916 json_sax_dom_parser&
operator=(
const json_sax_dom_parser&) =
delete;
5917 json_sax_dom_parser&
operator=(json_sax_dom_parser&&) =
default;
5918 ~json_sax_dom_parser() =
default;
5922 handle_value(
nullptr);
5958 handle_value(std::move(val));
5964 ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
5966 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5968 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
5977 object_element = &(ref_stack.back()->m_value.object->operator[](val));
5983 ref_stack.back()->set_parents();
5984 ref_stack.pop_back();
5990 ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
5992 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5994 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6002 ref_stack.back()->set_parents();
6003 ref_stack.pop_back();
6007 template<
class Exception>
6008 bool parse_error(std::size_t ,
const std::string& ,
6009 const Exception& ex)
6012 static_cast<void>(ex);
6013 if (allow_exceptions)
6020 constexpr
bool is_errored()
const
6032 template<
typename Value>
6034 BasicJsonType* handle_value(Value&& v)
6036 if (ref_stack.empty())
6038 root = BasicJsonType(std::forward<Value>(v));
6042 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6044 if (ref_stack.back()->is_array())
6046 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6047 return &(ref_stack.back()->m_value.array->back());
6050 JSON_ASSERT(ref_stack.back()->is_object());
6051 JSON_ASSERT(object_element);
6052 *object_element = BasicJsonType(std::forward<Value>(v));
6053 return object_element;
6057 BasicJsonType& root;
6059 std::vector<BasicJsonType*> ref_stack {};
6061 BasicJsonType* object_element =
nullptr;
6063 bool errored =
false;
6065 const bool allow_exceptions =
true;
6068 template<
typename BasicJsonType>
6069 class json_sax_dom_callback_parser
6075 using string_t =
typename BasicJsonType::string_t;
6076 using binary_t =
typename BasicJsonType::binary_t;
6077 using parser_callback_t =
typename BasicJsonType::parser_callback_t;
6078 using parse_event_t =
typename BasicJsonType::parse_event_t;
6080 json_sax_dom_callback_parser(BasicJsonType& r,
6081 const parser_callback_t cb,
6082 const bool allow_exceptions_ =
true)
6083 : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6085 keep_stack.push_back(
true);
6089 json_sax_dom_callback_parser(
const json_sax_dom_callback_parser&) =
delete;
6090 json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) =
default;
6091 json_sax_dom_callback_parser&
operator=(
const json_sax_dom_callback_parser&) =
delete;
6092 json_sax_dom_callback_parser&
operator=(json_sax_dom_callback_parser&&) =
default;
6093 ~json_sax_dom_callback_parser() =
default;
6097 handle_value(
nullptr);
6133 handle_value(std::move(val));
6140 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
6141 keep_stack.push_back(keep);
6143 auto val = handle_value(BasicJsonType::value_t::object,
true);
6144 ref_stack.push_back(val.second);
6147 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6149 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len), *ref_stack.back()));
6157 BasicJsonType k = BasicJsonType(val);
6160 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::key, k);
6161 key_keep_stack.push_back(keep);
6164 if (keep && ref_stack.back())
6166 object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
6174 if (ref_stack.back())
6176 if (!callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
6179 *ref_stack.back() = discarded;
6183 ref_stack.back()->set_parents();
6187 JSON_ASSERT(!ref_stack.empty());
6188 JSON_ASSERT(!keep_stack.empty());
6189 ref_stack.pop_back();
6190 keep_stack.pop_back();
6192 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
6195 for (
auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
6197 if (it->is_discarded())
6199 ref_stack.back()->erase(it);
6210 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
6211 keep_stack.push_back(keep);
6213 auto val = handle_value(BasicJsonType::value_t::array,
true);
6214 ref_stack.push_back(val.second);
6217 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
6219 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len), *ref_stack.back()));
6229 if (ref_stack.back())
6231 keep = callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
6234 ref_stack.back()->set_parents();
6239 *ref_stack.back() = discarded;
6243 JSON_ASSERT(!ref_stack.empty());
6244 JSON_ASSERT(!keep_stack.empty());
6245 ref_stack.pop_back();
6246 keep_stack.pop_back();
6249 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
6251 ref_stack.back()->m_value.array->pop_back();
6257 template<
class Exception>
6258 bool parse_error(std::size_t ,
const std::string& ,
6259 const Exception& ex)
6262 static_cast<void>(ex);
6263 if (allow_exceptions)
6270 constexpr
bool is_errored()
const
6291 template<
typename Value>
6292 std::pair<bool, BasicJsonType*> handle_value(Value&& v,
const bool skip_callback =
false)
6294 JSON_ASSERT(!keep_stack.empty());
6298 if (!keep_stack.back())
6300 return {
false,
nullptr};
6304 auto value = BasicJsonType(std::forward<Value>(v));
6307 const bool keep = skip_callback || callback(
static_cast<int>(ref_stack.size()), parse_event_t::value, value);
6312 return {
false,
nullptr};
6315 if (ref_stack.empty())
6317 root = std::move(value);
6318 return {
true, &root};
6323 if (!ref_stack.back())
6325 return {
false,
nullptr};
6329 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6332 if (ref_stack.back()->is_array())
6334 ref_stack.back()->m_value.array->emplace_back(std::move(value));
6335 return {
true, &(ref_stack.back()->m_value.array->back())};
6339 JSON_ASSERT(ref_stack.back()->is_object());
6341 JSON_ASSERT(!key_keep_stack.empty());
6342 const bool store_element = key_keep_stack.back();
6343 key_keep_stack.pop_back();
6347 return {
false,
nullptr};
6350 JSON_ASSERT(object_element);
6351 *object_element = std::move(value);
6352 return {
true, object_element};
6356 BasicJsonType& root;
6358 std::vector<BasicJsonType*> ref_stack {};
6360 std::vector<bool> keep_stack {};
6362 std::vector<bool> key_keep_stack {};
6364 BasicJsonType* object_element =
nullptr;
6366 bool errored =
false;
6368 const parser_callback_t callback =
nullptr;
6370 const bool allow_exceptions =
true;
6372 BasicJsonType discarded = BasicJsonType::value_t::discarded;
6375 template<
typename BasicJsonType>
6376 class json_sax_acceptor
6382 using string_t =
typename BasicJsonType::string_t;
6383 using binary_t =
typename BasicJsonType::binary_t;
6445 bool parse_error(std::size_t ,
const std::string& ,
const detail::exception& )
6462 #include <initializer_list>
6482 template<
typename BasicJsonType>
6487 enum class token_type
6511 static const char* token_type_name(
const token_type t) noexcept
6515 case token_type::uninitialized:
6516 return "<uninitialized>";
6517 case token_type::literal_true:
6518 return "true literal";
6519 case token_type::literal_false:
6520 return "false literal";
6521 case token_type::literal_null:
6522 return "null literal";
6523 case token_type::value_string:
6524 return "string literal";
6525 case token_type::value_unsigned:
6526 case token_type::value_integer:
6527 case token_type::value_float:
6528 return "number literal";
6529 case token_type::begin_array:
6531 case token_type::begin_object:
6533 case token_type::end_array:
6535 case token_type::end_object:
6537 case token_type::name_separator:
6539 case token_type::value_separator:
6541 case token_type::parse_error:
6542 return "<parse error>";
6543 case token_type::end_of_input:
6544 return "end of input";
6545 case token_type::literal_or_value:
6546 return "'[', '{', or a literal";
6549 return "unknown token";
6559 template<
typename BasicJsonType,
typename InputAdapterType>
6560 class lexer :
public lexer_base<BasicJsonType>
6562 using number_integer_t =
typename BasicJsonType::number_integer_t;
6563 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
6564 using number_float_t =
typename BasicJsonType::number_float_t;
6565 using string_t =
typename BasicJsonType::string_t;
6566 using char_type =
typename InputAdapterType::char_type;
6567 using char_int_type =
typename std::char_traits<char_type>::int_type;
6570 using token_type =
typename lexer_base<BasicJsonType>::token_type;
6572 explicit lexer(InputAdapterType&& adapter,
bool ignore_comments_ =
false) noexcept
6573 : ia(std::move(adapter))
6574 , ignore_comments(ignore_comments_)
6575 , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
6579 lexer(
const lexer&) =
delete;
6580 lexer(lexer&&) =
default;
6581 lexer& operator=(lexer&) =
delete;
6582 lexer& operator=(lexer&&) =
default;
6592 static char get_decimal_point() noexcept
6594 const auto* loc = localeconv();
6595 JSON_ASSERT(loc !=
nullptr);
6596 return (loc->decimal_point ==
nullptr) ?
'.' : *(loc->decimal_point);
6621 JSON_ASSERT(current ==
'u');
6624 const auto factors = { 12u, 8u, 4u, 0u };
6625 for (
const auto factor : factors)
6629 if (current >=
'0' && current <=
'9')
6631 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x30u) << factor);
6633 else if (current >=
'A' && current <=
'F')
6635 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x37u) << factor);
6637 else if (current >=
'a' && current <=
'f')
6639 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x57u) << factor);
6647 JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6666 bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6668 JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6671 for (
auto range = ranges.begin(); range != ranges.end(); ++range)
6674 if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6680 error_message =
"invalid string: ill-formed UTF-8 byte";
6703 token_type scan_string()
6709 JSON_ASSERT(current ==
'\"');
6717 case std::char_traits<char_type>::eof():
6719 error_message =
"invalid string: missing closing quote";
6720 return token_type::parse_error;
6726 return token_type::value_string;
6770 const int codepoint1 = get_codepoint();
6771 int codepoint = codepoint1;
6773 if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6775 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6776 return token_type::parse_error;
6780 if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6783 if (JSON_HEDLEY_LIKELY(get() ==
'\\' && get() ==
'u'))
6785 const int codepoint2 = get_codepoint();
6787 if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6789 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6790 return token_type::parse_error;
6794 if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6797 codepoint =
static_cast<int>(
6799 (
static_cast<unsigned int>(codepoint1) << 10u)
6801 +
static_cast<unsigned int>(codepoint2)
6809 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6810 return token_type::parse_error;
6815 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6816 return token_type::parse_error;
6821 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6823 error_message =
"invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6824 return token_type::parse_error;
6829 JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6832 if (codepoint < 0x80)
6835 add(
static_cast<char_int_type
>(codepoint));
6837 else if (codepoint <= 0x7FF)
6840 add(
static_cast<char_int_type
>(0xC0u | (
static_cast<unsigned int>(codepoint) >> 6u)));
6841 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6843 else if (codepoint <= 0xFFFF)
6846 add(
static_cast<char_int_type
>(0xE0u | (
static_cast<unsigned int>(codepoint) >> 12u)));
6847 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6848 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6853 add(
static_cast<char_int_type
>(0xF0u | (
static_cast<unsigned int>(codepoint) >> 18u)));
6854 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6855 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6856 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6864 error_message =
"invalid string: forbidden character after backslash";
6865 return token_type::parse_error;
6874 error_message =
"invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6875 return token_type::parse_error;
6880 error_message =
"invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6881 return token_type::parse_error;
6886 error_message =
"invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6887 return token_type::parse_error;
6892 error_message =
"invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6893 return token_type::parse_error;
6898 error_message =
"invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6899 return token_type::parse_error;
6904 error_message =
"invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6905 return token_type::parse_error;
6910 error_message =
"invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6911 return token_type::parse_error;
6916 error_message =
"invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6917 return token_type::parse_error;
6922 error_message =
"invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6923 return token_type::parse_error;
6928 error_message =
"invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6929 return token_type::parse_error;
6934 error_message =
"invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6935 return token_type::parse_error;
6940 error_message =
"invalid string: control character U+000B (VT) must be escaped to \\u000B";
6941 return token_type::parse_error;
6946 error_message =
"invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
6947 return token_type::parse_error;
6952 error_message =
"invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
6953 return token_type::parse_error;
6958 error_message =
"invalid string: control character U+000E (SO) must be escaped to \\u000E";
6959 return token_type::parse_error;
6964 error_message =
"invalid string: control character U+000F (SI) must be escaped to \\u000F";
6965 return token_type::parse_error;
6970 error_message =
"invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
6971 return token_type::parse_error;
6976 error_message =
"invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
6977 return token_type::parse_error;
6982 error_message =
"invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
6983 return token_type::parse_error;
6988 error_message =
"invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
6989 return token_type::parse_error;
6994 error_message =
"invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
6995 return token_type::parse_error;
7000 error_message =
"invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7001 return token_type::parse_error;
7006 error_message =
"invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7007 return token_type::parse_error;
7012 error_message =
"invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7013 return token_type::parse_error;
7018 error_message =
"invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7019 return token_type::parse_error;
7024 error_message =
"invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7025 return token_type::parse_error;
7030 error_message =
"invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7031 return token_type::parse_error;
7036 error_message =
"invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7037 return token_type::parse_error;
7042 error_message =
"invalid string: control character U+001C (FS) must be escaped to \\u001C";
7043 return token_type::parse_error;
7048 error_message =
"invalid string: control character U+001D (GS) must be escaped to \\u001D";
7049 return token_type::parse_error;
7054 error_message =
"invalid string: control character U+001E (RS) must be escaped to \\u001E";
7055 return token_type::parse_error;
7060 error_message =
"invalid string: control character U+001F (US) must be escaped to \\u001F";
7061 return token_type::parse_error;
7196 if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
7198 return token_type::parse_error;
7206 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7208 return token_type::parse_error;
7230 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7232 return token_type::parse_error;
7240 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7242 return token_type::parse_error;
7250 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7252 return token_type::parse_error;
7262 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7264 return token_type::parse_error;
7272 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7274 return token_type::parse_error;
7282 error_message =
"invalid string: ill-formed UTF-8 byte";
7283 return token_type::parse_error;
7306 case std::char_traits<char_type>::eof():
7323 case std::char_traits<char_type>::eof():
7326 error_message =
"invalid comment; missing closing '*/'";
7354 error_message =
"invalid comment; expecting '/' or '*' after '/'";
7360 JSON_HEDLEY_NON_NULL(2)
7361 static
void strtof(
float& f, const
char* str,
char** endptr) noexcept
7363 f = std::strtof(str, endptr);
7366 JSON_HEDLEY_NON_NULL(2)
7367 static
void strtof(
double& f, const
char* str,
char** endptr) noexcept
7369 f = std::strtod(str, endptr);
7372 JSON_HEDLEY_NON_NULL(2)
7373 static
void strtof(
long double& f, const
char* str,
char** endptr) noexcept
7375 f = std::strtold(str, endptr);
7418 token_type scan_number()
7425 token_type number_type = token_type::value_unsigned;
7433 goto scan_number_minus;
7439 goto scan_number_zero;
7453 goto scan_number_any1;
7463 number_type = token_type::value_integer;
7469 goto scan_number_zero;
7483 goto scan_number_any1;
7488 error_message =
"invalid number; expected digit after '-'";
7489 return token_type::parse_error;
7499 add(decimal_point_char);
7500 goto scan_number_decimal1;
7507 goto scan_number_exponent;
7511 goto scan_number_done;
7530 goto scan_number_any1;
7535 add(decimal_point_char);
7536 goto scan_number_decimal1;
7543 goto scan_number_exponent;
7547 goto scan_number_done;
7550 scan_number_decimal1:
7552 number_type = token_type::value_float;
7567 goto scan_number_decimal2;
7572 error_message =
"invalid number; expected digit after '.'";
7573 return token_type::parse_error;
7577 scan_number_decimal2:
7593 goto scan_number_decimal2;
7600 goto scan_number_exponent;
7604 goto scan_number_done;
7607 scan_number_exponent:
7609 number_type = token_type::value_float;
7616 goto scan_number_sign;
7631 goto scan_number_any2;
7637 "invalid number; expected '+', '-', or digit after exponent";
7638 return token_type::parse_error;
7658 goto scan_number_any2;
7663 error_message =
"invalid number; expected digit after exponent sign";
7664 return token_type::parse_error;
7684 goto scan_number_any2;
7688 goto scan_number_done;
7696 char* endptr =
nullptr;
7700 if (number_type == token_type::value_unsigned)
7702 const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7705 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7709 value_unsigned =
static_cast<number_unsigned_t
>(x);
7710 if (value_unsigned == x)
7712 return token_type::value_unsigned;
7716 else if (number_type == token_type::value_integer)
7718 const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7721 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7725 value_integer =
static_cast<number_integer_t
>(x);
7726 if (value_integer == x)
7728 return token_type::value_integer;
7735 strtof(value_float, token_buffer.data(), &endptr);
7738 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7740 return token_type::value_float;
7748 JSON_HEDLEY_NON_NULL(2)
7749 token_type scan_literal(const char_type* literal_text, const std::
size_t length,
7750 token_type return_type)
7752 JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7753 for (std::size_t i = 1; i < length; ++i)
7755 if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7757 error_message =
"invalid literal";
7758 return token_type::parse_error;
7769 void reset() noexcept
7771 token_buffer.clear();
7772 token_string.clear();
7773 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7788 ++position.chars_read_total;
7789 ++position.chars_read_current_line;
7798 current = ia.get_character();
7801 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7803 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7806 if (current ==
'\n')
7808 ++position.lines_read;
7809 position.chars_read_current_line = 0;
7827 --position.chars_read_total;
7830 if (position.chars_read_current_line == 0)
7832 if (position.lines_read > 0)
7834 --position.lines_read;
7839 --position.chars_read_current_line;
7842 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7844 JSON_ASSERT(!token_string.empty());
7845 token_string.pop_back();
7850 void add(char_int_type c)
7852 token_buffer.push_back(
static_cast<typename string_t::value_type
>(c));
7861 constexpr number_integer_t get_number_integer() const noexcept
7863 return value_integer;
7867 constexpr number_unsigned_t get_number_unsigned() const noexcept
7869 return value_unsigned;
7873 constexpr number_float_t get_number_float() const noexcept
7879 string_t& get_string()
7881 return token_buffer;
7889 constexpr position_t get_position() const noexcept
7897 std::string get_token_string()
const
7901 for (
const auto c : token_string)
7903 if (
static_cast<unsigned char>(c) <=
'\x1F')
7906 std::array<char, 9> cs{{}};
7907 (std::snprintf)(cs.data(), cs.size(),
"<U+%.4X>",
static_cast<unsigned char>(c));
7908 result += cs.data();
7913 result.push_back(
static_cast<std::string::value_type
>(c));
7922 constexpr
const char* get_error_message() const noexcept
7924 return error_message;
7940 return get() == 0xBB && get() == 0xBF;
7949 void skip_whitespace()
7955 while (current ==
' ' || current ==
'\t' || current ==
'\n' || current ==
'\r');
7961 if (position.chars_read_total == 0 && !skip_bom())
7963 error_message =
"invalid BOM; must be 0xEF 0xBB 0xBF if given";
7964 return token_type::parse_error;
7971 while (ignore_comments && current ==
'/')
7973 if (!scan_comment())
7975 return token_type::parse_error;
7986 return token_type::begin_array;
7988 return token_type::end_array;
7990 return token_type::begin_object;
7992 return token_type::end_object;
7994 return token_type::name_separator;
7996 return token_type::value_separator;
8001 std::array<char_type, 4> true_literal = {{char_type(
't'), char_type(
'r'), char_type(
'u'), char_type(
'e')}};
8002 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
8006 std::array<char_type, 5> false_literal = {{char_type(
'f'), char_type(
'a'), char_type(
'l'), char_type(
's'), char_type(
'e')}};
8007 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
8011 std::array<char_type, 4> null_literal = {{char_type(
'n'), char_type(
'u'), char_type(
'l'), char_type(
'l')}};
8012 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
8017 return scan_string();
8031 return scan_number();
8036 case std::char_traits<char_type>::eof():
8037 return token_type::end_of_input;
8041 error_message =
"invalid literal";
8042 return token_type::parse_error;
8048 InputAdapterType ia;
8051 const bool ignore_comments =
false;
8054 char_int_type current = std::char_traits<char_type>::eof();
8057 bool next_unget =
false;
8060 position_t position {};
8063 std::vector<char_type> token_string {};
8066 string_t token_buffer {};
8069 const char* error_message =
"";
8072 number_integer_t value_integer = 0;
8073 number_unsigned_t value_unsigned = 0;
8074 number_float_t value_float = 0;
8077 const char_int_type decimal_point_char =
'.';
8100 template<
typename T>
8101 using null_function_t = decltype(std::declval<T&>().
null());
8103 template<
typename T>
8104 using boolean_function_t =
8105 decltype(std::declval<T&>().
boolean(std::declval<bool>()));
8107 template<
typename T,
typename Integer>
8108 using number_integer_function_t =
8109 decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8111 template<
typename T,
typename Un
signed>
8112 using number_unsigned_function_t =
8113 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8115 template<
typename T,
typename Float,
typename String>
8116 using number_float_function_t = decltype(std::declval<T&>().number_float(
8117 std::declval<Float>(), std::declval<const String&>()));
8119 template<
typename T,
typename String>
8120 using string_function_t =
8121 decltype(std::declval<T&>().
string(std::declval<String&>()));
8123 template<
typename T,
typename Binary>
8124 using binary_function_t =
8125 decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8127 template<
typename T>
8128 using start_object_function_t =
8129 decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8131 template<
typename T,
typename String>
8132 using key_function_t =
8133 decltype(std::declval<T&>().key(std::declval<String&>()));
8135 template<
typename T>
8136 using end_object_function_t = decltype(std::declval<T&>().end_object());
8138 template<
typename T>
8139 using start_array_function_t =
8140 decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
8142 template<
typename T>
8143 using end_array_function_t = decltype(std::declval<T&>().end_array());
8145 template<
typename T,
typename Exception>
8146 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
8147 std::declval<std::size_t>(), std::declval<const std::string&>(),
8148 std::declval<const Exception&>()));
8150 template<
typename SAX,
typename BasicJsonType>
8154 static_assert(is_basic_json<BasicJsonType>::value,
8155 "BasicJsonType must be of type basic_json<...>");
8157 using number_integer_t =
typename BasicJsonType::number_integer_t;
8158 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8159 using number_float_t =
typename BasicJsonType::number_float_t;
8160 using string_t =
typename BasicJsonType::string_t;
8161 using binary_t =
typename BasicJsonType::binary_t;
8162 using exception_t =
typename BasicJsonType::exception;
8165 static constexpr
bool value =
8166 is_detected_exact<bool, null_function_t, SAX>::value &&
8167 is_detected_exact<bool, boolean_function_t, SAX>::value &&
8168 is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
8169 is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
8170 is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
8171 is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
8172 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
8173 is_detected_exact<bool, start_object_function_t, SAX>::value &&
8174 is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
8175 is_detected_exact<bool, end_object_function_t, SAX>::value &&
8176 is_detected_exact<bool, start_array_function_t, SAX>::value &&
8177 is_detected_exact<bool, end_array_function_t, SAX>::value &&
8178 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
8181 template<
typename SAX,
typename BasicJsonType>
8182 struct is_sax_static_asserts
8185 static_assert(is_basic_json<BasicJsonType>::value,
8186 "BasicJsonType must be of type basic_json<...>");
8188 using number_integer_t =
typename BasicJsonType::number_integer_t;
8189 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8190 using number_float_t =
typename BasicJsonType::number_float_t;
8191 using string_t =
typename BasicJsonType::string_t;
8192 using binary_t =
typename BasicJsonType::binary_t;
8193 using exception_t =
typename BasicJsonType::exception;
8196 static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
8197 "Missing/invalid function: bool null()");
8198 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8199 "Missing/invalid function: bool boolean(bool)");
8200 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8201 "Missing/invalid function: bool boolean(bool)");
8203 is_detected_exact<
bool, number_integer_function_t, SAX,
8204 number_integer_t>::value,
8205 "Missing/invalid function: bool number_integer(number_integer_t)");
8207 is_detected_exact<
bool, number_unsigned_function_t, SAX,
8208 number_unsigned_t>::value,
8209 "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
8210 static_assert(is_detected_exact<
bool, number_float_function_t, SAX,
8211 number_float_t, string_t>::value,
8212 "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
8214 is_detected_exact<bool, string_function_t, SAX, string_t>::value,
8215 "Missing/invalid function: bool string(string_t&)");
8217 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
8218 "Missing/invalid function: bool binary(binary_t&)");
8219 static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
8220 "Missing/invalid function: bool start_object(std::size_t)");
8221 static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
8222 "Missing/invalid function: bool key(string_t&)");
8223 static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
8224 "Missing/invalid function: bool end_object()");
8225 static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
8226 "Missing/invalid function: bool start_array(std::size_t)");
8227 static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
8228 "Missing/invalid function: bool end_array()");
8230 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
8231 "Missing/invalid function: bool parse_error(std::size_t, const "
8232 "std::string&, const exception&)");
8246 enum class cbor_tag_handler_t
8259 static inline bool little_endianess(
int num = 1) noexcept
8261 return *
reinterpret_cast<char*
>(&num) == 1;
8272 template<
typename BasicJsonType,
typename InputAdapterType,
typename SAX = json_sax_dom_parser<BasicJsonType>>
8275 using number_integer_t =
typename BasicJsonType::number_integer_t;
8276 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
8277 using number_float_t =
typename BasicJsonType::number_float_t;
8278 using string_t =
typename BasicJsonType::string_t;
8279 using binary_t =
typename BasicJsonType::binary_t;
8280 using json_sax_t = SAX;
8281 using char_type =
typename InputAdapterType::char_type;
8282 using char_int_type =
typename std::char_traits<char_type>::int_type;
8290 explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
8292 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
8296 binary_reader(
const binary_reader&) =
delete;
8297 binary_reader(binary_reader&&) =
default;
8298 binary_reader& operator=(
const binary_reader&) =
delete;
8299 binary_reader& operator=(binary_reader&&) =
default;
8300 ~binary_reader() =
default;
8310 JSON_HEDLEY_NON_NULL(3)
8311 bool sax_parse(const input_format_t format,
8313 const
bool strict = true,
8314 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
8317 bool result =
false;
8321 case input_format_t::bson:
8322 result = parse_bson_internal();
8325 case input_format_t::cbor:
8326 result = parse_cbor_internal(
true, tag_handler);
8329 case input_format_t::msgpack:
8330 result = parse_msgpack_internal();
8333 case input_format_t::ubjson:
8334 result = parse_ubjson_internal();
8342 if (result && strict)
8344 if (format == input_format_t::ubjson)
8353 if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
8355 return sax->parse_error(chars_read, get_token_string(),
8356 parse_error::create(110, chars_read, exception_message(format,
"expected end of input; last byte: 0x" + get_token_string(),
"value"), BasicJsonType()));
8372 bool parse_bson_internal()
8374 std::int32_t document_size{};
8375 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8377 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
8382 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
false)))
8387 return sax->end_object();
8397 bool get_bson_cstr(string_t& result)
8399 auto out = std::back_inserter(result);
8403 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"cstring")))
8407 if (current == 0x00)
8411 *out++ =
static_cast<typename string_t::value_type
>(current);
8426 template<
typename NumberType>
8427 bool get_bson_string(
const NumberType len, string_t& result)
8429 if (JSON_HEDLEY_UNLIKELY(len < 1))
8431 auto last_token = get_token_string();
8432 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson,
"string length must be at least 1, is " + std::to_string(len),
"string"), BasicJsonType()));
8435 return get_string(input_format_t::bson, len -
static_cast<NumberType
>(1), result) && get() != std::char_traits<char_type>::eof();
8447 template<
typename NumberType>
8448 bool get_bson_binary(
const NumberType len, binary_t& result)
8450 if (JSON_HEDLEY_UNLIKELY(len < 0))
8452 auto last_token = get_token_string();
8453 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson,
"byte array length cannot be negative, is " + std::to_string(len),
"binary"), BasicJsonType()));
8457 std::uint8_t subtype{};
8458 get_number<std::uint8_t>(input_format_t::bson, subtype);
8459 result.set_subtype(subtype);
8461 return get_binary(input_format_t::bson, len, result);
8474 bool parse_bson_element_internal(
const char_int_type element_type,
8475 const std::size_t element_type_parse_position)
8477 switch (element_type)
8482 return get_number<double, true>(input_format_t::bson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
8489 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
8494 return parse_bson_internal();
8499 return parse_bson_array();
8506 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
8511 return sax->boolean(get() != 0);
8521 std::int32_t value{};
8522 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8527 std::int64_t value{};
8528 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8533 std::array<char, 3> cr{{}};
8534 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(element_type));
8535 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()));
8552 bool parse_bson_element_list(
const bool is_array)
8556 while (
auto element_type = get())
8558 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"element list")))
8563 const std::size_t element_type_parse_position = chars_read;
8564 if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
8569 if (!is_array && !sax->key(key))
8574 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
8590 bool parse_bson_array()
8592 std::int32_t document_size{};
8593 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8595 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
8600 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
true)))
8605 return sax->end_array();
8620 bool parse_cbor_internal(
const bool get_char,
8621 const cbor_tag_handler_t tag_handler)
8623 switch (get_char ? get() : current)
8626 case std::char_traits<char_type>::eof():
8627 return unexpect_eof(input_format_t::cbor,
"value");
8654 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
8658 std::uint8_t number{};
8659 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8664 std::uint16_t number{};
8665 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8670 std::uint32_t number{};
8671 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8676 std::uint64_t number{};
8677 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8705 return sax->number_integer(
static_cast<std::int8_t
>(0x20 - 1 - current));
8709 std::uint8_t number{};
8710 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8715 std::uint16_t number{};
8716 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8721 std::uint32_t number{};
8722 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8727 std::uint64_t number{};
8728 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1)
8729 -
static_cast<number_integer_t
>(number));
8764 return get_cbor_binary(b) && sax->binary(b);
8799 return get_cbor_string(s) && sax->string(s);
8827 return get_cbor_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8832 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8837 std::uint16_t len{};
8838 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8843 std::uint32_t len{};
8844 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8849 std::uint64_t len{};
8850 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8854 return get_cbor_array(std::size_t(-1), tag_handler);
8881 return get_cbor_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8886 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8891 std::uint16_t len{};
8892 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8897 std::uint32_t len{};
8898 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8903 std::uint64_t len{};
8904 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8908 return get_cbor_object(std::size_t(-1), tag_handler);
8930 switch (tag_handler)
8932 case cbor_tag_handler_t::error:
8934 auto last_token = get_token_string();
8935 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor,
"invalid byte: 0x" + last_token,
"value"), BasicJsonType()));
8938 case cbor_tag_handler_t::ignore:
8945 get_number(input_format_t::cbor, len);
8950 std::uint16_t len{};
8951 get_number(input_format_t::cbor, len);
8956 std::uint32_t len{};
8957 get_number(input_format_t::cbor, len);
8962 std::uint64_t len{};
8963 get_number(input_format_t::cbor, len);
8969 return parse_cbor_internal(
true, tag_handler);
8979 return sax->boolean(
false);
8982 return sax->boolean(
true);
8989 const auto byte1_raw = get();
8990 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
8994 const auto byte2_raw = get();
8995 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
9000 const auto byte1 =
static_cast<unsigned char>(byte1_raw);
9001 const auto byte2 =
static_cast<unsigned char>(byte2_raw);
9011 const auto half =
static_cast<unsigned int>((byte1 << 8u) + byte2);
9012 const double val = [&half]
9014 const int exp = (half >> 10u) & 0x1Fu;
9015 const unsigned int mant = half & 0x3FFu;
9016 JSON_ASSERT(0 <= exp&& exp <= 32);
9017 JSON_ASSERT(mant <= 1024);
9021 return std::ldexp(mant, -24);
9024 ? std::numeric_limits<double>::infinity()
9025 : std::numeric_limits<double>::quiet_NaN();
9027 return std::ldexp(mant + 1024, exp - 25);
9030 return sax->number_float((half & 0x8000u) != 0
9031 ?
static_cast<number_float_t
>(-val)
9032 :
static_cast<number_float_t
>(val),
"");
9038 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9044 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9049 auto last_token = get_token_string();
9050 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor,
"invalid byte: 0x" + last_token,
"value"), BasicJsonType()));
9066 bool get_cbor_string(string_t& result)
9068 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"string")))
9101 return get_string(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
9107 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9112 std::uint16_t len{};
9113 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9118 std::uint32_t len{};
9119 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9124 std::uint64_t len{};
9125 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9130 while (get() != 0xFF)
9133 if (!get_cbor_string(chunk))
9137 result.append(chunk);
9144 auto last_token = get_token_string();
9145 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor,
"expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token,
"string"), BasicJsonType()));
9161 bool get_cbor_binary(binary_t& result)
9163 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"binary")))
9196 return get_binary(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
9202 return get_number(input_format_t::cbor, len) &&
9203 get_binary(input_format_t::cbor, len, result);
9208 std::uint16_t len{};
9209 return get_number(input_format_t::cbor, len) &&
9210 get_binary(input_format_t::cbor, len, result);
9215 std::uint32_t len{};
9216 return get_number(input_format_t::cbor, len) &&
9217 get_binary(input_format_t::cbor, len, result);
9222 std::uint64_t len{};
9223 return get_number(input_format_t::cbor, len) &&
9224 get_binary(input_format_t::cbor, len, result);
9229 while (get() != 0xFF)
9232 if (!get_cbor_binary(chunk))
9236 result.insert(result.end(), chunk.begin(), chunk.end());
9243 auto last_token = get_token_string();
9244 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor,
"expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token,
"binary"), BasicJsonType()));
9255 bool get_cbor_array(
const std::size_t len,
9256 const cbor_tag_handler_t tag_handler)
9258 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9263 if (len != std::size_t(-1))
9265 for (std::size_t i = 0; i < len; ++i)
9267 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9275 while (get() != 0xFF)
9277 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
false, tag_handler)))
9284 return sax->end_array();
9293 bool get_cbor_object(
const std::size_t len,
9294 const cbor_tag_handler_t tag_handler)
9296 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9304 if (len != std::size_t(-1))
9306 for (std::size_t i = 0; i < len; ++i)
9309 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9314 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9323 while (get() != 0xFF)
9325 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9330 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
9339 return sax->end_object();
9349 bool parse_msgpack_internal()
9354 case std::char_traits<char_type>::eof():
9355 return unexpect_eof(input_format_t::msgpack,
"value");
9486 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
9505 return get_msgpack_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
9524 return get_msgpack_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
9564 return get_msgpack_string(s) && sax->string(s);
9571 return sax->boolean(
false);
9574 return sax->boolean(
true);
9589 return get_msgpack_binary(b) && sax->binary(b);
9595 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9601 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9606 std::uint8_t number{};
9607 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9612 std::uint16_t number{};
9613 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9618 std::uint32_t number{};
9619 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9624 std::uint64_t number{};
9625 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9630 std::int8_t number{};
9631 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9636 std::int16_t number{};
9637 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9642 std::int32_t number{};
9643 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9648 std::int64_t number{};
9649 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9654 std::uint16_t len{};
9655 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9660 std::uint32_t len{};
9661 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9666 std::uint16_t len{};
9667 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9672 std::uint32_t len{};
9673 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9709 return sax->number_integer(
static_cast<std::int8_t
>(current));
9713 auto last_token = get_token_string();
9714 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack,
"invalid byte: 0x" + last_token,
"value"), BasicJsonType()));
9729 bool get_msgpack_string(string_t& result)
9731 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack,
"string")))
9772 return get_string(input_format_t::msgpack,
static_cast<unsigned int>(current) & 0x1Fu, result);
9778 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9783 std::uint16_t len{};
9784 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9789 std::uint32_t len{};
9790 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9795 auto last_token = get_token_string();
9796 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack,
"expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token,
"string"), BasicJsonType()));
9811 bool get_msgpack_binary(binary_t& result)
9814 auto assign_and_return_true = [&result](std::int8_t subtype)
9816 result.set_subtype(
static_cast<std::uint8_t
>(subtype));
9825 return get_number(input_format_t::msgpack, len) &&
9826 get_binary(input_format_t::msgpack, len, result);
9831 std::uint16_t len{};
9832 return get_number(input_format_t::msgpack, len) &&
9833 get_binary(input_format_t::msgpack, len, result);
9838 std::uint32_t len{};
9839 return get_number(input_format_t::msgpack, len) &&
9840 get_binary(input_format_t::msgpack, len, result);
9846 std::int8_t subtype{};
9847 return get_number(input_format_t::msgpack, len) &&
9848 get_number(input_format_t::msgpack, subtype) &&
9849 get_binary(input_format_t::msgpack, len, result) &&
9850 assign_and_return_true(subtype);
9855 std::uint16_t len{};
9856 std::int8_t subtype{};
9857 return get_number(input_format_t::msgpack, len) &&
9858 get_number(input_format_t::msgpack, subtype) &&
9859 get_binary(input_format_t::msgpack, len, result) &&
9860 assign_and_return_true(subtype);
9865 std::uint32_t len{};
9866 std::int8_t subtype{};
9867 return get_number(input_format_t::msgpack, len) &&
9868 get_number(input_format_t::msgpack, subtype) &&
9869 get_binary(input_format_t::msgpack, len, result) &&
9870 assign_and_return_true(subtype);
9875 std::int8_t subtype{};
9876 return get_number(input_format_t::msgpack, subtype) &&
9877 get_binary(input_format_t::msgpack, 1, result) &&
9878 assign_and_return_true(subtype);
9883 std::int8_t subtype{};
9884 return get_number(input_format_t::msgpack, subtype) &&
9885 get_binary(input_format_t::msgpack, 2, result) &&
9886 assign_and_return_true(subtype);
9891 std::int8_t subtype{};
9892 return get_number(input_format_t::msgpack, subtype) &&
9893 get_binary(input_format_t::msgpack, 4, result) &&
9894 assign_and_return_true(subtype);
9899 std::int8_t subtype{};
9900 return get_number(input_format_t::msgpack, subtype) &&
9901 get_binary(input_format_t::msgpack, 8, result) &&
9902 assign_and_return_true(subtype);
9907 std::int8_t subtype{};
9908 return get_number(input_format_t::msgpack, subtype) &&
9909 get_binary(input_format_t::msgpack, 16, result) &&
9910 assign_and_return_true(subtype);
9922 bool get_msgpack_array(
const std::size_t len)
9924 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9929 for (std::size_t i = 0; i < len; ++i)
9931 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9937 return sax->end_array();
9944 bool get_msgpack_object(
const std::size_t len)
9946 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9952 for (std::size_t i = 0; i < len; ++i)
9955 if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
9960 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9967 return sax->end_object();
9981 bool parse_ubjson_internal(
const bool get_char =
true)
9983 return get_ubjson_value(get_char ? get_ignore_noop() : current);
10000 bool get_ubjson_string(string_t& result,
const bool get_char =
true)
10007 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
10016 std::uint8_t len{};
10017 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10023 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10028 std::int16_t len{};
10029 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10034 std::int32_t len{};
10035 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10040 std::int64_t len{};
10041 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10045 auto last_token = get_token_string();
10046 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()));
10054 bool get_ubjson_size_value(std::size_t& result)
10056 switch (get_ignore_noop())
10060 std::uint8_t number{};
10061 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10065 result =
static_cast<std::size_t
>(number);
10071 std::int8_t number{};
10072 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10076 result =
static_cast<std::size_t
>(number);
10082 std::int16_t number{};
10083 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10087 result =
static_cast<std::size_t
>(number);
10093 std::int32_t number{};
10094 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10098 result =
static_cast<std::size_t
>(number);
10104 std::int64_t number{};
10105 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10109 result =
static_cast<std::size_t
>(number);
10115 auto last_token = get_token_string();
10116 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()));
10131 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
10133 result.first = string_t::npos;
10138 if (current ==
'$')
10140 result.second = get();
10141 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"type")))
10147 if (JSON_HEDLEY_UNLIKELY(current !=
'#'))
10149 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
10153 auto last_token = get_token_string();
10154 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson,
"expected '#' after type information; last byte: 0x" + last_token,
"size"), BasicJsonType()));
10157 return get_ubjson_size_value(result.first);
10160 if (current ==
'#')
10162 return get_ubjson_size_value(result.first);
10172 bool get_ubjson_value(
const char_int_type prefix)
10176 case std::char_traits<char_type>::eof():
10177 return unexpect_eof(input_format_t::ubjson,
"value");
10180 return sax->boolean(
true);
10182 return sax->boolean(
false);
10185 return sax->null();
10189 std::uint8_t number{};
10190 return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
10195 std::int8_t number{};
10196 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10201 std::int16_t number{};
10202 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10207 std::int32_t number{};
10208 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10213 std::int64_t number{};
10214 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10220 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
10226 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
10231 return get_ubjson_high_precision_number();
10237 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"char")))
10241 if (JSON_HEDLEY_UNLIKELY(current > 127))
10243 auto last_token = get_token_string();
10244 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson,
"byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token,
"char"), BasicJsonType()));
10246 string_t s(1,
static_cast<typename string_t::value_type
>(current));
10247 return sax->string(s);
10253 return get_ubjson_string(s) && sax->string(s);
10257 return get_ubjson_array();
10260 return get_ubjson_object();
10264 auto last_token = get_token_string();
10265 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson,
"invalid byte: 0x" + last_token,
"value"), BasicJsonType()));
10273 bool get_ubjson_array()
10275 std::pair<std::size_t, char_int_type> size_and_type;
10276 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10281 if (size_and_type.first != string_t::npos)
10283 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
10288 if (size_and_type.second != 0)
10290 if (size_and_type.second !=
'N')
10292 for (std::size_t i = 0; i < size_and_type.first; ++i)
10294 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10303 for (std::size_t i = 0; i < size_and_type.first; ++i)
10305 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10314 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10319 while (current !=
']')
10321 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(
false)))
10329 return sax->end_array();
10335 bool get_ubjson_object()
10337 std::pair<std::size_t, char_int_type> size_and_type;
10338 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10344 if (size_and_type.first != string_t::npos)
10346 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
10351 if (size_and_type.second != 0)
10353 for (std::size_t i = 0; i < size_and_type.first; ++i)
10355 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10359 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10368 for (std::size_t i = 0; i < size_and_type.first; ++i)
10370 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10374 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10384 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10389 while (current !=
'}')
10391 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key,
false) || !sax->key(key)))
10395 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10404 return sax->end_object();
10410 bool get_ubjson_high_precision_number()
10413 std::size_t size{};
10414 auto res = get_ubjson_size_value(size);
10415 if (JSON_HEDLEY_UNLIKELY(!res))
10421 std::vector<char> number_vector;
10422 for (std::size_t i = 0; i < size; ++i)
10425 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"number")))
10429 number_vector.push_back(
static_cast<char>(current));
10433 using ia_type = decltype(detail::input_adapter(number_vector));
10434 auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector),
false);
10435 const auto result_number = number_lexer.scan();
10436 const auto number_string = number_lexer.get_token_string();
10437 const auto result_remainder = number_lexer.scan();
10439 using token_type =
typename detail::lexer_base<BasicJsonType>::token_type;
10441 if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
10443 return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson,
"invalid number text: " + number_lexer.get_token_string(),
"high-precision number"), BasicJsonType()));
10446 switch (result_number)
10448 case token_type::value_integer:
10449 return sax->number_integer(number_lexer.get_number_integer());
10450 case token_type::value_unsigned:
10451 return sax->number_unsigned(number_lexer.get_number_unsigned());
10452 case token_type::value_float:
10453 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
10455 return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson,
"invalid number text: " + number_lexer.get_token_string(),
"high-precision number"), BasicJsonType()));
10472 char_int_type get()
10475 return current = ia.get_character();
10481 char_int_type get_ignore_noop()
10487 while (current ==
'N');
10505 template<
typename NumberType,
bool InputIsLittleEndian = false>
10506 bool get_number(
const input_format_t format, NumberType& result)
10509 std::array<std::uint8_t,
sizeof(NumberType)> vec{};
10510 for (std::size_t i = 0; i <
sizeof(NumberType); ++i)
10513 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"number")))
10519 if (is_little_endian != InputIsLittleEndian)
10521 vec[
sizeof(NumberType) - i - 1] =
static_cast<std::uint8_t
>(current);
10525 vec[i] =
static_cast<std::uint8_t
>(current);
10530 std::memcpy(&result, vec.data(),
sizeof(NumberType));
10548 template<
typename NumberType>
10549 bool get_string(
const input_format_t format,
10550 const NumberType len,
10553 bool success =
true;
10554 for (NumberType i = 0; i < len; i++)
10557 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"string")))
10562 result.push_back(
static_cast<typename string_t::value_type
>(current));
10581 template<
typename NumberType>
10582 bool get_binary(
const input_format_t format,
10583 const NumberType len,
10586 bool success =
true;
10587 for (NumberType i = 0; i < len; i++)
10590 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"binary")))
10595 result.push_back(
static_cast<std::uint8_t
>(current));
10605 JSON_HEDLEY_NON_NULL(3)
10606 bool unexpect_eof(const input_format_t format, const
char* context)
const
10608 if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10610 return sax->parse_error(chars_read,
"<end of file>",
10611 parse_error::create(110, chars_read, exception_message(format,
"unexpected end of input", context), BasicJsonType()));
10619 std::string get_token_string()
const
10621 std::array<char, 3> cr{{}};
10622 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(current));
10623 return std::string{cr.data()};
10632 std::string exception_message(
const input_format_t format,
10633 const std::string& detail,
10634 const std::string& context)
const
10636 std::string error_msg =
"syntax error while parsing ";
10640 case input_format_t::cbor:
10641 error_msg +=
"CBOR";
10644 case input_format_t::msgpack:
10645 error_msg +=
"MessagePack";
10648 case input_format_t::ubjson:
10649 error_msg +=
"UBJSON";
10652 case input_format_t::bson:
10653 error_msg +=
"BSON";
10657 JSON_ASSERT(
false);
10660 return error_msg +
" " + context +
": " + detail;
10665 InputAdapterType ia;
10668 char_int_type current = std::char_traits<char_type>::eof();
10671 std::size_t chars_read = 0;
10674 const bool is_little_endian = little_endianess();
10677 json_sax_t* sax =
nullptr;
10691 #include <functional>
10719 enum class parse_event_t : uint8_t
10735 template<
typename BasicJsonType>
10736 using parser_callback_t =
10737 std::function<bool(
int , parse_event_t , BasicJsonType& )>;
10744 template<
typename BasicJsonType,
typename InputAdapterType>
10747 using number_integer_t =
typename BasicJsonType::number_integer_t;
10748 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
10749 using number_float_t =
typename BasicJsonType::number_float_t;
10750 using string_t =
typename BasicJsonType::string_t;
10751 using lexer_t = lexer<BasicJsonType, InputAdapterType>;
10752 using token_type =
typename lexer_t::token_type;
10756 explicit parser(InputAdapterType&& adapter,
10757 const parser_callback_t<BasicJsonType> cb =
nullptr,
10758 const bool allow_exceptions_ =
true,
10759 const bool skip_comments =
false)
10761 , m_lexer(std::move(adapter), skip_comments)
10762 , allow_exceptions(allow_exceptions_)
10778 void parse(
const bool strict, BasicJsonType& result)
10782 json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
10783 sax_parse_internal(&sdp);
10786 if (strict && (get_token() != token_type::end_of_input))
10788 sdp.parse_error(m_lexer.get_position(),
10789 m_lexer.get_token_string(),
10790 parse_error::create(101, m_lexer.get_position(),
10791 exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
10795 if (sdp.is_errored())
10797 result = value_t::discarded;
10803 if (result.is_discarded())
10810 json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
10811 sax_parse_internal(&sdp);
10814 if (strict && (get_token() != token_type::end_of_input))
10816 sdp.parse_error(m_lexer.get_position(),
10817 m_lexer.get_token_string(),
10818 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
10822 if (sdp.is_errored())
10824 result = value_t::discarded;
10829 result.assert_invariant();
10838 bool accept(
const bool strict =
true)
10840 json_sax_acceptor<BasicJsonType> sax_acceptor;
10841 return sax_parse(&sax_acceptor, strict);
10844 template<
typename SAX>
10845 JSON_HEDLEY_NON_NULL(2)
10846 bool sax_parse(SAX* sax, const
bool strict = true)
10848 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
10849 const bool result = sax_parse_internal(sax);
10852 if (result && strict && (get_token() != token_type::end_of_input))
10854 return sax->parse_error(m_lexer.get_position(),
10855 m_lexer.get_token_string(),
10856 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input,
"value"), BasicJsonType()));
10863 template<
typename SAX>
10864 JSON_HEDLEY_NON_NULL(2)
10865 bool sax_parse_internal(SAX* sax)
10869 std::vector<bool> states;
10871 bool skip_to_state_evaluation =
false;
10875 if (!skip_to_state_evaluation)
10878 switch (last_token)
10880 case token_type::begin_object:
10882 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10888 if (get_token() == token_type::end_object)
10890 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10898 if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
10900 return sax->parse_error(m_lexer.get_position(),
10901 m_lexer.get_token_string(),
10902 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string,
"object key"), BasicJsonType()));
10904 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10910 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10912 return sax->parse_error(m_lexer.get_position(),
10913 m_lexer.get_token_string(),
10914 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator,
"object separator"), BasicJsonType()));
10918 states.push_back(
false);
10925 case token_type::begin_array:
10927 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10933 if (get_token() == token_type::end_array)
10935 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10943 states.push_back(
true);
10949 case token_type::value_float:
10951 const auto res = m_lexer.get_number_float();
10953 if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
10955 return sax->parse_error(m_lexer.get_position(),
10956 m_lexer.get_token_string(),
10957 out_of_range::create(406,
"number overflow parsing '" + m_lexer.get_token_string() +
"'", BasicJsonType()));
10960 if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
10968 case token_type::literal_false:
10970 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
false)))
10977 case token_type::literal_null:
10979 if (JSON_HEDLEY_UNLIKELY(!sax->null()))
10986 case token_type::literal_true:
10988 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
true)))
10995 case token_type::value_integer:
10997 if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
11004 case token_type::value_string:
11006 if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
11013 case token_type::value_unsigned:
11015 if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
11022 case token_type::parse_error:
11025 return sax->parse_error(m_lexer.get_position(),
11026 m_lexer.get_token_string(),
11027 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized,
"value"), BasicJsonType()));
11032 return sax->parse_error(m_lexer.get_position(),
11033 m_lexer.get_token_string(),
11034 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value,
"value"), BasicJsonType()));
11040 skip_to_state_evaluation =
false;
11044 if (states.empty())
11053 if (get_token() == token_type::value_separator)
11061 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
11063 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11072 JSON_ASSERT(!states.empty());
11074 skip_to_state_evaluation =
true;
11078 return sax->parse_error(m_lexer.get_position(),
11079 m_lexer.get_token_string(),
11080 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array,
"array"), BasicJsonType()));
11086 if (get_token() == token_type::value_separator)
11089 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
11091 return sax->parse_error(m_lexer.get_position(),
11092 m_lexer.get_token_string(),
11093 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string,
"object key"), BasicJsonType()));
11096 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11102 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11104 return sax->parse_error(m_lexer.get_position(),
11105 m_lexer.get_token_string(),
11106 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator,
"object separator"), BasicJsonType()));
11115 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
11117 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11126 JSON_ASSERT(!states.empty());
11128 skip_to_state_evaluation =
true;
11132 return sax->parse_error(m_lexer.get_position(),
11133 m_lexer.get_token_string(),
11134 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object,
"object"), BasicJsonType()));
11139 token_type get_token()
11141 return last_token = m_lexer.scan();
11144 std::string exception_message(
const token_type expected,
const std::string& context)
11146 std::string error_msg =
"syntax error ";
11148 if (!context.empty())
11150 error_msg +=
"while parsing " + context +
" ";
11155 if (last_token == token_type::parse_error)
11157 error_msg += std::string(m_lexer.get_error_message()) +
"; last read: '" +
11158 m_lexer.get_token_string() +
"'";
11162 error_msg +=
"unexpected " + std::string(lexer_t::token_type_name(last_token));
11165 if (expected != token_type::uninitialized)
11167 error_msg +=
"; expected " + std::string(lexer_t::token_type_name(expected));
11175 const parser_callback_t<BasicJsonType> callback =
nullptr;
11177 token_type last_token = token_type::uninitialized;
11181 const bool allow_exceptions =
true;
11212 class primitive_iterator_t
11215 using difference_type = std::ptrdiff_t;
11216 static constexpr difference_type begin_value = 0;
11217 static constexpr difference_type end_value = begin_value + 1;
11219 JSON_PRIVATE_UNLESS_TESTED:
11221 difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
11224 constexpr difference_type get_value() const noexcept
11230 void set_begin() noexcept
11232 m_it = begin_value;
11236 void set_end() noexcept
11242 constexpr
bool is_begin() const noexcept
11244 return m_it == begin_value;
11248 constexpr
bool is_end() const noexcept
11250 return m_it == end_value;
11253 friend constexpr
bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11255 return lhs.m_it == rhs.m_it;
11258 friend constexpr
bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11260 return lhs.m_it < rhs.m_it;
11263 primitive_iterator_t operator+(difference_type n) noexcept
11265 auto result = *
this;
11270 friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11272 return lhs.m_it - rhs.m_it;
11275 primitive_iterator_t& operator++() noexcept
11281 primitive_iterator_t
const operator++(
int) noexcept
11283 auto result = *
this;
11288 primitive_iterator_t& operator--() noexcept
11294 primitive_iterator_t
const operator--(
int) noexcept
11296 auto result = *
this;
11301 primitive_iterator_t& operator+=(difference_type n) noexcept
11307 primitive_iterator_t& operator-=(difference_type n) noexcept
11327 template<
typename BasicJsonType>
struct internal_iterator
11330 typename BasicJsonType::object_t::iterator object_iterator {};
11332 typename BasicJsonType::array_t::iterator array_iterator {};
11334 primitive_iterator_t primitive_iterator {};
11342 #include <iterator>
11343 #include <type_traits>
11365 template<
typename IteratorType>
class iteration_proxy;
11366 template<
typename IteratorType>
class iteration_proxy_value;
11384 template<
typename BasicJsonType>
11388 using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value,
typename std::remove_const<BasicJsonType>::type,
const BasicJsonType>::type>;
11390 friend other_iter_impl;
11391 friend BasicJsonType;
11392 friend iteration_proxy<iter_impl>;
11393 friend iteration_proxy_value<iter_impl>;
11395 using object_t =
typename BasicJsonType::object_t;
11396 using array_t =
typename BasicJsonType::array_t;
11398 static_assert(is_basic_json<
typename std::remove_const<BasicJsonType>::type>::value,
11399 "iter_impl only accepts (const) basic_json");
11408 using iterator_category = std::bidirectional_iterator_tag;
11411 using value_type =
typename BasicJsonType::value_type;
11413 using difference_type =
typename BasicJsonType::difference_type;
11415 using pointer =
typename std::conditional<std::is_const<BasicJsonType>::value,
11416 typename BasicJsonType::const_pointer,
11417 typename BasicJsonType::pointer>::type;
11420 typename std::conditional<std::is_const<BasicJsonType>::value,
11421 typename BasicJsonType::const_reference,
11422 typename BasicJsonType::reference>::type;
11424 iter_impl() =
default;
11425 ~iter_impl() =
default;
11426 iter_impl(iter_impl&&) noexcept = default;
11427 iter_impl& operator=(iter_impl&&) noexcept = default;
11435 explicit iter_impl(pointer
object) noexcept : m_object(
object)
11437 JSON_ASSERT(m_object !=
nullptr);
11439 switch (m_object->m_type)
11441 case value_t::object:
11443 m_it.object_iterator =
typename object_t::iterator();
11447 case value_t::array:
11449 m_it.array_iterator =
typename array_t::iterator();
11455 m_it.primitive_iterator = primitive_iterator_t();
11477 iter_impl(
const iter_impl<const BasicJsonType>& other) noexcept
11478 : m_object(other.m_object), m_it(other.m_it)
11487 iter_impl& operator=(
const iter_impl<const BasicJsonType>& other) noexcept
11489 if (&other !=
this)
11491 m_object = other.m_object;
11502 iter_impl(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
11503 : m_object(other.m_object), m_it(other.m_it)
11512 iter_impl& operator=(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
11514 m_object = other.m_object;
11519 JSON_PRIVATE_UNLESS_TESTED:
11524 void set_begin() noexcept
11526 JSON_ASSERT(m_object !=
nullptr);
11528 switch (m_object->m_type)
11530 case value_t::object:
11532 m_it.object_iterator = m_object->m_value.object->begin();
11536 case value_t::array:
11538 m_it.array_iterator = m_object->m_value.array->begin();
11542 case value_t::null:
11545 m_it.primitive_iterator.set_end();
11551 m_it.primitive_iterator.set_begin();
11561 void set_end() noexcept
11563 JSON_ASSERT(m_object !=
nullptr);
11565 switch (m_object->m_type)
11567 case value_t::object:
11569 m_it.object_iterator = m_object->m_value.object->end();
11573 case value_t::array:
11575 m_it.array_iterator = m_object->m_value.array->end();
11581 m_it.primitive_iterator.set_end();
11592 reference operator*()
const
11594 JSON_ASSERT(m_object !=
nullptr);
11596 switch (m_object->m_type)
11598 case value_t::object:
11600 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11601 return m_it.object_iterator->second;
11604 case value_t::array:
11606 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11607 return *m_it.array_iterator;
11610 case value_t::null:
11611 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11615 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11620 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11629 pointer operator->()
const
11631 JSON_ASSERT(m_object !=
nullptr);
11633 switch (m_object->m_type)
11635 case value_t::object:
11637 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11638 return &(m_it.object_iterator->second);
11641 case value_t::array:
11643 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11644 return &*m_it.array_iterator;
11649 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11654 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11663 iter_impl
const operator++(
int)
11665 auto result = *
this;
11674 iter_impl& operator++()
11676 JSON_ASSERT(m_object !=
nullptr);
11678 switch (m_object->m_type)
11680 case value_t::object:
11682 std::advance(m_it.object_iterator, 1);
11686 case value_t::array:
11688 std::advance(m_it.array_iterator, 1);
11694 ++m_it.primitive_iterator;
11706 iter_impl
const operator--(
int)
11708 auto result = *
this;
11717 iter_impl& operator--()
11719 JSON_ASSERT(m_object !=
nullptr);
11721 switch (m_object->m_type)
11723 case value_t::object:
11725 std::advance(m_it.object_iterator, -1);
11729 case value_t::array:
11731 std::advance(m_it.array_iterator, -1);
11737 --m_it.primitive_iterator;
11749 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 >
11750 bool operator==(
const IterImpl& other)
const
11753 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11755 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers", *m_object));
11758 JSON_ASSERT(m_object !=
nullptr);
11760 switch (m_object->m_type)
11762 case value_t::object:
11763 return (m_it.object_iterator == other.m_it.object_iterator);
11765 case value_t::array:
11766 return (m_it.array_iterator == other.m_it.array_iterator);
11769 return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11777 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 >
11778 bool operator!=(
const IterImpl& other)
const
11780 return !operator==(other);
11787 bool operator<(
const iter_impl& other)
const
11790 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11792 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers", *m_object));
11795 JSON_ASSERT(m_object !=
nullptr);
11797 switch (m_object->m_type)
11799 case value_t::object:
11800 JSON_THROW(invalid_iterator::create(213,
"cannot compare order of object iterators", *m_object));
11802 case value_t::array:
11803 return (m_it.array_iterator < other.m_it.array_iterator);
11806 return (m_it.primitive_iterator < other.m_it.primitive_iterator);
11814 bool operator<=(
const iter_impl& other)
const
11816 return !other.operator < (*this);
11823 bool operator>(
const iter_impl& other)
const
11825 return !operator<=(other);
11832 bool operator>=(
const iter_impl& other)
const
11834 return !operator<(other);
11841 iter_impl& operator+=(difference_type i)
11843 JSON_ASSERT(m_object !=
nullptr);
11845 switch (m_object->m_type)
11847 case value_t::object:
11848 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators", *m_object));
11850 case value_t::array:
11852 std::advance(m_it.array_iterator, i);
11858 m_it.primitive_iterator += i;
11870 iter_impl& operator-=(difference_type i)
11872 return operator+=(-i);
11879 iter_impl operator+(difference_type i)
const
11881 auto result = *
this;
11890 friend iter_impl operator+(difference_type i,
const iter_impl& it)
11901 iter_impl operator-(difference_type i)
const
11903 auto result = *
this;
11912 difference_type operator-(
const iter_impl& other)
const
11914 JSON_ASSERT(m_object !=
nullptr);
11916 switch (m_object->m_type)
11918 case value_t::object:
11919 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators", *m_object));
11921 case value_t::array:
11922 return m_it.array_iterator - other.m_it.array_iterator;
11925 return m_it.primitive_iterator - other.m_it.primitive_iterator;
11933 reference operator[](difference_type n)
const
11935 JSON_ASSERT(m_object !=
nullptr);
11937 switch (m_object->m_type)
11939 case value_t::object:
11940 JSON_THROW(invalid_iterator::create(208,
"cannot use operator[] for object iterators", *m_object));
11942 case value_t::array:
11943 return *std::next(m_it.array_iterator, n);
11945 case value_t::null:
11946 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11950 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
11955 JSON_THROW(invalid_iterator::create(214,
"cannot get value", *m_object));
11964 const typename object_t::key_type& key()
const
11966 JSON_ASSERT(m_object !=
nullptr);
11968 if (JSON_HEDLEY_LIKELY(m_object->is_object()))
11970 return m_it.object_iterator->first;
11973 JSON_THROW(invalid_iterator::create(207,
"cannot use key() for non-object iterators", *m_object));
11980 reference value()
const
11982 return operator*();
11985 JSON_PRIVATE_UNLESS_TESTED:
11987 pointer m_object =
nullptr;
11989 internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
12000 #include <iterator>
12029 template<
typename Base>
12030 class json_reverse_iterator :
public std::reverse_iterator<Base>
12033 using difference_type = std::ptrdiff_t;
12035 using base_iterator = std::reverse_iterator<Base>;
12037 using reference =
typename Base::reference;
12040 explicit json_reverse_iterator(
const typename base_iterator::iterator_type& it) noexcept
12041 : base_iterator(it) {}
12044 explicit json_reverse_iterator(
const base_iterator& it) noexcept : base_iterator(it) {}
12047 json_reverse_iterator
const operator++(
int)
12049 return static_cast<json_reverse_iterator
>(base_iterator::operator++(1));
12053 json_reverse_iterator& operator++()
12055 return static_cast<json_reverse_iterator&
>(base_iterator::operator++());
12059 json_reverse_iterator
const operator--(
int)
12061 return static_cast<json_reverse_iterator
>(base_iterator::operator--(1));
12065 json_reverse_iterator& operator--()
12067 return static_cast<json_reverse_iterator&
>(base_iterator::operator--());
12071 json_reverse_iterator& operator+=(difference_type i)
12073 return static_cast<json_reverse_iterator&
>(base_iterator::operator+=(i));
12077 json_reverse_iterator operator+(difference_type i)
const
12079 return static_cast<json_reverse_iterator
>(base_iterator::operator+(i));
12083 json_reverse_iterator operator-(difference_type i)
const
12085 return static_cast<json_reverse_iterator
>(base_iterator::operator-(i));
12089 difference_type operator-(
const json_reverse_iterator& other)
const
12091 return base_iterator(*
this) - base_iterator(other);
12095 reference operator[](difference_type n)
const
12097 return *(this->operator+(n));
12101 auto key() const -> decltype(std::declval<Base>().key())
12103 auto it = --this->base();
12108 reference value()
const
12110 auto it = --this->base();
12111 return it.operator * ();
12122 #include <algorithm>
12141 template<
typename BasicJsonType>
12145 NLOHMANN_BASIC_JSON_TPL_DECLARATION
12171 : reference_tokens(split(s))
12190 return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
12192 [](
const std::string & a,
const std::string & b)
12194 return a +
"/" + detail::escape(b);
12199 operator std::string()
const
12222 reference_tokens.insert(reference_tokens.end(),
12223 ptr.reference_tokens.begin(),
12224 ptr.reference_tokens.end());
12268 return *
this /= std::to_string(array_idx);
12372 if (JSON_HEDLEY_UNLIKELY(
empty()))
12374 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12377 reference_tokens.pop_back();
12396 if (JSON_HEDLEY_UNLIKELY(
empty()))
12398 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12401 return reference_tokens.back();
12418 reference_tokens.push_back(token);
12424 reference_tokens.push_back(std::move(token));
12443 return reference_tokens.empty();
12457 static typename BasicJsonType::size_type array_index(
const std::string& s)
12459 using size_type =
typename BasicJsonType::size_type;
12462 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] ==
'0'))
12464 JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + s +
"' must not begin with '0'", BasicJsonType()));
12468 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >=
'1' && s[0] <=
'9')))
12470 JSON_THROW(detail::parse_error::create(109, 0,
"array index '" + s +
"' is not a number", BasicJsonType()));
12473 std::size_t processed_chars = 0;
12474 unsigned long long res = 0;
12477 res = std::stoull(s, &processed_chars);
12479 JSON_CATCH(std::out_of_range&)
12481 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'", BasicJsonType()));
12485 if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
12487 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'", BasicJsonType()));
12492 if (res >=
static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
12494 JSON_THROW(detail::out_of_range::create(410,
"array index " + s +
" exceeds size_type", BasicJsonType()));
12497 return static_cast<size_type
>(res);
12500 JSON_PRIVATE_UNLESS_TESTED:
12503 if (JSON_HEDLEY_UNLIKELY(
empty()))
12505 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent", BasicJsonType()));
12509 result.reference_tokens = {reference_tokens[0]};
12522 BasicJsonType& get_and_create(BasicJsonType& j)
const
12528 for (
const auto& reference_token : reference_tokens)
12530 switch (result->type())
12532 case detail::value_t::null:
12534 if (reference_token ==
"0")
12537 result = &result->operator[](0);
12542 result = &result->operator[](reference_token);
12547 case detail::value_t::object:
12550 result = &result->operator[](reference_token);
12554 case detail::value_t::array:
12557 result = &result->operator[](array_index(reference_token));
12568 JSON_THROW(detail::type_error::create(313,
"invalid value to unflatten", j));
12594 BasicJsonType& get_unchecked(BasicJsonType* ptr)
const
12596 for (
const auto& reference_token : reference_tokens)
12599 if (ptr->is_null())
12603 std::all_of(reference_token.begin(), reference_token.end(),
12604 [](
const unsigned char x)
12606 return std::isdigit(x);
12610 *ptr = (nums || reference_token ==
"-")
12611 ? detail::value_t::array
12612 : detail::value_t::object;
12615 switch (ptr->type())
12617 case detail::value_t::object:
12620 ptr = &ptr->operator[](reference_token);
12624 case detail::value_t::array:
12626 if (reference_token ==
"-")
12629 ptr = &ptr->operator[](ptr->m_value.array->size());
12634 ptr = &ptr->operator[](array_index(reference_token));
12640 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12653 BasicJsonType& get_checked(BasicJsonType* ptr)
const
12655 for (
const auto& reference_token : reference_tokens)
12657 switch (ptr->type())
12659 case detail::value_t::object:
12662 ptr = &ptr->at(reference_token);
12666 case detail::value_t::array:
12668 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12671 JSON_THROW(detail::out_of_range::create(402,
12672 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12673 ") is out of range", *ptr));
12677 ptr = &ptr->at(array_index(reference_token));
12682 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12702 const BasicJsonType& get_unchecked(
const BasicJsonType* ptr)
const
12704 for (
const auto& reference_token : reference_tokens)
12706 switch (ptr->type())
12708 case detail::value_t::object:
12711 ptr = &ptr->operator[](reference_token);
12715 case detail::value_t::array:
12717 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12720 JSON_THROW(detail::out_of_range::create(402,
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
") is out of range", *ptr));
12724 ptr = &ptr->operator[](array_index(reference_token));
12729 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12742 const BasicJsonType& get_checked(
const BasicJsonType* ptr)
const
12744 for (
const auto& reference_token : reference_tokens)
12746 switch (ptr->type())
12748 case detail::value_t::object:
12751 ptr = &ptr->at(reference_token);
12755 case detail::value_t::array:
12757 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12760 JSON_THROW(detail::out_of_range::create(402,
12761 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12762 ") is out of range", *ptr));
12766 ptr = &ptr->at(array_index(reference_token));
12771 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'", *ptr));
12782 bool contains(
const BasicJsonType* ptr)
const
12784 for (
const auto& reference_token : reference_tokens)
12786 switch (ptr->type())
12788 case detail::value_t::object:
12790 if (!ptr->contains(reference_token))
12796 ptr = &ptr->operator[](reference_token);
12800 case detail::value_t::array:
12802 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12807 if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !(
"0" <= reference_token && reference_token <=
"9")))
12812 if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
12814 if (JSON_HEDLEY_UNLIKELY(!(
'1' <= reference_token[0] && reference_token[0] <=
'9')))
12819 for (std::size_t i = 1; i < reference_token.size(); i++)
12821 if (JSON_HEDLEY_UNLIKELY(!(
'0' <= reference_token[i] && reference_token[i] <=
'9')))
12829 const auto idx = array_index(reference_token);
12830 if (idx >= ptr->size())
12836 ptr = &ptr->operator[](idx);
12862 static std::vector<std::string> split(
const std::string& reference_string)
12864 std::vector<std::string> result;
12867 if (reference_string.empty())
12873 if (JSON_HEDLEY_UNLIKELY(reference_string[0] !=
'/'))
12875 JSON_THROW(detail::parse_error::create(107, 1,
"JSON pointer must be empty or begin with '/' - was: '" + reference_string +
"'", BasicJsonType()));
12883 std::size_t slash = reference_string.find_first_of(
'/', 1),
12890 start = (slash == std::string::npos) ? 0 : slash + 1,
12892 slash = reference_string.find_first_of(
'/', start))
12896 auto reference_token = reference_string.substr(start, slash - start);
12899 for (std::size_t pos = reference_token.find_first_of(
'~');
12900 pos != std::string::npos;
12901 pos = reference_token.find_first_of(
'~', pos + 1))
12903 JSON_ASSERT(reference_token[pos] ==
'~');
12906 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
12907 (reference_token[pos + 1] !=
'0' &&
12908 reference_token[pos + 1] !=
'1')))
12910 JSON_THROW(detail::parse_error::create(108, 0,
"escape character '~' must be followed with '0' or '1'", BasicJsonType()));
12915 detail::unescape(reference_token);
12916 result.push_back(reference_token);
12930 static void flatten(
const std::string& reference_string,
12931 const BasicJsonType& value,
12932 BasicJsonType& result)
12934 switch (value.type())
12936 case detail::value_t::array:
12938 if (value.m_value.array->empty())
12941 result[reference_string] =
nullptr;
12946 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
12948 flatten(reference_string +
"/" + std::to_string(i),
12949 value.m_value.array->operator[](i), result);
12955 case detail::value_t::object:
12957 if (value.m_value.object->empty())
12960 result[reference_string] =
nullptr;
12965 for (
const auto& element : *value.m_value.object)
12967 flatten(reference_string +
"/" + detail::escape(element.first), element.second, result);
12976 result[reference_string] = value;
12992 static BasicJsonType
12993 unflatten(
const BasicJsonType& value)
12995 if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
12997 JSON_THROW(detail::type_error::create(314,
"only objects can be unflattened", value));
13000 BasicJsonType result;
13003 for (
const auto& element : *value.m_value.object)
13005 if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
13007 JSON_THROW(detail::type_error::create(315,
"values in object must be primitive", element.second));
13014 json_pointer(element.first).get_and_create(result) = element.second;
13034 return lhs.reference_tokens == rhs.reference_tokens;
13051 return !(lhs == rhs);
13055 std::vector<std::string> reference_tokens;
13062 #include <initializer_list>
13072 template<
typename BasicJsonType>
13076 using value_type = BasicJsonType;
13078 json_ref(value_type&& value)
13079 : owned_value(std::move(value))
13082 json_ref(
const value_type& value)
13083 : value_ref(&value)
13086 json_ref(std::initializer_list<json_ref> init)
13087 : owned_value(init)
13092 enable_if_t<std::is_constructible<value_type, Args...>::value,
int> = 0 >
13093 json_ref(Args && ... args)
13094 : owned_value(std::forward<Args>(args)...)
13098 json_ref(json_ref&&) noexcept = default;
13099 json_ref(const json_ref&) = delete;
13100 json_ref& operator=(const json_ref&) = delete;
13101 json_ref& operator=(json_ref&&) = delete;
13102 ~json_ref() = default;
13104 value_type moved_or_copied()
const
13106 if (value_ref ==
nullptr)
13108 return std::move(owned_value);
13113 value_type
const& operator*()
const
13115 return value_ref ? *value_ref : owned_value;
13118 value_type
const* operator->()
const
13124 mutable value_type owned_value =
nullptr;
13125 value_type
const* value_ref =
nullptr;
13141 #include <algorithm>
13157 #include <algorithm>
13159 #include <iterator>
13177 template<
typename CharType>
struct output_adapter_protocol
13179 virtual void write_character(CharType c) = 0;
13180 virtual void write_characters(
const CharType* s, std::size_t length) = 0;
13181 virtual ~output_adapter_protocol() =
default;
13183 output_adapter_protocol() =
default;
13184 output_adapter_protocol(
const output_adapter_protocol&) =
default;
13185 output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
13186 output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
13187 output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
13191 template<typename CharType>
13192 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
13195 template<typename CharType>
13196 class output_vector_adapter : public output_adapter_protocol<CharType>
13199 explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
13203 void write_character(CharType c)
override
13208 JSON_HEDLEY_NON_NULL(2)
13209 void write_characters(const CharType* s, std::
size_t length)
override
13211 std::copy(s, s + length, std::back_inserter(v));
13215 std::vector<CharType>& v;
13220 template<
typename CharType>
13221 class output_stream_adapter :
public output_adapter_protocol<CharType>
13224 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
13228 void write_character(CharType c)
override
13233 JSON_HEDLEY_NON_NULL(2)
13234 void write_characters(const CharType* s, std::
size_t length)
override
13236 stream.write(s,
static_cast<std::streamsize
>(length));
13240 std::basic_ostream<CharType>& stream;
13245 template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13246 class output_string_adapter :
public output_adapter_protocol<CharType>
13249 explicit output_string_adapter(StringType& s) noexcept
13253 void write_character(CharType c)
override
13258 JSON_HEDLEY_NON_NULL(2)
13259 void write_characters(const CharType* s, std::
size_t length)
override
13261 str.append(s, length);
13268 template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
13269 class output_adapter
13272 output_adapter(std::vector<CharType>& vec)
13273 : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
13276 output_adapter(std::basic_ostream<CharType>& s)
13277 : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
13280 output_adapter(StringType& s)
13281 : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
13283 operator output_adapter_t<CharType>()
13289 output_adapter_t<CharType> oa =
nullptr;
13306 template<
typename BasicJsonType,
typename CharType>
13307 class binary_writer
13309 using string_t =
typename BasicJsonType::string_t;
13310 using binary_t =
typename BasicJsonType::binary_t;
13311 using number_float_t =
typename BasicJsonType::number_float_t;
13319 explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
13328 void write_bson(
const BasicJsonType& j)
13332 case value_t::object:
13334 write_bson_object(*j.m_value.object);
13340 JSON_THROW(type_error::create(317,
"to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));;
13348 void write_cbor(
const BasicJsonType& j)
13352 case value_t::null:
13354 oa->write_character(to_char_type(0xF6));
13358 case value_t::boolean:
13360 oa->write_character(j.m_value.boolean
13361 ? to_char_type(0xF5)
13362 : to_char_type(0xF4));
13366 case value_t::number_integer:
13368 if (j.m_value.number_integer >= 0)
13373 if (j.m_value.number_integer <= 0x17)
13375 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13377 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
13379 oa->write_character(to_char_type(0x18));
13380 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13382 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
13384 oa->write_character(to_char_type(0x19));
13385 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13387 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
13389 oa->write_character(to_char_type(0x1A));
13390 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13394 oa->write_character(to_char_type(0x1B));
13395 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13402 const auto positive_number = -1 - j.m_value.number_integer;
13403 if (j.m_value.number_integer >= -24)
13405 write_number(
static_cast<std::uint8_t
>(0x20 + positive_number));
13407 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
13409 oa->write_character(to_char_type(0x38));
13410 write_number(
static_cast<std::uint8_t
>(positive_number));
13412 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
13414 oa->write_character(to_char_type(0x39));
13415 write_number(
static_cast<std::uint16_t
>(positive_number));
13417 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
13419 oa->write_character(to_char_type(0x3A));
13420 write_number(
static_cast<std::uint32_t
>(positive_number));
13424 oa->write_character(to_char_type(0x3B));
13425 write_number(
static_cast<std::uint64_t
>(positive_number));
13431 case value_t::number_unsigned:
13433 if (j.m_value.number_unsigned <= 0x17)
13435 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13437 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13439 oa->write_character(to_char_type(0x18));
13440 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
13442 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13444 oa->write_character(to_char_type(0x19));
13445 write_number(
static_cast<std::uint16_t
>(j.m_value.number_unsigned));
13447 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13449 oa->write_character(to_char_type(0x1A));
13450 write_number(
static_cast<std::uint32_t
>(j.m_value.number_unsigned));
13454 oa->write_character(to_char_type(0x1B));
13455 write_number(
static_cast<std::uint64_t
>(j.m_value.number_unsigned));
13460 case value_t::number_float:
13462 if (std::isnan(j.m_value.number_float))
13465 oa->write_character(to_char_type(0xF9));
13466 oa->write_character(to_char_type(0x7E));
13467 oa->write_character(to_char_type(0x00));
13469 else if (std::isinf(j.m_value.number_float))
13472 oa->write_character(to_char_type(0xf9));
13473 oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
13474 oa->write_character(to_char_type(0x00));
13478 write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
13483 case value_t::string:
13486 const auto N = j.m_value.string->size();
13489 write_number(
static_cast<std::uint8_t
>(0x60 + N));
13491 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13493 oa->write_character(to_char_type(0x78));
13494 write_number(
static_cast<std::uint8_t
>(N));
13496 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13498 oa->write_character(to_char_type(0x79));
13499 write_number(
static_cast<std::uint16_t
>(N));
13501 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13503 oa->write_character(to_char_type(0x7A));
13504 write_number(
static_cast<std::uint32_t
>(N));
13507 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13509 oa->write_character(to_char_type(0x7B));
13510 write_number(
static_cast<std::uint64_t
>(N));
13515 oa->write_characters(
13516 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13517 j.m_value.string->size());
13521 case value_t::array:
13524 const auto N = j.m_value.array->size();
13527 write_number(
static_cast<std::uint8_t
>(0x80 + N));
13529 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13531 oa->write_character(to_char_type(0x98));
13532 write_number(
static_cast<std::uint8_t
>(N));
13534 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13536 oa->write_character(to_char_type(0x99));
13537 write_number(
static_cast<std::uint16_t
>(N));
13539 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13541 oa->write_character(to_char_type(0x9A));
13542 write_number(
static_cast<std::uint32_t
>(N));
13545 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13547 oa->write_character(to_char_type(0x9B));
13548 write_number(
static_cast<std::uint64_t
>(N));
13553 for (
const auto& el : *j.m_value.array)
13560 case value_t::binary:
13562 if (j.m_value.binary->has_subtype())
13564 write_number(
static_cast<std::uint8_t
>(0xd8));
13565 write_number(j.m_value.binary->subtype());
13569 const auto N = j.m_value.binary->size();
13572 write_number(
static_cast<std::uint8_t
>(0x40 + N));
13574 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13576 oa->write_character(to_char_type(0x58));
13577 write_number(
static_cast<std::uint8_t
>(N));
13579 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13581 oa->write_character(to_char_type(0x59));
13582 write_number(
static_cast<std::uint16_t
>(N));
13584 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13586 oa->write_character(to_char_type(0x5A));
13587 write_number(
static_cast<std::uint32_t
>(N));
13590 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13592 oa->write_character(to_char_type(0x5B));
13593 write_number(
static_cast<std::uint64_t
>(N));
13598 oa->write_characters(
13599 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13605 case value_t::object:
13608 const auto N = j.m_value.object->size();
13611 write_number(
static_cast<std::uint8_t
>(0xA0 + N));
13613 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13615 oa->write_character(to_char_type(0xB8));
13616 write_number(
static_cast<std::uint8_t
>(N));
13618 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13620 oa->write_character(to_char_type(0xB9));
13621 write_number(
static_cast<std::uint16_t
>(N));
13623 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13625 oa->write_character(to_char_type(0xBA));
13626 write_number(
static_cast<std::uint32_t
>(N));
13629 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13631 oa->write_character(to_char_type(0xBB));
13632 write_number(
static_cast<std::uint64_t
>(N));
13637 for (
const auto& el : *j.m_value.object)
13639 write_cbor(el.first);
13640 write_cbor(el.second);
13653 void write_msgpack(
const BasicJsonType& j)
13657 case value_t::null:
13659 oa->write_character(to_char_type(0xC0));
13663 case value_t::boolean:
13665 oa->write_character(j.m_value.boolean
13666 ? to_char_type(0xC3)
13667 : to_char_type(0xC2));
13671 case value_t::number_integer:
13673 if (j.m_value.number_integer >= 0)
13678 if (j.m_value.number_unsigned < 128)
13681 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13683 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13686 oa->write_character(to_char_type(0xCC));
13687 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13689 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13692 oa->write_character(to_char_type(0xCD));
13693 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13695 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13698 oa->write_character(to_char_type(0xCE));
13699 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13701 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13704 oa->write_character(to_char_type(0xCF));
13705 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13710 if (j.m_value.number_integer >= -32)
13713 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
13715 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
13716 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
13719 oa->write_character(to_char_type(0xD0));
13720 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
13722 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
13723 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
13726 oa->write_character(to_char_type(0xD1));
13727 write_number(
static_cast<std::int16_t
>(j.m_value.number_integer));
13729 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
13730 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
13733 oa->write_character(to_char_type(0xD2));
13734 write_number(
static_cast<std::int32_t
>(j.m_value.number_integer));
13736 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
13737 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
13740 oa->write_character(to_char_type(0xD3));
13741 write_number(
static_cast<std::int64_t
>(j.m_value.number_integer));
13747 case value_t::number_unsigned:
13749 if (j.m_value.number_unsigned < 128)
13752 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13754 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13757 oa->write_character(to_char_type(0xCC));
13758 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13760 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13763 oa->write_character(to_char_type(0xCD));
13764 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13766 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13769 oa->write_character(to_char_type(0xCE));
13770 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13772 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13775 oa->write_character(to_char_type(0xCF));
13776 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13781 case value_t::number_float:
13783 write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
13787 case value_t::string:
13790 const auto N = j.m_value.string->size();
13794 write_number(
static_cast<std::uint8_t
>(0xA0 | N));
13796 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13799 oa->write_character(to_char_type(0xD9));
13800 write_number(
static_cast<std::uint8_t
>(N));
13802 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13805 oa->write_character(to_char_type(0xDA));
13806 write_number(
static_cast<std::uint16_t
>(N));
13808 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13811 oa->write_character(to_char_type(0xDB));
13812 write_number(
static_cast<std::uint32_t
>(N));
13816 oa->write_characters(
13817 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13818 j.m_value.string->size());
13822 case value_t::array:
13825 const auto N = j.m_value.array->size();
13829 write_number(
static_cast<std::uint8_t
>(0x90 | N));
13831 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13834 oa->write_character(to_char_type(0xDC));
13835 write_number(
static_cast<std::uint16_t
>(N));
13837 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13840 oa->write_character(to_char_type(0xDD));
13841 write_number(
static_cast<std::uint32_t
>(N));
13845 for (
const auto& el : *j.m_value.array)
13852 case value_t::binary:
13856 const bool use_ext = j.m_value.binary->has_subtype();
13859 const auto N = j.m_value.binary->size();
13860 if (N <= (std::numeric_limits<std::uint8_t>::max)())
13862 std::uint8_t output_type{};
13869 output_type = 0xD4;
13872 output_type = 0xD5;
13875 output_type = 0xD6;
13878 output_type = 0xD7;
13881 output_type = 0xD8;
13884 output_type = 0xC7;
13892 output_type = 0xC4;
13896 oa->write_character(to_char_type(output_type));
13899 write_number(
static_cast<std::uint8_t
>(N));
13902 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13904 std::uint8_t output_type = use_ext
13908 oa->write_character(to_char_type(output_type));
13909 write_number(
static_cast<std::uint16_t
>(N));
13911 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13913 std::uint8_t output_type = use_ext
13917 oa->write_character(to_char_type(output_type));
13918 write_number(
static_cast<std::uint32_t
>(N));
13924 write_number(
static_cast<std::int8_t
>(j.m_value.binary->subtype()));
13928 oa->write_characters(
13929 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13935 case value_t::object:
13938 const auto N = j.m_value.object->size();
13942 write_number(
static_cast<std::uint8_t
>(0x80 | (N & 0xF)));
13944 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13947 oa->write_character(to_char_type(0xDE));
13948 write_number(
static_cast<std::uint16_t
>(N));
13950 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13953 oa->write_character(to_char_type(0xDF));
13954 write_number(
static_cast<std::uint32_t
>(N));
13958 for (
const auto& el : *j.m_value.object)
13960 write_msgpack(el.first);
13961 write_msgpack(el.second);
13977 void write_ubjson(
const BasicJsonType& j,
const bool use_count,
13978 const bool use_type,
const bool add_prefix =
true)
13982 case value_t::null:
13986 oa->write_character(to_char_type(
'Z'));
13991 case value_t::boolean:
13995 oa->write_character(j.m_value.boolean
13996 ? to_char_type(
'T')
13997 : to_char_type(
'F'));
14002 case value_t::number_integer:
14004 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
14008 case value_t::number_unsigned:
14010 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
14014 case value_t::number_float:
14016 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
14020 case value_t::string:
14024 oa->write_character(to_char_type(
'S'));
14026 write_number_with_ubjson_prefix(j.m_value.string->size(),
true);
14027 oa->write_characters(
14028 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
14029 j.m_value.string->size());
14033 case value_t::array:
14037 oa->write_character(to_char_type(
'['));
14040 bool prefix_required =
true;
14041 if (use_type && !j.m_value.array->empty())
14043 JSON_ASSERT(use_count);
14044 const CharType first_prefix = ubjson_prefix(j.front());
14045 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
14046 [
this, first_prefix](
const BasicJsonType & v)
14048 return ubjson_prefix(v) == first_prefix;
14053 prefix_required =
false;
14054 oa->write_character(to_char_type(
'$'));
14055 oa->write_character(first_prefix);
14061 oa->write_character(to_char_type(
'#'));
14062 write_number_with_ubjson_prefix(j.m_value.array->size(),
true);
14065 for (
const auto& el : *j.m_value.array)
14067 write_ubjson(el, use_count, use_type, prefix_required);
14072 oa->write_character(to_char_type(
']'));
14078 case value_t::binary:
14082 oa->write_character(to_char_type(
'['));
14085 if (use_type && !j.m_value.binary->empty())
14087 JSON_ASSERT(use_count);
14088 oa->write_character(to_char_type(
'$'));
14089 oa->write_character(
'U');
14094 oa->write_character(to_char_type(
'#'));
14095 write_number_with_ubjson_prefix(j.m_value.binary->size(),
true);
14100 oa->write_characters(
14101 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
14102 j.m_value.binary->size());
14106 for (
size_t i = 0; i < j.m_value.binary->size(); ++i)
14108 oa->write_character(to_char_type(
'U'));
14109 oa->write_character(j.m_value.binary->data()[i]);
14115 oa->write_character(to_char_type(
']'));
14121 case value_t::object:
14125 oa->write_character(to_char_type(
'{'));
14128 bool prefix_required =
true;
14129 if (use_type && !j.m_value.object->empty())
14131 JSON_ASSERT(use_count);
14132 const CharType first_prefix = ubjson_prefix(j.front());
14133 const bool same_prefix = std::all_of(j.begin(), j.end(),
14134 [
this, first_prefix](
const BasicJsonType & v)
14136 return ubjson_prefix(v) == first_prefix;
14141 prefix_required =
false;
14142 oa->write_character(to_char_type(
'$'));
14143 oa->write_character(first_prefix);
14149 oa->write_character(to_char_type(
'#'));
14150 write_number_with_ubjson_prefix(j.m_value.object->size(),
true);
14153 for (
const auto& el : *j.m_value.object)
14155 write_number_with_ubjson_prefix(el.first.size(),
true);
14156 oa->write_characters(
14157 reinterpret_cast<const CharType*
>(el.first.c_str()),
14159 write_ubjson(el.second, use_count, use_type, prefix_required);
14164 oa->write_character(to_char_type(
'}'));
14184 static std::size_t calc_bson_entry_header_size(
const string_t& name,
const BasicJsonType& j)
14186 const auto it = name.find(
static_cast<typename string_t::value_type
>(0));
14187 if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
14189 JSON_THROW(out_of_range::create(409,
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) +
")", j));
14192 return 1ul + name.size() + 1u;
14198 void write_bson_entry_header(
const string_t& name,
14199 const std::uint8_t element_type)
14201 oa->write_character(to_char_type(element_type));
14202 oa->write_characters(
14203 reinterpret_cast<const CharType*
>(name.c_str()),
14210 void write_bson_boolean(
const string_t& name,
14213 write_bson_entry_header(name, 0x08);
14214 oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
14220 void write_bson_double(
const string_t& name,
14221 const double value)
14223 write_bson_entry_header(name, 0x01);
14224 write_number<double, true>(value);
14230 static std::size_t calc_bson_string_size(
const string_t& value)
14232 return sizeof(std::int32_t) + value.size() + 1ul;
14238 void write_bson_string(
const string_t& name,
14239 const string_t& value)
14241 write_bson_entry_header(name, 0x02);
14243 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size() + 1ul));
14244 oa->write_characters(
14245 reinterpret_cast<const CharType*
>(value.c_str()),
14252 void write_bson_null(
const string_t& name)
14254 write_bson_entry_header(name, 0x0A);
14260 static std::size_t calc_bson_integer_size(
const std::int64_t value)
14262 return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
14263 ?
sizeof(std::int32_t)
14264 :
sizeof(std::int64_t);
14270 void write_bson_integer(
const string_t& name,
14271 const std::int64_t value)
14273 if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
14275 write_bson_entry_header(name, 0x10);
14276 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value));
14280 write_bson_entry_header(name, 0x12);
14281 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(value));
14288 static constexpr std::size_t calc_bson_unsigned_size(
const std::uint64_t value) noexcept
14290 return (value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14291 ?
sizeof(std::int32_t)
14292 :
sizeof(std::int64_t);
14298 void write_bson_unsigned(
const string_t& name,
14299 const BasicJsonType& j)
14301 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14303 write_bson_entry_header(name, 0x10 );
14304 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(j.m_value.number_unsigned));
14306 else if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14308 write_bson_entry_header(name, 0x12 );
14309 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(j.m_value.number_unsigned));
14313 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));
14320 void write_bson_object_entry(
const string_t& name,
14321 const typename BasicJsonType::object_t& value)
14323 write_bson_entry_header(name, 0x03);
14324 write_bson_object(value);
14330 static std::size_t calc_bson_array_size(
const typename BasicJsonType::array_t& value)
14332 std::size_t array_index = 0ul;
14334 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)
14336 return result + calc_bson_element_size(std::to_string(array_index++), el);
14339 return sizeof(std::int32_t) + embedded_document_size + 1ul;
14345 static std::size_t calc_bson_binary_size(
const typename BasicJsonType::binary_t& value)
14347 return sizeof(std::int32_t) + value.size() + 1ul;
14353 void write_bson_array(
const string_t& name,
14354 const typename BasicJsonType::array_t& value)
14356 write_bson_entry_header(name, 0x04);
14357 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_array_size(value)));
14359 std::size_t array_index = 0ul;
14361 for (
const auto& el : value)
14363 write_bson_element(std::to_string(array_index++), el);
14366 oa->write_character(to_char_type(0x00));
14372 void write_bson_binary(
const string_t& name,
14373 const binary_t& value)
14375 write_bson_entry_header(name, 0x05);
14377 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size()));
14378 write_number(value.has_subtype() ? value.subtype() : std::uint8_t(0x00));
14380 oa->write_characters(
reinterpret_cast<const CharType*
>(value.data()), value.size());
14387 static std::size_t calc_bson_element_size(
const string_t& name,
14388 const BasicJsonType& j)
14390 const auto header_size = calc_bson_entry_header_size(name, j);
14393 case value_t::object:
14394 return header_size + calc_bson_object_size(*j.m_value.object);
14396 case value_t::array:
14397 return header_size + calc_bson_array_size(*j.m_value.array);
14399 case value_t::binary:
14400 return header_size + calc_bson_binary_size(*j.m_value.binary);
14402 case value_t::boolean:
14403 return header_size + 1ul;
14405 case value_t::number_float:
14406 return header_size + 8ul;
14408 case value_t::number_integer:
14409 return header_size + calc_bson_integer_size(j.m_value.number_integer);
14411 case value_t::number_unsigned:
14412 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
14414 case value_t::string:
14415 return header_size + calc_bson_string_size(*j.m_value.string);
14417 case value_t::null:
14418 return header_size + 0ul;
14422 JSON_ASSERT(
false);
14434 void write_bson_element(
const string_t& name,
14435 const BasicJsonType& j)
14439 case value_t::object:
14440 return write_bson_object_entry(name, *j.m_value.object);
14442 case value_t::array:
14443 return write_bson_array(name, *j.m_value.array);
14445 case value_t::binary:
14446 return write_bson_binary(name, *j.m_value.binary);
14448 case value_t::boolean:
14449 return write_bson_boolean(name, j.m_value.boolean);
14451 case value_t::number_float:
14452 return write_bson_double(name, j.m_value.number_float);
14454 case value_t::number_integer:
14455 return write_bson_integer(name, j.m_value.number_integer);
14457 case value_t::number_unsigned:
14458 return write_bson_unsigned(name, j);
14460 case value_t::string:
14461 return write_bson_string(name, *j.m_value.string);
14463 case value_t::null:
14464 return write_bson_null(name);
14468 JSON_ASSERT(
false);
14480 static std::size_t calc_bson_object_size(
const typename BasicJsonType::object_t& value)
14482 std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
14483 [](
size_t result,
const typename BasicJsonType::object_t::value_type & el)
14485 return result += calc_bson_element_size(el.first, el.second);
14488 return sizeof(std::int32_t) + document_size + 1ul;
14495 void write_bson_object(
const typename BasicJsonType::object_t& value)
14497 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_object_size(value)));
14499 for (
const auto& el : value)
14501 write_bson_element(el.first, el.second);
14504 oa->write_character(to_char_type(0x00));
14511 static constexpr CharType get_cbor_float_prefix(
float )
14513 return to_char_type(0xFA);
14516 static constexpr CharType get_cbor_float_prefix(
double )
14518 return to_char_type(0xFB);
14525 static constexpr CharType get_msgpack_float_prefix(
float )
14527 return to_char_type(0xCA);
14530 static constexpr CharType get_msgpack_float_prefix(
double )
14532 return to_char_type(0xCB);
14540 template<
typename NumberType,
typename std::enable_if<
14541 std::is_floating_point<NumberType>::value,
int>::type = 0>
14542 void write_number_with_ubjson_prefix(
const NumberType n,
14543 const bool add_prefix)
14547 oa->write_character(get_ubjson_float_prefix(n));
14553 template<
typename NumberType,
typename std::enable_if<
14554 std::is_unsigned<NumberType>::value,
int>::type = 0>
14555 void write_number_with_ubjson_prefix(
const NumberType n,
14556 const bool add_prefix)
14558 if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14562 oa->write_character(to_char_type(
'i'));
14564 write_number(
static_cast<std::uint8_t
>(n));
14566 else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14570 oa->write_character(to_char_type(
'U'));
14572 write_number(
static_cast<std::uint8_t
>(n));
14574 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14578 oa->write_character(to_char_type(
'I'));
14580 write_number(
static_cast<std::int16_t
>(n));
14582 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14586 oa->write_character(to_char_type(
'l'));
14588 write_number(
static_cast<std::int32_t
>(n));
14590 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14594 oa->write_character(to_char_type(
'L'));
14596 write_number(
static_cast<std::int64_t
>(n));
14602 oa->write_character(to_char_type(
'H'));
14605 const auto number = BasicJsonType(n).dump();
14606 write_number_with_ubjson_prefix(number.size(),
true);
14607 for (std::size_t i = 0; i < number.size(); ++i)
14609 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14615 template <
typename NumberType,
typename std::enable_if <
14616 std::is_signed<NumberType>::value&&
14617 !std::is_floating_point<NumberType>::value,
int >::type = 0 >
14618 void write_number_with_ubjson_prefix(
const NumberType n,
14619 const bool add_prefix)
14621 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14625 oa->write_character(to_char_type(
'i'));
14627 write_number(
static_cast<std::int8_t
>(n));
14629 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)()))
14633 oa->write_character(to_char_type(
'U'));
14635 write_number(
static_cast<std::uint8_t
>(n));
14637 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14641 oa->write_character(to_char_type(
'I'));
14643 write_number(
static_cast<std::int16_t
>(n));
14645 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14649 oa->write_character(to_char_type(
'l'));
14651 write_number(
static_cast<std::int32_t
>(n));
14653 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14657 oa->write_character(to_char_type(
'L'));
14659 write_number(
static_cast<std::int64_t
>(n));
14666 oa->write_character(to_char_type(
'H'));
14669 const auto number = BasicJsonType(n).dump();
14670 write_number_with_ubjson_prefix(number.size(),
true);
14671 for (std::size_t i = 0; i < number.size(); ++i)
14673 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14682 CharType ubjson_prefix(
const BasicJsonType& j)
const noexcept
14686 case value_t::null:
14689 case value_t::boolean:
14690 return j.m_value.boolean ?
'T' :
'F';
14692 case value_t::number_integer:
14694 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)())
14698 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)())
14702 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)())
14706 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)())
14710 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)())
14718 case value_t::number_unsigned:
14720 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14724 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::uint8_t>::max)()))
14728 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14732 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14736 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14744 case value_t::number_float:
14745 return get_ubjson_float_prefix(j.m_value.number_float);
14747 case value_t::string:
14750 case value_t::array:
14751 case value_t::binary:
14754 case value_t::object:
14762 static constexpr CharType get_ubjson_float_prefix(
float )
14767 static constexpr CharType get_ubjson_float_prefix(
double )
14787 template<
typename NumberType,
bool OutputIsLittleEndian = false>
14788 void write_number(
const NumberType n)
14791 std::array<CharType,
sizeof(NumberType)> vec{};
14792 std::memcpy(vec.data(), &n,
sizeof(NumberType));
14795 if (is_little_endian != OutputIsLittleEndian)
14798 std::reverse(vec.begin(), vec.end());
14801 oa->write_characters(vec.data(),
sizeof(NumberType));
14804 void write_compact_float(
const number_float_t n, detail::input_format_t format)
14806 if (
static_cast<double>(n) >=
static_cast<double>(std::numeric_limits<float>::lowest()) &&
14807 static_cast<double>(n) <=
static_cast<double>((std::numeric_limits<float>::max)()) &&
14808 static_cast<double>(
static_cast<float>(n)) ==
static_cast<double>(n))
14810 oa->write_character(format == detail::input_format_t::cbor
14811 ? get_cbor_float_prefix(
static_cast<float>(n))
14812 : get_msgpack_float_prefix(
static_cast<float>(n)));
14813 write_number(
static_cast<float>(n));
14817 oa->write_character(format == detail::input_format_t::cbor
14818 ? get_cbor_float_prefix(n)
14819 : get_msgpack_float_prefix(n));
14829 template <
typename C = CharType,
14830 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * =
nullptr >
14831 static constexpr CharType to_char_type(std::uint8_t x) noexcept
14833 return *
reinterpret_cast<char*
>(&x);
14836 template <
typename C = CharType,
14837 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * =
nullptr >
14838 static CharType to_char_type(std::uint8_t x) noexcept
14840 static_assert(
sizeof(std::uint8_t) ==
sizeof(CharType),
"size of CharType must be equal to std::uint8_t");
14841 static_assert(std::is_trivial<CharType>::value,
"CharType must be trivial");
14843 std::memcpy(&result, &x,
sizeof(x));
14847 template<
typename C = CharType,
14848 enable_if_t<std::is_unsigned<C>::value>* =
nullptr>
14849 static constexpr CharType to_char_type(std::uint8_t x) noexcept
14854 template <
typename InputCharType,
typename C = CharType,
14856 std::is_signed<C>::value &&
14857 std::is_signed<char>::value &&
14858 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
14860 static constexpr CharType to_char_type(InputCharType x) noexcept
14867 const bool is_little_endian = little_endianess();
14870 output_adapter_t<CharType> oa =
nullptr;
14880 #include <algorithm>
14889 #include <type_traits>
14900 #include <type_traits>
14929 namespace dtoa_impl
14932 template<
typename Target,
typename Source>
14933 Target reinterpret_bits(
const Source source)
14935 static_assert(
sizeof(Target) ==
sizeof(Source),
"size mismatch");
14938 std::memcpy(&target, &source,
sizeof(Source));
14944 static constexpr
int kPrecision = 64;
14946 std::uint64_t f = 0;
14949 constexpr diyfp(std::uint64_t f_,
int e_) noexcept : f(f_), e(e_) {}
14955 static diyfp sub(
const diyfp& x,
const diyfp& y) noexcept
14957 JSON_ASSERT(x.e == y.e);
14958 JSON_ASSERT(x.f >= y.f);
14960 return {x.f - y.f, x.e};
14967 static diyfp mul(
const diyfp& x,
const diyfp& y) noexcept
14969 static_assert(kPrecision == 64,
"internal error");
14994 const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
14995 const std::uint64_t u_hi = x.f >> 32u;
14996 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
14997 const std::uint64_t v_hi = y.f >> 32u;
14999 const std::uint64_t p0 = u_lo * v_lo;
15000 const std::uint64_t p1 = u_lo * v_hi;
15001 const std::uint64_t p2 = u_hi * v_lo;
15002 const std::uint64_t p3 = u_hi * v_hi;
15004 const std::uint64_t p0_hi = p0 >> 32u;
15005 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
15006 const std::uint64_t p1_hi = p1 >> 32u;
15007 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
15008 const std::uint64_t p2_hi = p2 >> 32u;
15010 std::uint64_t Q = p0_hi + p1_lo + p2_lo;
15021 Q += std::uint64_t{1} << (64u - 32u - 1u);
15023 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
15025 return {h, x.e + y.e + 64};
15032 static diyfp normalize(diyfp x) noexcept
15034 JSON_ASSERT(x.f != 0);
15036 while ((x.f >> 63u) == 0)
15049 static diyfp normalize_to(
const diyfp& x,
const int target_exponent) noexcept
15051 const int delta = x.e - target_exponent;
15053 JSON_ASSERT(delta >= 0);
15054 JSON_ASSERT(((x.f << delta) >> delta) == x.f);
15056 return {x.f << delta, target_exponent};
15073 template<
typename FloatType>
15074 boundaries compute_boundaries(FloatType value)
15076 JSON_ASSERT(std::isfinite(value));
15077 JSON_ASSERT(value > 0);
15086 static_assert(std::numeric_limits<FloatType>::is_iec559,
15087 "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
15089 constexpr
int kPrecision = std::numeric_limits<FloatType>::digits;
15090 constexpr
int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
15091 constexpr
int kMinExp = 1 - kBias;
15092 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1);
15094 using bits_type =
typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
15096 const auto bits =
static_cast<std::uint64_t
>(reinterpret_bits<bits_type>(value));
15097 const std::uint64_t E = bits >> (kPrecision - 1);
15098 const std::uint64_t F = bits & (kHiddenBit - 1);
15100 const bool is_denormal = E == 0;
15101 const diyfp v = is_denormal
15102 ? diyfp(F, kMinExp)
15103 : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
15126 const bool lower_boundary_is_closer = F == 0 && E > 1;
15127 const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
15128 const diyfp m_minus = lower_boundary_is_closer
15129 ? diyfp(4 * v.f - 1, v.e - 2)
15130 : diyfp(2 * v.f - 1, v.e - 1);
15133 const diyfp w_plus = diyfp::normalize(m_plus);
15136 const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
15138 return {diyfp::normalize(v), w_minus, w_plus};
15196 constexpr
int kAlpha = -60;
15197 constexpr
int kGamma = -32;
15199 struct cached_power
15213 inline cached_power get_cached_power_for_binary_exponent(
int e)
15265 constexpr
int kCachedPowersMinDecExp = -300;
15266 constexpr
int kCachedPowersDecStep = 8;
15268 static constexpr std::array<cached_power, 79> kCachedPowers =
15271 { 0xAB70FE17C79AC6CA, -1060, -300 },
15272 { 0xFF77B1FCBEBCDC4F, -1034, -292 },
15273 { 0xBE5691EF416BD60C, -1007, -284 },
15274 { 0x8DD01FAD907FFC3C, -980, -276 },
15275 { 0xD3515C2831559A83, -954, -268 },
15276 { 0x9D71AC8FADA6C9B5, -927, -260 },
15277 { 0xEA9C227723EE8BCB, -901, -252 },
15278 { 0xAECC49914078536D, -874, -244 },
15279 { 0x823C12795DB6CE57, -847, -236 },
15280 { 0xC21094364DFB5637, -821, -228 },
15281 { 0x9096EA6F3848984F, -794, -220 },
15282 { 0xD77485CB25823AC7, -768, -212 },
15283 { 0xA086CFCD97BF97F4, -741, -204 },
15284 { 0xEF340A98172AACE5, -715, -196 },
15285 { 0xB23867FB2A35B28E, -688, -188 },
15286 { 0x84C8D4DFD2C63F3B, -661, -180 },
15287 { 0xC5DD44271AD3CDBA, -635, -172 },
15288 { 0x936B9FCEBB25C996, -608, -164 },
15289 { 0xDBAC6C247D62A584, -582, -156 },
15290 { 0xA3AB66580D5FDAF6, -555, -148 },
15291 { 0xF3E2F893DEC3F126, -529, -140 },
15292 { 0xB5B5ADA8AAFF80B8, -502, -132 },
15293 { 0x87625F056C7C4A8B, -475, -124 },
15294 { 0xC9BCFF6034C13053, -449, -116 },
15295 { 0x964E858C91BA2655, -422, -108 },
15296 { 0xDFF9772470297EBD, -396, -100 },
15297 { 0xA6DFBD9FB8E5B88F, -369, -92 },
15298 { 0xF8A95FCF88747D94, -343, -84 },
15299 { 0xB94470938FA89BCF, -316, -76 },
15300 { 0x8A08F0F8BF0F156B, -289, -68 },
15301 { 0xCDB02555653131B6, -263, -60 },
15302 { 0x993FE2C6D07B7FAC, -236, -52 },
15303 { 0xE45C10C42A2B3B06, -210, -44 },
15304 { 0xAA242499697392D3, -183, -36 },
15305 { 0xFD87B5F28300CA0E, -157, -28 },
15306 { 0xBCE5086492111AEB, -130, -20 },
15307 { 0x8CBCCC096F5088CC, -103, -12 },
15308 { 0xD1B71758E219652C, -77, -4 },
15309 { 0x9C40000000000000, -50, 4 },
15310 { 0xE8D4A51000000000, -24, 12 },
15311 { 0xAD78EBC5AC620000, 3, 20 },
15312 { 0x813F3978F8940984, 30, 28 },
15313 { 0xC097CE7BC90715B3, 56, 36 },
15314 { 0x8F7E32CE7BEA5C70, 83, 44 },
15315 { 0xD5D238A4ABE98068, 109, 52 },
15316 { 0x9F4F2726179A2245, 136, 60 },
15317 { 0xED63A231D4C4FB27, 162, 68 },
15318 { 0xB0DE65388CC8ADA8, 189, 76 },
15319 { 0x83C7088E1AAB65DB, 216, 84 },
15320 { 0xC45D1DF942711D9A, 242, 92 },
15321 { 0x924D692CA61BE758, 269, 100 },
15322 { 0xDA01EE641A708DEA, 295, 108 },
15323 { 0xA26DA3999AEF774A, 322, 116 },
15324 { 0xF209787BB47D6B85, 348, 124 },
15325 { 0xB454E4A179DD1877, 375, 132 },
15326 { 0x865B86925B9BC5C2, 402, 140 },
15327 { 0xC83553C5C8965D3D, 428, 148 },
15328 { 0x952AB45CFA97A0B3, 455, 156 },
15329 { 0xDE469FBD99A05FE3, 481, 164 },
15330 { 0xA59BC234DB398C25, 508, 172 },
15331 { 0xF6C69A72A3989F5C, 534, 180 },
15332 { 0xB7DCBF5354E9BECE, 561, 188 },
15333 { 0x88FCF317F22241E2, 588, 196 },
15334 { 0xCC20CE9BD35C78A5, 614, 204 },
15335 { 0x98165AF37B2153DF, 641, 212 },
15336 { 0xE2A0B5DC971F303A, 667, 220 },
15337 { 0xA8D9D1535CE3B396, 694, 228 },
15338 { 0xFB9B7CD9A4A7443C, 720, 236 },
15339 { 0xBB764C4CA7A44410, 747, 244 },
15340 { 0x8BAB8EEFB6409C1A, 774, 252 },
15341 { 0xD01FEF10A657842C, 800, 260 },
15342 { 0x9B10A4E5E9913129, 827, 268 },
15343 { 0xE7109BFBA19C0C9D, 853, 276 },
15344 { 0xAC2820D9623BF429, 880, 284 },
15345 { 0x80444B5E7AA7CF85, 907, 292 },
15346 { 0xBF21E44003ACDD2D, 933, 300 },
15347 { 0x8E679C2F5E44FF8F, 960, 308 },
15348 { 0xD433179D9C8CB841, 986, 316 },
15349 { 0x9E19DB92B4E31BA9, 1013, 324 },
15357 JSON_ASSERT(e >= -1500);
15358 JSON_ASSERT(e <= 1500);
15359 const int f = kAlpha - e - 1;
15360 const int k = (f * 78913) / (1 << 18) +
static_cast<int>(f > 0);
15362 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
15363 JSON_ASSERT(index >= 0);
15364 JSON_ASSERT(
static_cast<std::size_t
>(index) < kCachedPowers.size());
15366 const cached_power cached = kCachedPowers[
static_cast<std::size_t
>(index)];
15367 JSON_ASSERT(kAlpha <= cached.e + e + 64);
15368 JSON_ASSERT(kGamma >= cached.e + e + 64);
15377 inline int find_largest_pow10(
const std::uint32_t n, std::uint32_t& pow10)
15380 if (n >= 1000000000)
15382 pow10 = 1000000000;
15386 if (n >= 100000000)
15431 inline void grisu2_round(
char* buf,
int len, std::uint64_t dist, std::uint64_t delta,
15432 std::uint64_t rest, std::uint64_t ten_k)
15434 JSON_ASSERT(len >= 1);
15435 JSON_ASSERT(dist <= delta);
15436 JSON_ASSERT(rest <= delta);
15437 JSON_ASSERT(ten_k > 0);
15459 && delta - rest >= ten_k
15460 && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
15462 JSON_ASSERT(buf[len - 1] !=
'0');
15472 inline void grisu2_digit_gen(
char* buffer,
int& length,
int& decimal_exponent,
15473 diyfp M_minus, diyfp w, diyfp M_plus)
15475 static_assert(kAlpha >= -60,
"internal error");
15476 static_assert(kGamma <= -32,
"internal error");
15490 JSON_ASSERT(M_plus.e >= kAlpha);
15491 JSON_ASSERT(M_plus.e <= kGamma);
15493 std::uint64_t delta = diyfp::sub(M_plus, M_minus).f;
15494 std::uint64_t dist = diyfp::sub(M_plus, w ).f;
15503 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
15505 auto p1 =
static_cast<std::uint32_t
>(M_plus.f >> -one.e);
15506 std::uint64_t p2 = M_plus.f & (one.f - 1);
15512 JSON_ASSERT(p1 > 0);
15514 std::uint32_t pow10{};
15515 const int k = find_largest_pow10(p1, pow10);
15542 const std::uint32_t d = p1 / pow10;
15543 const std::uint32_t r = p1 % pow10;
15548 JSON_ASSERT(d <= 9);
15549 buffer[length++] =
static_cast<char>(
'0' + d);
15568 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15573 decimal_exponent += n;
15584 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15585 grisu2_round(buffer, length, dist, delta, rest, ten_n);
15635 JSON_ASSERT(p2 > delta);
15646 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15648 const std::uint64_t d = p2 >> -one.e;
15649 const std::uint64_t r = p2 & (one.f - 1);
15655 JSON_ASSERT(d <= 9);
15656 buffer[length++] =
static_cast<char>(
'0' + d);
15681 decimal_exponent -= m;
15689 const std::uint64_t ten_m = one.f;
15690 grisu2_round(buffer, length, dist, delta, p2, ten_m);
15712 JSON_HEDLEY_NON_NULL(1)
15713 inline
void grisu2(
char* buf,
int& len,
int& decimal_exponent,
15714 diyfp m_minus, diyfp v, diyfp m_plus)
15716 JSON_ASSERT(m_plus.e == m_minus.e);
15717 JSON_ASSERT(m_plus.e == v.e);
15728 const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
15730 const diyfp c_minus_k(cached.f, cached.e);
15733 const diyfp w = diyfp::mul(v, c_minus_k);
15734 const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
15735 const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
15758 const diyfp M_minus(w_minus.f + 1, w_minus.e);
15759 const diyfp M_plus (w_plus.f - 1, w_plus.e );
15761 decimal_exponent = -cached.k;
15763 grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
15771 template<
typename FloatType>
15772 JSON_HEDLEY_NON_NULL(1)
15773 void grisu2(
char* buf,
int& len,
int& decimal_exponent, FloatType value)
15775 static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
15776 "internal error: not enough precision");
15778 JSON_ASSERT(std::isfinite(value));
15779 JSON_ASSERT(value > 0);
15798 const boundaries w = compute_boundaries(
static_cast<double>(value));
15800 const boundaries w = compute_boundaries(value);
15803 grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
15811 JSON_HEDLEY_NON_NULL(1)
15813 inline
char* append_exponent(
char* buf,
int e)
15815 JSON_ASSERT(e > -1000);
15816 JSON_ASSERT(e < 1000);
15828 auto k =
static_cast<std::uint32_t
>(e);
15834 *buf++ =
static_cast<char>(
'0' + k);
15838 *buf++ =
static_cast<char>(
'0' + k / 10);
15840 *buf++ =
static_cast<char>(
'0' + k);
15844 *buf++ =
static_cast<char>(
'0' + k / 100);
15846 *buf++ =
static_cast<char>(
'0' + k / 10);
15848 *buf++ =
static_cast<char>(
'0' + k);
15863 JSON_HEDLEY_NON_NULL(1)
15865 inline
char* format_buffer(
char* buf,
int len,
int decimal_exponent,
15866 int min_exp,
int max_exp)
15868 JSON_ASSERT(min_exp < 0);
15869 JSON_ASSERT(max_exp > 0);
15872 const int n = len + decimal_exponent;
15878 if (k <= n && n <= max_exp)
15883 std::memset(buf + k,
'0',
static_cast<size_t>(n) -
static_cast<size_t>(k));
15887 return buf + (
static_cast<size_t>(n) + 2);
15890 if (0 < n && n <= max_exp)
15895 JSON_ASSERT(k > n);
15897 std::memmove(buf + (
static_cast<size_t>(n) + 1), buf + n,
static_cast<size_t>(k) -
static_cast<size_t>(n));
15899 return buf + (
static_cast<size_t>(k) + 1U);
15902 if (min_exp < n && n <= 0)
15907 std::memmove(buf + (2 +
static_cast<size_t>(-n)), buf,
static_cast<size_t>(k));
15910 std::memset(buf + 2,
'0',
static_cast<size_t>(-n));
15911 return buf + (2U +
static_cast<size_t>(-n) +
static_cast<size_t>(k));
15926 std::memmove(buf + 2, buf + 1,
static_cast<size_t>(k) - 1);
15928 buf += 1 +
static_cast<size_t>(k);
15932 return append_exponent(buf, n - 1);
15947 template<
typename FloatType>
15948 JSON_HEDLEY_NON_NULL(1, 2)
15950 char* to_chars(
char* first, const
char* last, FloatType value)
15952 static_cast<void>(last);
15953 JSON_ASSERT(std::isfinite(value));
15956 if (std::signbit(value))
15971 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
15978 int decimal_exponent = 0;
15979 dtoa_impl::grisu2(first, len, decimal_exponent, value);
15981 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
15984 constexpr
int kMinExp = -4;
15986 constexpr
int kMaxExp = std::numeric_limits<FloatType>::digits10;
15988 JSON_ASSERT(last - first >= kMaxExp + 2);
15989 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
15990 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
15992 return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
16020 enum class error_handler_t
16027 template<
typename BasicJsonType>
16030 using string_t =
typename BasicJsonType::string_t;
16031 using number_float_t =
typename BasicJsonType::number_float_t;
16032 using number_integer_t =
typename BasicJsonType::number_integer_t;
16033 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
16034 using binary_char_t =
typename BasicJsonType::binary_t::value_type;
16035 static constexpr std::uint8_t UTF8_ACCEPT = 0;
16036 static constexpr std::uint8_t UTF8_REJECT = 1;
16044 serializer(output_adapter_t<char> s,
const char ichar,
16045 error_handler_t error_handler_ = error_handler_t::strict)
16047 , loc(std::localeconv())
16048 , thousands_sep(loc->thousands_sep == nullptr ?
'\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
16049 , decimal_point(loc->decimal_point == nullptr ?
'\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
16050 , indent_char(ichar)
16051 , indent_string(512, indent_char)
16052 , error_handler(error_handler_)
16056 serializer(
const serializer&) =
delete;
16057 serializer& operator=(
const serializer&) =
delete;
16058 serializer(serializer&&) =
delete;
16059 serializer& operator=(serializer&&) =
delete;
16060 ~serializer() =
default;
16084 void dump(
const BasicJsonType& val,
16085 const bool pretty_print,
16086 const bool ensure_ascii,
16087 const unsigned int indent_step,
16088 const unsigned int current_indent = 0)
16090 switch (val.m_type)
16092 case value_t::object:
16094 if (val.m_value.object->empty())
16096 o->write_characters(
"{}", 2);
16102 o->write_characters(
"{\n", 2);
16105 const auto new_indent = current_indent + indent_step;
16106 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16108 indent_string.resize(indent_string.size() * 2,
' ');
16112 auto i = val.m_value.object->cbegin();
16113 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16115 o->write_characters(indent_string.c_str(), new_indent);
16116 o->write_character(
'\"');
16117 dump_escaped(i->first, ensure_ascii);
16118 o->write_characters(
"\": ", 3);
16119 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
16120 o->write_characters(
",\n", 2);
16124 JSON_ASSERT(i != val.m_value.object->cend());
16125 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16126 o->write_characters(indent_string.c_str(), new_indent);
16127 o->write_character(
'\"');
16128 dump_escaped(i->first, ensure_ascii);
16129 o->write_characters(
"\": ", 3);
16130 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
16132 o->write_character(
'\n');
16133 o->write_characters(indent_string.c_str(), current_indent);
16134 o->write_character(
'}');
16138 o->write_character(
'{');
16141 auto i = val.m_value.object->cbegin();
16142 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16144 o->write_character(
'\"');
16145 dump_escaped(i->first, ensure_ascii);
16146 o->write_characters(
"\":", 2);
16147 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
16148 o->write_character(
',');
16152 JSON_ASSERT(i != val.m_value.object->cend());
16153 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16154 o->write_character(
'\"');
16155 dump_escaped(i->first, ensure_ascii);
16156 o->write_characters(
"\":", 2);
16157 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
16159 o->write_character(
'}');
16165 case value_t::array:
16167 if (val.m_value.array->empty())
16169 o->write_characters(
"[]", 2);
16175 o->write_characters(
"[\n", 2);
16178 const auto new_indent = current_indent + indent_step;
16179 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16181 indent_string.resize(indent_string.size() * 2,
' ');
16185 for (
auto i = val.m_value.array->cbegin();
16186 i != val.m_value.array->cend() - 1; ++i)
16188 o->write_characters(indent_string.c_str(), new_indent);
16189 dump(*i,
true, ensure_ascii, indent_step, new_indent);
16190 o->write_characters(
",\n", 2);
16194 JSON_ASSERT(!val.m_value.array->empty());
16195 o->write_characters(indent_string.c_str(), new_indent);
16196 dump(val.m_value.array->back(),
true, ensure_ascii, indent_step, new_indent);
16198 o->write_character(
'\n');
16199 o->write_characters(indent_string.c_str(), current_indent);
16200 o->write_character(
']');
16204 o->write_character(
'[');
16207 for (
auto i = val.m_value.array->cbegin();
16208 i != val.m_value.array->cend() - 1; ++i)
16210 dump(*i,
false, ensure_ascii, indent_step, current_indent);
16211 o->write_character(
',');
16215 JSON_ASSERT(!val.m_value.array->empty());
16216 dump(val.m_value.array->back(),
false, ensure_ascii, indent_step, current_indent);
16218 o->write_character(
']');
16224 case value_t::string:
16226 o->write_character(
'\"');
16227 dump_escaped(*val.m_value.string, ensure_ascii);
16228 o->write_character(
'\"');
16232 case value_t::binary:
16236 o->write_characters(
"{\n", 2);
16239 const auto new_indent = current_indent + indent_step;
16240 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16242 indent_string.resize(indent_string.size() * 2,
' ');
16245 o->write_characters(indent_string.c_str(), new_indent);
16247 o->write_characters(
"\"bytes\": [", 10);
16249 if (!val.m_value.binary->empty())
16251 for (
auto i = val.m_value.binary->cbegin();
16252 i != val.m_value.binary->cend() - 1; ++i)
16255 o->write_characters(
", ", 2);
16257 dump_integer(val.m_value.binary->back());
16260 o->write_characters(
"],\n", 3);
16261 o->write_characters(indent_string.c_str(), new_indent);
16263 o->write_characters(
"\"subtype\": ", 11);
16264 if (val.m_value.binary->has_subtype())
16266 dump_integer(val.m_value.binary->subtype());
16270 o->write_characters(
"null", 4);
16272 o->write_character(
'\n');
16273 o->write_characters(indent_string.c_str(), current_indent);
16274 o->write_character(
'}');
16278 o->write_characters(
"{\"bytes\":[", 10);
16280 if (!val.m_value.binary->empty())
16282 for (
auto i = val.m_value.binary->cbegin();
16283 i != val.m_value.binary->cend() - 1; ++i)
16286 o->write_character(
',');
16288 dump_integer(val.m_value.binary->back());
16291 o->write_characters(
"],\"subtype\":", 12);
16292 if (val.m_value.binary->has_subtype())
16294 dump_integer(val.m_value.binary->subtype());
16295 o->write_character(
'}');
16299 o->write_characters(
"null}", 5);
16305 case value_t::boolean:
16307 if (val.m_value.boolean)
16309 o->write_characters(
"true", 4);
16313 o->write_characters(
"false", 5);
16318 case value_t::number_integer:
16320 dump_integer(val.m_value.number_integer);
16324 case value_t::number_unsigned:
16326 dump_integer(val.m_value.number_unsigned);
16330 case value_t::number_float:
16332 dump_float(val.m_value.number_float);
16336 case value_t::discarded:
16338 o->write_characters(
"<discarded>", 11);
16342 case value_t::null:
16344 o->write_characters(
"null", 4);
16349 JSON_ASSERT(
false);
16353 JSON_PRIVATE_UNLESS_TESTED:
16368 void dump_escaped(
const string_t& s,
const bool ensure_ascii)
16370 std::uint32_t codepoint{};
16371 std::uint8_t state = UTF8_ACCEPT;
16372 std::size_t bytes = 0;
16375 std::size_t bytes_after_last_accept = 0;
16376 std::size_t undumped_chars = 0;
16378 for (std::size_t i = 0; i < s.size(); ++i)
16380 const auto byte =
static_cast<uint8_t
>(s[i]);
16382 switch (decode(state, codepoint,
byte))
16390 string_buffer[bytes++] =
'\\';
16391 string_buffer[bytes++] =
'b';
16397 string_buffer[bytes++] =
'\\';
16398 string_buffer[bytes++] =
't';
16404 string_buffer[bytes++] =
'\\';
16405 string_buffer[bytes++] =
'n';
16411 string_buffer[bytes++] =
'\\';
16412 string_buffer[bytes++] =
'f';
16418 string_buffer[bytes++] =
'\\';
16419 string_buffer[bytes++] =
'r';
16425 string_buffer[bytes++] =
'\\';
16426 string_buffer[bytes++] =
'\"';
16432 string_buffer[bytes++] =
'\\';
16433 string_buffer[bytes++] =
'\\';
16441 if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
16443 if (codepoint <= 0xFFFF)
16446 (std::snprintf)(string_buffer.data() + bytes, 7,
"\\u%04x",
16447 static_cast<std::uint16_t
>(codepoint));
16453 (std::snprintf)(string_buffer.data() + bytes, 13,
"\\u%04x\\u%04x",
16454 static_cast<std::uint16_t
>(0xD7C0u + (codepoint >> 10u)),
16455 static_cast<std::uint16_t
>(0xDC00u + (codepoint & 0x3FFu)));
16463 string_buffer[bytes++] = s[i];
16472 if (string_buffer.size() - bytes < 13)
16474 o->write_characters(string_buffer.data(), bytes);
16479 bytes_after_last_accept = bytes;
16480 undumped_chars = 0;
16486 switch (error_handler)
16488 case error_handler_t::strict:
16490 std::string sn(9,
'\0');
16492 (std::snprintf)(&sn[0], sn.size(),
"%.2X", byte);
16493 JSON_THROW(type_error::create(316,
"invalid UTF-8 byte at index " + std::to_string(i) +
": 0x" + sn, BasicJsonType()));
16496 case error_handler_t::ignore:
16497 case error_handler_t::replace:
16503 if (undumped_chars > 0)
16510 bytes = bytes_after_last_accept;
16512 if (error_handler == error_handler_t::replace)
16517 string_buffer[bytes++] =
'\\';
16518 string_buffer[bytes++] =
'u';
16519 string_buffer[bytes++] =
'f';
16520 string_buffer[bytes++] =
'f';
16521 string_buffer[bytes++] =
'f';
16522 string_buffer[bytes++] =
'd';
16526 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xEF');
16527 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBF');
16528 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBD');
16534 if (string_buffer.size() - bytes < 13)
16536 o->write_characters(string_buffer.data(), bytes);
16540 bytes_after_last_accept = bytes;
16543 undumped_chars = 0;
16546 state = UTF8_ACCEPT;
16551 JSON_ASSERT(
false);
16561 string_buffer[bytes++] = s[i];
16570 if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16575 o->write_characters(string_buffer.data(), bytes);
16581 switch (error_handler)
16583 case error_handler_t::strict:
16585 std::string sn(9,
'\0');
16587 (std::snprintf)(&sn[0], sn.size(),
"%.2X",
static_cast<std::uint8_t
>(s.back()));
16588 JSON_THROW(type_error::create(316,
"incomplete UTF-8 string; last byte: 0x" + sn, BasicJsonType()));
16591 case error_handler_t::ignore:
16594 o->write_characters(string_buffer.data(), bytes_after_last_accept);
16598 case error_handler_t::replace:
16601 o->write_characters(string_buffer.data(), bytes_after_last_accept);
16605 o->write_characters(
"\\ufffd", 6);
16609 o->write_characters(
"\xEF\xBF\xBD", 3);
16615 JSON_ASSERT(
false);
16629 inline unsigned int count_digits(number_unsigned_t x) noexcept
16631 unsigned int n_digits = 1;
16640 return n_digits + 1;
16644 return n_digits + 2;
16648 return n_digits + 3;
16664 template <
typename NumberType, detail::enable_if_t <
16665 std::is_same<NumberType, number_unsigned_t>::value ||
16666 std::is_same<NumberType, number_integer_t>::value ||
16667 std::is_same<NumberType, binary_char_t>::value,
16669 void dump_integer(NumberType x)
16671 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16674 {{
'0',
'0'}}, {{
'0',
'1'}}, {{
'0',
'2'}}, {{
'0',
'3'}}, {{
'0',
'4'}}, {{
'0',
'5'}}, {{
'0',
'6'}}, {{
'0',
'7'}}, {{
'0',
'8'}}, {{
'0',
'9'}},
16675 {{
'1',
'0'}}, {{
'1',
'1'}}, {{
'1',
'2'}}, {{
'1',
'3'}}, {{
'1',
'4'}}, {{
'1',
'5'}}, {{
'1',
'6'}}, {{
'1',
'7'}}, {{
'1',
'8'}}, {{
'1',
'9'}},
16676 {{
'2',
'0'}}, {{
'2',
'1'}}, {{
'2',
'2'}}, {{
'2',
'3'}}, {{
'2',
'4'}}, {{
'2',
'5'}}, {{
'2',
'6'}}, {{
'2',
'7'}}, {{
'2',
'8'}}, {{
'2',
'9'}},
16677 {{
'3',
'0'}}, {{
'3',
'1'}}, {{
'3',
'2'}}, {{
'3',
'3'}}, {{
'3',
'4'}}, {{
'3',
'5'}}, {{
'3',
'6'}}, {{
'3',
'7'}}, {{
'3',
'8'}}, {{
'3',
'9'}},
16678 {{
'4',
'0'}}, {{
'4',
'1'}}, {{
'4',
'2'}}, {{
'4',
'3'}}, {{
'4',
'4'}}, {{
'4',
'5'}}, {{
'4',
'6'}}, {{
'4',
'7'}}, {{
'4',
'8'}}, {{
'4',
'9'}},
16679 {{
'5',
'0'}}, {{
'5',
'1'}}, {{
'5',
'2'}}, {{
'5',
'3'}}, {{
'5',
'4'}}, {{
'5',
'5'}}, {{
'5',
'6'}}, {{
'5',
'7'}}, {{
'5',
'8'}}, {{
'5',
'9'}},
16680 {{
'6',
'0'}}, {{
'6',
'1'}}, {{
'6',
'2'}}, {{
'6',
'3'}}, {{
'6',
'4'}}, {{
'6',
'5'}}, {{
'6',
'6'}}, {{
'6',
'7'}}, {{
'6',
'8'}}, {{
'6',
'9'}},
16681 {{
'7',
'0'}}, {{
'7',
'1'}}, {{
'7',
'2'}}, {{
'7',
'3'}}, {{
'7',
'4'}}, {{
'7',
'5'}}, {{
'7',
'6'}}, {{
'7',
'7'}}, {{
'7',
'8'}}, {{
'7',
'9'}},
16682 {{
'8',
'0'}}, {{
'8',
'1'}}, {{
'8',
'2'}}, {{
'8',
'3'}}, {{
'8',
'4'}}, {{
'8',
'5'}}, {{
'8',
'6'}}, {{
'8',
'7'}}, {{
'8',
'8'}}, {{
'8',
'9'}},
16683 {{
'9',
'0'}}, {{
'9',
'1'}}, {{
'9',
'2'}}, {{
'9',
'3'}}, {{
'9',
'4'}}, {{
'9',
'5'}}, {{
'9',
'6'}}, {{
'9',
'7'}}, {{
'9',
'8'}}, {{
'9',
'9'}},
16690 o->write_character(
'0');
16695 auto buffer_ptr = number_buffer.begin();
16697 const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0);
16698 number_unsigned_t abs_value;
16700 unsigned int n_chars{};
16705 abs_value = remove_sign(
static_cast<number_integer_t
>(x));
16708 n_chars = 1 + count_digits(abs_value);
16712 abs_value =
static_cast<number_unsigned_t
>(x);
16713 n_chars = count_digits(abs_value);
16717 JSON_ASSERT(n_chars < number_buffer.size() - 1);
16721 buffer_ptr += n_chars;
16725 while (abs_value >= 100)
16727 const auto digits_index =
static_cast<unsigned>((abs_value % 100));
16729 *(--buffer_ptr) = digits_to_99[digits_index][1];
16730 *(--buffer_ptr) = digits_to_99[digits_index][0];
16733 if (abs_value >= 10)
16735 const auto digits_index =
static_cast<unsigned>(abs_value);
16736 *(--buffer_ptr) = digits_to_99[digits_index][1];
16737 *(--buffer_ptr) = digits_to_99[digits_index][0];
16741 *(--buffer_ptr) =
static_cast<char>(
'0' + abs_value);
16744 o->write_characters(number_buffer.data(), n_chars);
16755 void dump_float(number_float_t x)
16758 if (!std::isfinite(x))
16760 o->write_characters(
"null", 4);
16769 static constexpr
bool is_ieee_single_or_double
16770 = (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) ||
16771 (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);
16773 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
16776 void dump_float(number_float_t x, std::true_type )
16778 auto* begin = number_buffer.data();
16779 auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
16781 o->write_characters(begin,
static_cast<size_t>(end - begin));
16784 void dump_float(number_float_t x, std::false_type )
16787 static constexpr
auto d = std::numeric_limits<number_float_t>::max_digits10;
16791 std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(),
"%.*g", d, x);
16794 JSON_ASSERT(len > 0);
16796 JSON_ASSERT(
static_cast<std::size_t
>(len) < number_buffer.size());
16799 if (thousands_sep !=
'\0')
16801 auto*
const end = std::remove(number_buffer.begin(),
16802 number_buffer.begin() + len, thousands_sep);
16803 std::fill(end, number_buffer.end(),
'\0');
16804 JSON_ASSERT((end - number_buffer.begin()) <= len);
16805 len = (end - number_buffer.begin());
16809 if (decimal_point !=
'\0' && decimal_point !=
'.')
16811 auto*
const dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
16812 if (dec_pos != number_buffer.end())
16818 o->write_characters(number_buffer.data(),
static_cast<std::size_t
>(len));
16821 const bool value_is_int_like =
16822 std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
16825 return c ==
'.' || c ==
'e';
16828 if (value_is_int_like)
16830 o->write_characters(
".0", 2);
16855 static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep,
const std::uint8_t
byte) noexcept
16857 static const std::array<std::uint8_t, 400> utf8d =
16860 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,
16861 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,
16862 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,
16863 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,
16864 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,
16865 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,
16866 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,
16867 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3,
16868 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
16869 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1,
16870 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,
16871 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,
16872 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,
16873 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
16877 JSON_ASSERT(
byte < utf8d.size());
16878 const std::uint8_t type = utf8d[byte];
16880 codep = (state != UTF8_ACCEPT)
16881 ? (
byte & 0x3fu) | (codep << 6u)
16882 : (0xFFu >> type) & (byte);
16884 std::size_t index = 256u +
static_cast<size_t>(state) * 16u +
static_cast<size_t>(type);
16885 JSON_ASSERT(index < 400);
16886 state = utf8d[index];
16895 number_unsigned_t remove_sign(number_unsigned_t x)
16897 JSON_ASSERT(
false);
16910 inline number_unsigned_t remove_sign(number_integer_t x) noexcept
16912 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
16913 return static_cast<number_unsigned_t
>(-(x + 1)) + 1;
16918 output_adapter_t<char> o =
nullptr;
16921 std::array<char, 64> number_buffer{{}};
16924 const std::lconv* loc =
nullptr;
16926 const char thousands_sep =
'\0';
16928 const char decimal_point =
'\0';
16931 std::array<char, 512> string_buffer{{}};
16934 const char indent_char;
16936 string_t indent_string;
16939 const error_handler_t error_handler;
16951 #include <functional>
16952 #include <initializer_list>
16953 #include <iterator>
16955 #include <stdexcept>
16956 #include <type_traits>
16968 template <
class Key,
class T,
class IgnoredLess = std::less<Key>,
16969 class Allocator = std::allocator<std::pair<const Key, T>>>
16974 using Container = std::vector<std::pair<const Key, T>, Allocator>;
16975 using typename Container::iterator;
16976 using typename Container::const_iterator;
16977 using typename Container::size_type;
16978 using typename Container::value_type;
16983 template <
class It>
16986 ordered_map(std::initializer_list<T> init,
const Allocator& alloc = Allocator() )
16991 for (
auto it = this->begin(); it != this->end(); ++it)
16993 if (it->first == key)
16995 return {it,
false};
16998 Container::emplace_back(key, t);
16999 return {--this->end(),
true};
17004 return emplace(key, T{}).first->second;
17014 for (
auto it = this->begin(); it != this->end(); ++it)
17016 if (it->first == key)
17022 JSON_THROW(std::out_of_range(
"key not found"));
17025 const T&
at(
const Key& key)
const
17027 for (
auto it = this->begin(); it != this->end(); ++it)
17029 if (it->first == key)
17035 JSON_THROW(std::out_of_range(
"key not found"));
17040 for (
auto it = this->begin(); it != this->end(); ++it)
17042 if (it->first == key)
17045 for (
auto next = it; ++next != this->end(); ++it)
17048 new (&*it) value_type{std::move(*next)};
17050 Container::pop_back();
17062 for (
auto next = it; ++next != this->end(); ++it)
17065 new (&*it) value_type{std::move(*next)};
17067 Container::pop_back();
17073 for (
auto it = this->begin(); it != this->end(); ++it)
17075 if (it->first == key)
17085 for (
auto it = this->begin(); it != this->end(); ++it)
17087 if (it->first == key)
17092 return Container::end();
17095 const_iterator
find(
const Key& key)
const
17097 for (
auto it = this->begin(); it != this->end(); ++it)
17099 if (it->first == key)
17104 return Container::end();
17107 std::pair<iterator, bool>
insert( value_type&& value )
17109 return emplace(value.first, std::move(value.second));
17112 std::pair<iterator, bool>
insert(
const value_type& value )
17114 for (
auto it = this->begin(); it != this->end(); ++it)
17116 if (it->first == value.first)
17118 return {it,
false};
17121 Container::push_back(value);
17122 return {--this->end(),
true};
17125 template<
typename InputIt>
17126 using require_input_iter =
typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
17127 std::input_iterator_tag>::value>::type;
17129 template<
typename InputIt,
typename = require_input_iter<InputIt>>
17132 for (
auto it = first; it != last; ++it)
17142 #if defined(JSON_HAS_CPP_17)
17143 #include <string_view>
17238 NLOHMANN_BASIC_JSON_TPL_DECLARATION
17243 friend ::nlohmann::json_pointer<basic_json>;
17245 template<
typename BasicJsonType,
typename InputType>
17246 friend class ::nlohmann::detail::parser;
17247 friend ::nlohmann::detail::serializer<basic_json>;
17248 template<
typename BasicJsonType>
17249 friend class ::nlohmann::detail::iter_impl;
17250 template<
typename BasicJsonType,
typename CharType>
17251 friend class ::nlohmann::detail::binary_writer;
17252 template<
typename BasicJsonType,
typename InputType,
typename SAX>
17253 friend class ::nlohmann::detail::binary_reader;
17254 template<
typename BasicJsonType>
17255 friend class ::nlohmann::detail::json_sax_dom_parser;
17256 template<
typename BasicJsonType>
17257 friend class ::nlohmann::detail::json_sax_dom_callback_parser;
17258 friend class ::nlohmann::detail::exception;
17261 using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
17263 JSON_PRIVATE_UNLESS_TESTED:
17265 using lexer = ::nlohmann::detail::lexer_base<basic_json>;
17267 template<
typename InputAdapterType>
17268 static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
17269 InputAdapterType adapter,
17270 detail::parser_callback_t<basic_json>cb =
nullptr,
17271 const bool allow_exceptions =
true,
17272 const bool ignore_comments =
false
17275 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
17276 std::move(cb), allow_exceptions, ignore_comments);
17280 using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
17281 template<
typename BasicJsonType>
17282 using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
17283 template<
typename BasicJsonType>
17284 using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
17285 template<
typename Iterator>
17286 using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
17287 template<
typename Base>
using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
17289 template<
typename CharType>
17290 using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
17292 template<
typename InputType>
17293 using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
17294 template<
typename CharType>
using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
17296 JSON_PRIVATE_UNLESS_TESTED:
17297 using serializer = ::nlohmann::detail::serializer<basic_json>;
17300 using value_t = detail::value_t;
17303 template<
typename T,
typename SFINAE>
17306 using error_handler_t = detail::error_handler_t;
17308 using cbor_tag_handler_t = detail::cbor_tag_handler_t;
17312 using input_format_t = detail::input_format_t;
17366 using pointer =
typename std::allocator_traits<allocator_type>::pointer;
17368 using const_pointer =
typename std::allocator_traits<allocator_type>::const_pointer;
17421 result[
"copyright"] =
"(C) 2013-2021 Niels Lohmann";
17422 result[
"name"] =
"JSON for Modern C++";
17423 result[
"url"] =
"https://github.com/nlohmann/json";
17424 result[
"version"][
"string"] =
17425 std::to_string(NLOHMANN_JSON_VERSION_MAJOR) +
"." +
17426 std::to_string(NLOHMANN_JSON_VERSION_MINOR) +
"." +
17427 std::to_string(NLOHMANN_JSON_VERSION_PATCH);
17428 result[
"version"][
"major"] = NLOHMANN_JSON_VERSION_MAJOR;
17429 result[
"version"][
"minor"] = NLOHMANN_JSON_VERSION_MINOR;
17430 result[
"version"][
"patch"] = NLOHMANN_JSON_VERSION_PATCH;
17433 result[
"platform"] =
"win32";
17434 #elif defined __linux__
17435 result[
"platform"] =
"linux";
17436 #elif defined __APPLE__
17437 result[
"platform"] =
"apple";
17438 #elif defined __unix__
17439 result[
"platform"] =
"unix";
17441 result[
"platform"] =
"unknown";
17444 #if defined(__ICC) || defined(__INTEL_COMPILER)
17445 result[
"compiler"] = {{
"family",
"icc"}, {
"version", __INTEL_COMPILER}};
17446 #elif defined(__clang__)
17447 result[
"compiler"] = {{
"family",
"clang"}, {
"version", __clang_version__}};
17448 #elif defined(__GNUC__) || defined(__GNUG__)
17449 result[
"compiler"] = {{
"family",
"gcc"}, {
"version", std::to_string(__GNUC__) +
"." + std::to_string(__GNUC_MINOR__) +
"." + std::to_string(__GNUC_PATCHLEVEL__)}};
17450 #elif defined(__HP_cc) || defined(__HP_aCC)
17451 result[
"compiler"] =
"hp"
17452 #elif defined(__IBMCPP__)
17453 result[
"compiler"] = {{
"family",
"ilecpp"}, {
"version", __IBMCPP__}};
17454 #elif defined(_MSC_VER)
17455 result[
"compiler"] = {{
"family",
"msvc"}, {
"version", _MSC_VER}};
17456 #elif defined(__PGI)
17457 result[
"compiler"] = {{
"family",
"pgcpp"}, {
"version", __PGI}};
17458 #elif defined(__SUNPRO_CC)
17459 result[
"compiler"] = {{
"family",
"sunpro"}, {
"version", __SUNPRO_CC}};
17461 result[
"compiler"] = {{
"family",
"unknown"}, {
"version",
"unknown"}};
17465 result[
"compiler"][
"c++"] = std::to_string(__cplusplus);
17467 result[
"compiler"][
"c++"] =
"unknown";
17482 #if defined(JSON_HAS_CPP_14)
17576 AllocatorType<std::pair<
const StringType,
17623 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
17990 template<
typename T,
typename... Args>
17992 static T* create(Args&& ... args)
17994 AllocatorType<T> alloc;
17995 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
17997 auto deleter = [&](T * obj)
17999 AllocatorTraits::deallocate(alloc, obj, 1);
18001 std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
18002 AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
18003 JSON_ASSERT(obj !=
nullptr);
18004 return obj.release();
18011 JSON_PRIVATE_UNLESS_TESTED:
18057 json_value() =
default;
18059 json_value(
boolean_t v) noexcept : boolean(v) {}
18071 case value_t::object:
18073 object = create<object_t>();
18077 case value_t::array:
18079 array = create<array_t>();
18083 case value_t::string:
18085 string = create<string_t>(
"");
18089 case value_t::binary:
18091 binary = create<binary_t>();
18095 case value_t::boolean:
18101 case value_t::number_integer:
18107 case value_t::number_unsigned:
18113 case value_t::number_float:
18119 case value_t::null:
18128 if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
18130 JSON_THROW(other_error::create(500,
"961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1",
basic_json()));
18140 string = create<string_t>(
value);
18146 string = create<string_t>(std::move(
value));
18152 object = create<object_t>(
value);
18158 object = create<object_t>(std::move(
value));
18164 array = create<array_t>(
value);
18170 array = create<array_t>(std::move(
value));
18176 binary = create<binary_t>(
value);
18182 binary = create<binary_t>(std::move(
value));
18188 binary = create<binary_t>(
value);
18194 binary = create<binary_t>(std::move(
value));
18199 if (t == value_t::array || t == value_t::object)
18202 std::vector<basic_json> stack;
18205 if (t == value_t::array)
18207 stack.reserve(array->size());
18208 std::move(array->begin(), array->end(), std::back_inserter(stack));
18213 for (
auto&& it : *
object)
18215 stack.push_back(std::move(it.second));
18219 while (!stack.empty())
18222 basic_json current_item(std::move(stack.back()));
18227 if (current_item.is_array())
18229 std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
18231 current_item.m_value.array->clear();
18233 else if (current_item.is_object())
18235 for (
auto&& it : *current_item.m_value.object)
18237 stack.push_back(std::move(it.second));
18240 current_item.m_value.object->clear();
18250 case value_t::object:
18252 AllocatorType<object_t> alloc;
18253 std::allocator_traits<decltype(alloc)>::destroy(alloc,
object);
18254 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
object, 1);
18258 case value_t::array:
18260 AllocatorType<array_t> alloc;
18261 std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
18262 std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
18266 case value_t::string:
18268 AllocatorType<string_t> alloc;
18269 std::allocator_traits<decltype(alloc)>::destroy(alloc,
string);
18270 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
string, 1);
18274 case value_t::binary:
18276 AllocatorType<binary_t> alloc;
18277 std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
18278 std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
18309 void assert_invariant(
bool check_parents =
true) const noexcept
18311 JSON_ASSERT(m_type != value_t::object ||
m_value.object !=
nullptr);
18312 JSON_ASSERT(m_type != value_t::array ||
m_value.array !=
nullptr);
18313 JSON_ASSERT(m_type != value_t::string ||
m_value.string !=
nullptr);
18314 JSON_ASSERT(m_type != value_t::binary ||
m_value.binary !=
nullptr);
18316 #if JSON_DIAGNOSTICS
18322 return j.m_parent ==
this;
18327 static_cast<void>(check_parents);
18332 #if JSON_DIAGNOSTICS
18335 case value_t::array:
18337 for (
auto& element : *
m_value.array)
18339 element.m_parent =
this;
18344 case value_t::object:
18346 for (
auto& element : *
m_value.object)
18348 element.second.m_parent =
this;
18361 #if JSON_DIAGNOSTICS
18362 for (
typename iterator::difference_type i = 0; i <
count; ++i)
18364 (it + i)->m_parent =
this;
18367 static_cast<void>(
count);
18374 #if JSON_DIAGNOSTICS
18375 if (old_capacity != std::size_t(-1))
18378 JSON_ASSERT(
type() == value_t::array);
18379 if (JSON_HEDLEY_UNLIKELY(
m_value.array->capacity() != old_capacity))
18389 static_cast<void>(j);
18390 static_cast<void>(old_capacity);
18415 using parse_event_t = detail::parse_event_t;
18510 assert_invariant();
18534 assert_invariant();
18599 template <
typename CompatibleType,
18600 typename U = detail::uncvref_t<CompatibleType>,
18601 detail::enable_if_t <
18602 !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value,
int > = 0 >
18604 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
18605 std::forward<CompatibleType>(val))))
18607 JSONSerializer<U>::to_json(*
this, std::forward<CompatibleType>(val));
18609 assert_invariant();
18638 template <
typename BasicJsonType,
18639 detail::enable_if_t <
18640 detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value,
int > = 0 >
18643 using other_boolean_t =
typename BasicJsonType::boolean_t;
18644 using other_number_float_t =
typename BasicJsonType::number_float_t;
18645 using other_number_integer_t =
typename BasicJsonType::number_integer_t;
18646 using other_number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
18647 using other_string_t =
typename BasicJsonType::string_t;
18648 using other_object_t =
typename BasicJsonType::object_t;
18649 using other_array_t =
typename BasicJsonType::array_t;
18650 using other_binary_t =
typename BasicJsonType::binary_t;
18652 switch (val.type())
18654 case value_t::boolean:
18655 JSONSerializer<other_boolean_t>::to_json(*
this, val.template get<other_boolean_t>());
18657 case value_t::number_float:
18658 JSONSerializer<other_number_float_t>::to_json(*
this, val.template get<other_number_float_t>());
18660 case value_t::number_integer:
18661 JSONSerializer<other_number_integer_t>::to_json(*
this, val.template get<other_number_integer_t>());
18663 case value_t::number_unsigned:
18664 JSONSerializer<other_number_unsigned_t>::to_json(*
this, val.template get<other_number_unsigned_t>());
18666 case value_t::string:
18667 JSONSerializer<other_string_t>::to_json(*
this, val.template get_ref<const other_string_t&>());
18669 case value_t::object:
18670 JSONSerializer<other_object_t>::to_json(*
this, val.template get_ref<const other_object_t&>());
18672 case value_t::array:
18673 JSONSerializer<other_array_t>::to_json(*
this, val.template get_ref<const other_array_t&>());
18675 case value_t::binary:
18676 JSONSerializer<other_binary_t>::to_json(*
this, val.template get_ref<const other_binary_t&>());
18678 case value_t::null:
18681 case value_t::discarded:
18682 m_type = value_t::discarded;
18685 JSON_ASSERT(
false);
18688 assert_invariant();
18766 bool type_deduction =
true,
18767 value_t manual_type = value_t::array)
18771 bool is_an_object = std::all_of(init.begin(), init.end(),
18772 [](
const detail::json_ref<basic_json>& element_ref)
18774 return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
18778 if (!type_deduction)
18781 if (manual_type == value_t::array)
18783 is_an_object =
false;
18787 if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
18789 JSON_THROW(type_error::create(301,
"cannot create object from initializer list",
basic_json()));
18796 m_type = value_t::object;
18799 for (
auto& element_ref : init)
18801 auto element = element_ref.moved_or_copied();
18803 std::move(*((*element.m_value.array)[0].m_value.string)),
18804 std::move((*element.m_value.array)[1]));
18810 m_type = value_t::array;
18811 m_value.array = create<array_t>(init.begin(), init.end());
18815 assert_invariant();
18849 res.m_type = value_t::binary;
18850 res.m_value = init;
18886 res.m_type = value_t::binary;
18887 res.m_value =
binary_t(init, subtype);
18896 res.m_type = value_t::binary;
18897 res.m_value = std::move(init);
18906 res.m_type = value_t::binary;
18907 res.m_value =
binary_t(std::move(init), subtype);
18951 return basic_json(init,
false, value_t::array);
18995 return basic_json(init,
false, value_t::object);
19021 : m_type(value_t::array)
19023 m_value.array = create<array_t>(cnt, val);
19025 assert_invariant();
19083 template <
class InputIT,
typename std::enable_if <
19084 std::is_same<InputIT, typename basic_json_t::iterator>::value ||
19085 std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
int >
::type = 0 >
19088 JSON_ASSERT(first.m_object !=
nullptr);
19089 JSON_ASSERT(last.m_object !=
nullptr);
19092 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
19094 JSON_THROW(invalid_iterator::create(201,
"iterators are not compatible",
basic_json()));
19098 m_type = first.m_object->m_type;
19103 case value_t::boolean:
19104 case value_t::number_float:
19105 case value_t::number_integer:
19106 case value_t::number_unsigned:
19107 case value_t::string:
19109 if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
19110 || !last.m_it.primitive_iterator.is_end()))
19112 JSON_THROW(invalid_iterator::create(204,
"iterators out of range", *first.m_object));
19123 case value_t::number_integer:
19125 m_value.number_integer = first.m_object->m_value.number_integer;
19129 case value_t::number_unsigned:
19131 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
19135 case value_t::number_float:
19137 m_value.number_float = first.m_object->m_value.number_float;
19141 case value_t::boolean:
19143 m_value.boolean = first.m_object->m_value.boolean;
19147 case value_t::string:
19149 m_value = *first.m_object->m_value.string;
19153 case value_t::object:
19155 m_value.object = create<object_t>(first.m_it.object_iterator,
19156 last.m_it.object_iterator);
19160 case value_t::array:
19162 m_value.array = create<array_t>(first.m_it.array_iterator,
19163 last.m_it.array_iterator);
19167 case value_t::binary:
19169 m_value = *first.m_object->m_value.binary;
19174 JSON_THROW(invalid_iterator::create(206,
"cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
19178 assert_invariant();
19186 template<
typename JsonRef,
19187 detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
19188 std::is_same<typename JsonRef::value_type, basic_json>>
::value,
int> = 0 >
19217 : m_type(other.m_type)
19220 other.assert_invariant();
19224 case value_t::object:
19230 case value_t::array:
19236 case value_t::string:
19242 case value_t::boolean:
19248 case value_t::number_integer:
19254 case value_t::number_unsigned:
19260 case value_t::number_float:
19266 case value_t::binary:
19277 assert_invariant();
19307 : m_type(std::move(other.m_type)),
19308 m_value(std::move(other.m_value))
19311 other.assert_invariant(
false);
19314 other.m_type = value_t::null;
19315 other.m_value = {};
19318 assert_invariant();
19345 std::is_nothrow_move_constructible<value_t>::value&&
19346 std::is_nothrow_move_assignable<value_t>::value&&
19347 std::is_nothrow_move_constructible<json_value>::value&&
19348 std::is_nothrow_move_assignable<json_value>::value
19352 other.assert_invariant();
19355 swap(m_type, other.m_type);
19359 assert_invariant();
19380 assert_invariant(
false);
19443 const char indent_char =
' ',
19444 const bool ensure_ascii =
false,
19445 const error_handler_t error_handler = error_handler_t::strict)
const
19448 serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
19452 s.dump(*
this,
true, ensure_ascii,
static_cast<unsigned int>(indent));
19456 s.dump(*
this,
false, ensure_ascii, 0);
19495 constexpr value_t
type() const noexcept
19577 return m_type == value_t::null;
19599 return m_type == value_t::boolean;
19658 return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
19686 return m_type == value_t::number_unsigned;
19714 return m_type == value_t::number_float;
19736 return m_type == value_t::object;
19758 return m_type == value_t::array;
19780 return m_type == value_t::string;
19802 return m_type == value_t::binary;
19829 return m_type == value_t::discarded;
19873 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(
type_name()), *
this));
19895 constexpr
const array_t* get_impl_ptr(
const array_t* )
const noexcept
19983 template<
typename ReferenceType,
typename ThisType>
19984 static ReferenceType get_ref_impl(ThisType& obj)
19987 auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
19989 if (JSON_HEDLEY_LIKELY(ptr !=
nullptr))
19994 JSON_THROW(type_error::create(303,
"incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
20028 template<
typename PointerType,
typename std::enable_if<
20029 std::is_pointer<PointerType>::value,
int>
::type = 0>
20030 auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20033 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20040 template <
typename PointerType,
typename std::enable_if <
20041 std::is_pointer<PointerType>::value&&
20042 std::is_const<typename std::remove_pointer<PointerType>::type>
::value,
int >
::type = 0 >
20043 constexpr
auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20046 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
20088 template <
typename ValueType,
20089 detail::enable_if_t <
20090 detail::is_default_constructible<ValueType>::value&&
20091 detail::has_from_json<basic_json_t, ValueType>::value,
20093 ValueType get_impl(detail::priority_tag<0> )
const noexcept(noexcept(
20094 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20097 JSONSerializer<ValueType>::from_json(*
this, ret);
20131 template <
typename ValueType,
20132 detail::enable_if_t <
20133 detail::has_non_default_from_json<basic_json_t, ValueType>::value,
20135 ValueType get_impl(detail::priority_tag<1> )
const noexcept(noexcept(
20136 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20138 return JSONSerializer<ValueType>::from_json(*
this);
20156 template <
typename BasicJsonType,
20157 detail::enable_if_t <
20158 detail::is_basic_json<BasicJsonType>::value,
20160 BasicJsonType get_impl(detail::priority_tag<2> )
const
20179 template<
typename BasicJsonType,
20180 detail::enable_if_t<
20181 std::is_same<BasicJsonType, basic_json_t>::value,
20183 basic_json get_impl(detail::priority_tag<3> )
const
20192 template<
typename PointerType,
20193 detail::enable_if_t<
20194 std::is_pointer<PointerType>::value,
20196 constexpr
auto get_impl(detail::priority_tag<4> )
const noexcept
20197 -> decltype(std::declval<const basic_json_t&>().
template get_ptr<PointerType>())
20200 return get_ptr<PointerType>();
20227 template <
typename ValueTypeCV,
typename ValueType = detail::uncvref_t<ValueTypeCV>>
20228 #if defined(JSON_HAS_CPP_14)
20232 noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
20233 -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
20238 static_assert(!std::is_reference<ValueTypeCV>::value,
20239 "get() cannot be used with reference types, you might want to use get_ref()");
20240 return get_impl<ValueType>(detail::priority_tag<4> {});
20270 template<
typename PointerType,
typename std::enable_if<
20271 std::is_pointer<PointerType>::value,
int>
::type = 0>
20272 auto get() noexcept -> decltype(std::declval<basic_json_t&>().template
get_ptr<PointerType>())
20275 return get_ptr<PointerType>();
20311 template <
typename ValueType,
20312 detail::enable_if_t <
20313 !detail::is_basic_json<ValueType>::value&&
20314 detail::has_from_json<basic_json_t, ValueType>::value,
20316 ValueType &
get_to(ValueType& v)
const noexcept(noexcept(
20317 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
20319 JSONSerializer<ValueType>::from_json(*
this, v);
20325 template<
typename ValueType,
20326 detail::enable_if_t <
20327 detail::is_basic_json<ValueType>::value,
20336 typename T, std::size_t N,
20337 typename Array = T (&)[N],
20338 detail::enable_if_t <
20339 detail::has_from_json<basic_json_t, Array>::value,
int > = 0 >
20341 noexcept(noexcept(JSONSerializer<Array>::from_json(
20342 std::declval<const basic_json_t&>(), v)))
20344 JSONSerializer<Array>::from_json(*
this, v);
20374 template<
typename ReferenceType,
typename std::enable_if<
20375 std::is_reference<ReferenceType>::value,
int>
::type = 0>
20379 return get_ref_impl<ReferenceType>(*
this);
20386 template <
typename ReferenceType,
typename std::enable_if <
20387 std::is_reference<ReferenceType>::value&&
20388 std::is_const<typename std::remove_reference<ReferenceType>::type>
::value,
int >
::type = 0 >
20392 return get_ref_impl<ReferenceType>(*
this);
20424 template <
typename ValueType,
typename std::enable_if <
20425 !std::is_pointer<ValueType>::value&&
20426 !std::is_same<ValueType, detail::json_ref<basic_json>>
::value&&
20427 !std::is_same<ValueType, typename string_t::value_type>::value&&
20428 !detail::is_basic_json<ValueType>::value
20429 && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>
::value
20430 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
20431 && !std::is_same<ValueType, typename std::string_view>::value
20433 && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
20435 JSON_EXPLICIT
operator ValueType()
const
20438 return get<ValueType>();
20454 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name()), *
this));
20457 return *get_ptr<binary_t*>();
20465 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name()), *
this));
20468 return *get_ptr<const binary_t*>();
20511 if (JSON_HEDLEY_LIKELY(
is_array()))
20515 return set_parent(
m_value.array->at(idx));
20517 JSON_CATCH (std::out_of_range&)
20520 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
20525 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
20558 if (JSON_HEDLEY_LIKELY(
is_array()))
20562 return m_value.array->at(idx);
20564 JSON_CATCH (std::out_of_range&)
20567 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
20572 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
20606 reference at(
const typename object_t::key_type& key)
20613 return set_parent(
m_value.object->at(key));
20615 JSON_CATCH (std::out_of_range&)
20618 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found", *
this));
20623 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
20664 return m_value.object->at(key);
20666 JSON_CATCH (std::out_of_range&)
20669 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found", *
this));
20674 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name()), *
this));
20708 m_type = value_t::array;
20709 m_value.array = create<array_t>();
20710 assert_invariant();
20714 if (JSON_HEDLEY_LIKELY(
is_array()))
20717 if (idx >=
m_value.array->size())
20719 #if JSON_DIAGNOSTICS
20721 const auto previous_size =
m_value.array->size();
20723 m_value.array->resize(idx + 1);
20725 #if JSON_DIAGNOSTICS
20727 set_parents(
begin() +
static_cast<typename iterator::difference_type
>(previous_size),
static_cast<typename iterator::difference_type
>(idx + 1 - previous_size));
20731 return m_value.array->operator[](idx);
20734 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name()), *
this));
20759 if (JSON_HEDLEY_LIKELY(
is_array()))
20761 return m_value.array->operator[](idx);
20764 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name()), *
this));
20799 m_type = value_t::object;
20800 m_value.object = create<object_t>();
20801 assert_invariant();
20807 return set_parent(
m_value.object->operator[](key));
20810 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
20848 JSON_ASSERT(
m_value.object->find(key) !=
m_value.object->end());
20849 return m_value.object->find(key)->second;
20852 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
20882 template<
typename T>
20883 JSON_HEDLEY_NON_NULL(2)
20889 m_type = value_t::object;
20891 assert_invariant();
20897 return set_parent(
m_value.object->operator[](key));
20900 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
20933 template<
typename T>
20934 JSON_HEDLEY_NON_NULL(2)
20940 JSON_ASSERT(
m_value.object->find(key) !=
m_value.object->end());
20941 return m_value.object->find(key)->second;
20944 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name()), *
this));
20998 template <
class ValueType,
typename std::enable_if <
20999 detail::is_getable<basic_json_t, ValueType>::value
21000 && !std::is_same<value_t, ValueType>::value,
int >
::type = 0 >
21001 ValueType
value(
const typename object_t::key_type& key,
const ValueType& default_value)
const
21007 const auto it =
find(key);
21010 return it->template get<ValueType>();
21013 return default_value;
21016 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name()), *
this));
21023 string_t value(
const typename object_t::key_type& key,
const char* default_value)
const
21071 template<
class ValueType,
typename std::enable_if<
21072 detail::is_getable<basic_json_t, ValueType>::value,
int>
::type = 0>
21081 return ptr.get_checked(
this).template get<ValueType>();
21085 return default_value;
21089 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name()), *
this));
21096 JSON_HEDLEY_NON_NULL(3)
21234 template <
class IteratorType,
typename std::enable_if <
21235 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21236 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21238 IteratorType
erase(IteratorType pos)
21241 if (JSON_HEDLEY_UNLIKELY(
this != pos.m_object))
21243 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
21246 IteratorType result =
end();
21250 case value_t::boolean:
21251 case value_t::number_float:
21252 case value_t::number_integer:
21253 case value_t::number_unsigned:
21254 case value_t::string:
21255 case value_t::binary:
21257 if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
21259 JSON_THROW(invalid_iterator::create(205,
"iterator out of range", *
this));
21264 AllocatorType<string_t> alloc;
21265 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.string);
21266 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21271 AllocatorType<binary_t> alloc;
21272 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.binary);
21273 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21277 m_type = value_t::null;
21278 assert_invariant();
21282 case value_t::object:
21284 result.m_it.object_iterator =
m_value.object->erase(pos.m_it.object_iterator);
21288 case value_t::array:
21290 result.m_it.array_iterator =
m_value.array->erase(pos.m_it.array_iterator);
21295 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21347 template <
class IteratorType,
typename std::enable_if <
21348 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21349 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
21351 IteratorType
erase(IteratorType first, IteratorType last)
21354 if (JSON_HEDLEY_UNLIKELY(
this != first.m_object ||
this != last.m_object))
21356 JSON_THROW(invalid_iterator::create(203,
"iterators do not fit current value", *
this));
21359 IteratorType result =
end();
21363 case value_t::boolean:
21364 case value_t::number_float:
21365 case value_t::number_integer:
21366 case value_t::number_unsigned:
21367 case value_t::string:
21368 case value_t::binary:
21370 if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
21371 || !last.m_it.primitive_iterator.is_end()))
21373 JSON_THROW(invalid_iterator::create(204,
"iterators out of range", *
this));
21378 AllocatorType<string_t> alloc;
21379 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.string);
21380 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.string, 1);
21385 AllocatorType<binary_t> alloc;
21386 std::allocator_traits<decltype(alloc)>::destroy(alloc,
m_value.binary);
21387 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
m_value.binary, 1);
21391 m_type = value_t::null;
21392 assert_invariant();
21396 case value_t::object:
21398 result.m_it.object_iterator =
m_value.object->erase(first.m_it.object_iterator,
21399 last.m_it.object_iterator);
21403 case value_t::array:
21405 result.m_it.array_iterator =
m_value.array->erase(first.m_it.array_iterator,
21406 last.m_it.array_iterator);
21411 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21451 return m_value.object->erase(key);
21454 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21484 if (JSON_HEDLEY_LIKELY(
is_array()))
21486 if (JSON_HEDLEY_UNLIKELY(idx >=
size()))
21488 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", *
this));
21495 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name()), *
this));
21533 template<
typename KeyT>
21536 auto result =
end();
21540 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
21550 template<
typename KeyT>
21553 auto result =
cend();
21557 result.m_it.object_iterator =
m_value.object->find(std::forward<KeyT>(key));
21584 template<
typename KeyT>
21616 template <
typename KeyT,
typename std::enable_if <
21651 return ptr.contains(
this);
21691 result.set_begin();
21731 result.set_begin();
21995 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
21998 return ref.items();
22004 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
22007 return ref.items();
22078 iteration_proxy<iterator>
items() noexcept
22080 return iteration_proxy<iterator>(*
this);
22086 iteration_proxy<const_iterator>
items() const noexcept
22088 return iteration_proxy<const_iterator>(*
this);
22143 bool empty() const noexcept
22147 case value_t::null:
22153 case value_t::array:
22156 return m_value.array->empty();
22159 case value_t::object:
22162 return m_value.object->empty();
22220 case value_t::null:
22226 case value_t::array:
22229 return m_value.array->size();
22232 case value_t::object:
22235 return m_value.object->size();
22291 case value_t::array:
22294 return m_value.array->max_size();
22297 case value_t::object:
22300 return m_value.object->max_size();
22358 void clear() noexcept
22362 case value_t::number_integer:
22368 case value_t::number_unsigned:
22374 case value_t::number_float:
22380 case value_t::boolean:
22386 case value_t::string:
22392 case value_t::binary:
22398 case value_t::array:
22404 case value_t::object:
22440 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22446 m_type = value_t::array;
22448 assert_invariant();
22452 const auto old_capacity =
m_value.array->capacity();
22453 m_value.array->push_back(std::move(val));
22454 set_parent(
m_value.array->back(), old_capacity);
22477 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22483 m_type = value_t::array;
22485 assert_invariant();
22489 const auto old_capacity =
m_value.array->capacity();
22490 m_value.array->push_back(val);
22491 set_parent(
m_value.array->back(), old_capacity);
22524 void push_back(
const typename object_t::value_type& val)
22529 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name()), *
this));
22535 m_type = value_t::object;
22537 assert_invariant();
22541 auto res =
m_value.object->insert(val);
22542 set_parent(res.first->second);
22582 if (
is_object() && init.size() == 2 && (*init.begin())->is_string())
22584 basic_json&& key = init.begin()->moved_or_copied();
22585 push_back(
typename object_t::value_type(
22586 std::move(key.get_ref<
string_t&>()), (init.begin() + 1)->moved_or_copied()));
22627 template<
class... Args>
22633 JSON_THROW(type_error::create(311,
"cannot use emplace_back() with " + std::string(
type_name()), *
this));
22639 m_type = value_t::array;
22641 assert_invariant();
22645 const auto old_capacity =
m_value.array->capacity();
22646 m_value.array->emplace_back(std::forward<Args>(args)...);
22647 return set_parent(
m_value.array->back(), old_capacity);
22677 template<
class... Args>
22678 std::pair<iterator, bool>
emplace(Args&& ... args)
22683 JSON_THROW(type_error::create(311,
"cannot use emplace() with " + std::string(
type_name()), *
this));
22689 m_type = value_t::object;
22691 assert_invariant();
22695 auto res =
m_value.object->emplace(std::forward<Args>(args)...);
22696 set_parent(res.first->second);
22700 it.m_it.object_iterator = res.first;
22703 return {it, res.second};
22709 template<
typename... Args>
22713 JSON_ASSERT(
m_value.array !=
nullptr);
22715 auto insert_pos = std::distance(
m_value.array->begin(), pos.m_it.array_iterator);
22716 m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
22717 result.m_it.array_iterator =
m_value.array->begin() + insert_pos;
22752 if (JSON_HEDLEY_LIKELY(
is_array()))
22755 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
22757 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
22764 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
22773 return insert(pos, val);
22803 if (JSON_HEDLEY_LIKELY(
is_array()))
22806 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
22808 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
22815 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
22851 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
22853 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
22857 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
22859 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
22863 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22865 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
22868 if (JSON_HEDLEY_UNLIKELY(first.m_object ==
this))
22870 JSON_THROW(invalid_iterator::create(211,
"passed iterators may not belong to container", *
this));
22874 return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
22904 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
22906 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
22910 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
22912 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value", *
this));
22945 if (JSON_HEDLEY_UNLIKELY(!
is_object()))
22947 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name()), *
this));
22951 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22953 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
22957 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
22959 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects", *
this));
22962 m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
22989 m_type = value_t::object;
22990 m_value.object = create<object_t>();
22991 assert_invariant();
22996 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name()), *
this));
22998 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
23000 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(j.type_name()), *
this));
23003 for (
auto it = j.cbegin(); it != j.cend(); ++it)
23005 m_value.object->operator[](it.key()) = it.value();
23040 m_type = value_t::object;
23041 m_value.object = create<object_t>();
23042 assert_invariant();
23047 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name()), *
this));
23051 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
23053 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit", *
this));
23057 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
23058 || !last.m_object->is_object()))
23060 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects", *
this));
23063 for (
auto it = first; it != last; ++it)
23065 m_value.object->operator[](it.key()) = it.value();
23087 std::is_nothrow_move_constructible<value_t>::value&&
23088 std::is_nothrow_move_assignable<value_t>::value&&
23089 std::is_nothrow_move_constructible<json_value>::value&&
23090 std::is_nothrow_move_assignable<json_value>::value
23093 std::swap(m_type, other.m_type);
23094 std::swap(
m_value, other.m_value);
23097 other.set_parents();
23098 assert_invariant();
23120 std::is_nothrow_move_constructible<value_t>::value&&
23121 std::is_nothrow_move_assignable<value_t>::value&&
23122 std::is_nothrow_move_constructible<json_value>::value&&
23123 std::is_nothrow_move_assignable<json_value>::value
23152 if (JSON_HEDLEY_LIKELY(
is_array()))
23154 std::swap(*(
m_value.array), other);
23158 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23187 std::swap(*(
m_value.object), other);
23191 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23220 std::swap(*(
m_value.string), other);
23224 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23253 std::swap(*(
m_value.binary), other);
23257 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23267 std::swap(*(
m_value.binary), other);
23271 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name()), *
this));
23342 const auto lhs_type = lhs.type();
23343 const auto rhs_type = rhs.type();
23345 if (lhs_type == rhs_type)
23349 case value_t::array:
23350 return *lhs.m_value.array == *rhs.m_value.array;
23352 case value_t::object:
23353 return *lhs.m_value.object == *rhs.m_value.object;
23355 case value_t::null:
23358 case value_t::string:
23359 return *lhs.m_value.string == *rhs.m_value.string;
23361 case value_t::boolean:
23362 return lhs.m_value.boolean == rhs.m_value.boolean;
23364 case value_t::number_integer:
23365 return lhs.m_value.number_integer == rhs.m_value.number_integer;
23367 case value_t::number_unsigned:
23368 return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
23370 case value_t::number_float:
23371 return lhs.m_value.number_float == rhs.m_value.number_float;
23373 case value_t::binary:
23374 return *lhs.m_value.binary == *rhs.m_value.binary;
23380 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23382 return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
23384 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23386 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_integer);
23388 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23390 return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
23392 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23394 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23396 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23398 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
23400 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23402 return lhs.m_value.number_integer ==
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23412 template<
typename ScalarType,
typename std::enable_if<
23413 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23423 template<
typename ScalarType,
typename std::enable_if<
23424 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23450 return !(lhs == rhs);
23457 template<
typename ScalarType,
typename std::enable_if<
23458 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23468 template<
typename ScalarType,
typename std::enable_if<
23469 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23503 const auto lhs_type = lhs.type();
23504 const auto rhs_type = rhs.type();
23506 if (lhs_type == rhs_type)
23510 case value_t::array:
23513 return (*lhs.m_value.array) < (*rhs.m_value.array);
23515 case value_t::object:
23516 return (*lhs.m_value.object) < (*rhs.m_value.object);
23518 case value_t::null:
23521 case value_t::string:
23522 return (*lhs.m_value.string) < (*rhs.m_value.string);
23524 case value_t::boolean:
23525 return (lhs.m_value.boolean) < (rhs.m_value.boolean);
23527 case value_t::number_integer:
23528 return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
23530 case value_t::number_unsigned:
23531 return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
23533 case value_t::number_float:
23534 return (lhs.m_value.number_float) < (rhs.m_value.number_float);
23536 case value_t::binary:
23537 return (*lhs.m_value.binary) < (*rhs.m_value.binary);
23543 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
23545 return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
23547 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
23549 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_integer);
23551 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
23553 return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
23555 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
23557 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_unsigned);
23559 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
23561 return lhs.m_value.number_integer <
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
23563 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
23565 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
23578 template<
typename ScalarType,
typename std::enable_if<
23579 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23589 template<
typename ScalarType,
typename std::enable_if<
23590 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23617 return !(rhs < lhs);
23624 template<
typename ScalarType,
typename std::enable_if<
23625 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23635 template<
typename ScalarType,
typename std::enable_if<
23636 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23663 return !(lhs <= rhs);
23670 template<
typename ScalarType,
typename std::enable_if<
23671 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23681 template<
typename ScalarType,
typename std::enable_if<
23682 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23709 return !(lhs < rhs);
23716 template<
typename ScalarType,
typename std::enable_if<
23717 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23727 template<
typename ScalarType,
typename std::enable_if<
23728 std::is_scalar<ScalarType>::value,
int>
::type = 0>
23777 const bool pretty_print = o.width() > 0;
23778 const auto indentation = pretty_print ? o.width() : 0;
23784 serializer s(detail::output_adapter<char>(o), o.fill());
23785 s.dump(j, pretty_print,
false,
static_cast<unsigned int>(indentation));
23797 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator<<(std::ostream&,
const basic_json&))
23864 template<
typename InputType>
23868 const bool allow_exceptions =
true,
23869 const bool ignore_comments =
false)
23872 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(
true, result);
23902 template<
typename IteratorType>
23907 const bool allow_exceptions =
true,
23908 const bool ignore_comments =
false)
23911 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(
true, result);
23916 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
parse(ptr, ptr + len))
23919 const bool allow_exceptions =
true,
23920 const bool ignore_comments =
false)
23923 parser(i.get(), cb, allow_exceptions, ignore_comments).parse(
true, result);
23957 template<
typename InputType>
23958 static bool accept(InputType&& i,
23959 const bool ignore_comments =
false)
23961 return parser(detail::input_adapter(std::forward<InputType>(i)),
nullptr,
false, ignore_comments).accept(
true);
23964 template<
typename IteratorType>
23965 static bool accept(IteratorType first, IteratorType last,
23966 const bool ignore_comments =
false)
23968 return parser(detail::input_adapter(std::move(first), std::move(last)),
nullptr,
false, ignore_comments).accept(
true);
23972 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
accept(ptr, ptr + len))
23973 static bool accept(detail::span_input_adapter&& i,
23974 const bool ignore_comments =
false)
23976 return parser(i.get(),
nullptr,
false, ignore_comments).accept(
true);
24019 template <
typename InputType,
typename SAX>
24020 JSON_HEDLEY_NON_NULL(2)
24021 static
bool sax_parse(InputType&& i, SAX* sax,
24023 const
bool strict = true,
24024 const
bool ignore_comments = false)
24026 auto ia = detail::input_adapter(std::forward<InputType>(i));
24027 return format == input_format_t::json
24028 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24029 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24032 template<
class IteratorType,
class SAX>
24033 JSON_HEDLEY_NON_NULL(3)
24034 static
bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
24035 input_format_t format = input_format_t::
json,
24036 const
bool strict = true,
24037 const
bool ignore_comments = false)
24039 auto ia = detail::input_adapter(std::move(first), std::move(last));
24040 return format == input_format_t::json
24041 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24042 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24045 template <
typename SAX>
24046 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
sax_parse(ptr, ptr + len, ...))
24047 JSON_HEDLEY_NON_NULL(2)
24048 static
bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
24049 input_format_t format = input_format_t::
json,
24050 const
bool strict = true,
24051 const
bool ignore_comments = false)
24054 return format == input_format_t::json
24056 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
24058 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
24069 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator>>(std::istream&,
basic_json&))
24102 parser(detail::input_adapter(i)).parse(
false, j);
24149 case value_t::null:
24151 case value_t::object:
24153 case value_t::array:
24155 case value_t::string:
24157 case value_t::boolean:
24159 case value_t::binary:
24161 case value_t::discarded:
24162 return "discarded";
24170 JSON_PRIVATE_UNLESS_TESTED:
24176 value_t m_type = value_t::null;
24181 #if JSON_DIAGNOSTICS
24290 std::vector<uint8_t> result;
24297 binary_writer<uint8_t>(o).write_cbor(j);
24302 binary_writer<char>(o).write_cbor(j);
24385 std::vector<uint8_t> result;
24392 binary_writer<uint8_t>(o).write_msgpack(j);
24397 binary_writer<char>(o).write_msgpack(j);
24487 const bool use_size =
false,
24488 const bool use_type =
false)
24490 std::vector<uint8_t> result;
24491 to_ubjson(j, result, use_size, use_type);
24496 const bool use_size =
false,
const bool use_type =
false)
24498 binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
24502 const bool use_size =
false,
const bool use_type =
false)
24504 binary_writer<char>(o).write_ubjson(j, use_size, use_type);
24566 std::vector<uint8_t> result;
24581 binary_writer<uint8_t>(o).write_bson(j);
24589 binary_writer<char>(o).write_bson(j);
24695 template<
typename InputType>
24698 const bool strict =
true,
24699 const bool allow_exceptions =
true,
24703 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24704 auto ia = detail::input_adapter(std::forward<InputType>(i));
24705 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
24706 return res ? result :
basic_json(value_t::discarded);
24712 template<
typename IteratorType>
24715 const bool strict =
true,
24716 const bool allow_exceptions =
true,
24720 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24721 auto ia = detail::input_adapter(std::move(first), std::move(last));
24722 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
24723 return res ? result :
basic_json(value_t::discarded);
24726 template<
typename T>
24728 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_cbor(ptr, ptr + len))
24730 const bool strict =
true,
24731 const bool allow_exceptions =
true,
24734 return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
24741 const bool strict =
true,
24742 const bool allow_exceptions =
true,
24743 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24746 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24749 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
24839 template<
typename InputType>
24842 const bool strict =
true,
24843 const bool allow_exceptions =
true)
24846 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24847 auto ia = detail::input_adapter(std::forward<InputType>(i));
24848 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24849 return res ? result :
basic_json(value_t::discarded);
24855 template<
typename IteratorType>
24858 const bool strict =
true,
24859 const bool allow_exceptions =
true)
24862 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24863 auto ia = detail::input_adapter(std::move(first), std::move(last));
24864 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24865 return res ? result :
basic_json(value_t::discarded);
24869 template<
typename T>
24871 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
24873 const bool strict =
true,
24874 const bool allow_exceptions =
true)
24876 return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
24880 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
24882 const bool strict =
true,
24883 const bool allow_exceptions =
true)
24886 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24889 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24890 return res ? result :
basic_json(value_t::discarded);
24956 template<
typename InputType>
24959 const bool strict =
true,
24960 const bool allow_exceptions =
true)
24963 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24964 auto ia = detail::input_adapter(std::forward<InputType>(i));
24965 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24966 return res ? result :
basic_json(value_t::discarded);
24972 template<
typename IteratorType>
24975 const bool strict =
true,
24976 const bool allow_exceptions =
true)
24979 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24980 auto ia = detail::input_adapter(std::move(first), std::move(last));
24981 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24982 return res ? result :
basic_json(value_t::discarded);
24985 template<
typename T>
24987 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
24989 const bool strict =
true,
24990 const bool allow_exceptions =
true)
24992 return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
24996 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
24998 const bool strict =
true,
24999 const bool allow_exceptions =
true)
25002 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25005 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
25006 return res ? result :
basic_json(value_t::discarded);
25070 template<
typename InputType>
25073 const bool strict =
true,
25074 const bool allow_exceptions =
true)
25077 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25078 auto ia = detail::input_adapter(std::forward<InputType>(i));
25079 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25080 return res ? result :
basic_json(value_t::discarded);
25086 template<
typename IteratorType>
25089 const bool strict =
true,
25090 const bool allow_exceptions =
true)
25093 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25094 auto ia = detail::input_adapter(std::move(first), std::move(last));
25095 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25096 return res ? result :
basic_json(value_t::discarded);
25099 template<
typename T>
25101 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
25103 const bool strict =
true,
25104 const bool allow_exceptions =
true)
25106 return from_bson(ptr, ptr + len, strict, allow_exceptions);
25110 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
25112 const bool strict =
true,
25113 const bool allow_exceptions =
true)
25116 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
25119 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
25120 return res ? result :
basic_json(value_t::discarded);
25166 return ptr.get_unchecked(
this);
25194 return ptr.get_unchecked(
this);
25237 return ptr.get_checked(
this);
25280 return ptr.get_checked(
this);
25308 json_pointer::flatten(
"", *
this, result);
25344 return json_pointer::unflatten(*
this);
25409 enum class patch_operations {add, remove, replace, move, copy, test, invalid};
25411 const auto get_op = [](
const std::string & op)
25415 return patch_operations::add;
25417 if (op ==
"remove")
25419 return patch_operations::remove;
25421 if (op ==
"replace")
25423 return patch_operations::replace;
25427 return patch_operations::move;
25431 return patch_operations::copy;
25435 return patch_operations::test;
25438 return patch_operations::invalid;
25453 if (top_pointer != ptr)
25455 result.
at(top_pointer);
25459 const auto last_path = ptr.
back();
25463 switch (parent.m_type)
25465 case value_t::null:
25466 case value_t::object:
25469 parent[last_path] = val;
25473 case value_t::array:
25475 if (last_path ==
"-")
25482 const auto idx = json_pointer::array_index(last_path);
25483 if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
25486 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range", parent));
25490 parent.insert(parent.begin() +
static_cast<difference_type>(idx), val);
25497 JSON_ASSERT(
false);
25502 const auto operation_remove = [
this, &result](
json_pointer & ptr)
25505 const auto last_path = ptr.back();
25510 if (parent.is_object())
25513 auto it = parent.
find(last_path);
25514 if (JSON_HEDLEY_LIKELY(it != parent.end()))
25520 JSON_THROW(out_of_range::create(403,
"key '" + last_path +
"' not found", *
this));
25523 else if (parent.is_array())
25526 parent.erase(json_pointer::array_index(last_path));
25531 if (JSON_HEDLEY_UNLIKELY(!json_patch.
is_array()))
25533 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects", json_patch));
25537 for (
const auto& val : json_patch)
25540 const auto get_value = [&val](
const std::string & op,
25541 const std::string & member,
25545 auto it = val.m_value.object->find(member);
25548 const auto error_msg = (op ==
"op") ?
"operation" :
"operation '" + op +
"'";
25551 if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
25554 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have member '" + member +
"'", val));
25558 if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
25561 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have string member '" + member +
"'", val));
25569 if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
25571 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects", val));
25575 const auto op = get_value(
"op",
"op",
true).template get<std::string>();
25576 const auto path = get_value(op,
"path",
true).template get<std::string>();
25579 switch (get_op(op))
25581 case patch_operations::add:
25583 operation_add(ptr, get_value(
"add",
"value",
false));
25587 case patch_operations::remove:
25589 operation_remove(ptr);
25593 case patch_operations::replace:
25596 result.
at(ptr) = get_value(
"replace",
"value",
false);
25600 case patch_operations::move:
25602 const auto from_path = get_value(
"move",
"from",
true).template get<std::string>();
25612 operation_remove(from_ptr);
25613 operation_add(ptr, v);
25617 case patch_operations::copy:
25619 const auto from_path = get_value(
"copy",
"from",
true).template get<std::string>();
25628 operation_add(ptr, v);
25632 case patch_operations::test:
25634 bool success =
false;
25639 success = (result.
at(ptr) == get_value(
"test",
"value",
false));
25647 if (JSON_HEDLEY_UNLIKELY(!success))
25649 JSON_THROW(other_error::create(501,
"unsuccessful: " + val.dump(), val));
25659 JSON_THROW(parse_error::create(105, 0,
"operation value '" + op +
"' is invalid", val));
25702 const std::string& path =
"")
25708 if (source == target)
25713 if (source.type() != target.type())
25718 {
"op",
"replace"}, {
"path", path}, {
"value", target}
25723 switch (source.type())
25725 case value_t::array:
25729 while (i < source.size() && i < target.size())
25732 auto temp_diff =
diff(source[i], target[i], path +
"/" + std::to_string(i));
25733 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
25742 while (i < source.size())
25749 {
"path", path +
"/" + std::to_string(i)}
25755 while (i < target.size())
25760 {
"path", path +
"/-"},
25761 {
"value", target[i]}
25769 case value_t::object:
25772 for (
auto it = source.cbegin(); it != source.cend(); ++it)
25775 const auto path_key = path +
"/" + detail::escape(it.key());
25777 if (target.find(it.key()) != target.end())
25780 auto temp_diff =
diff(it.value(), target[it.key()], path_key);
25781 result.
insert(result.
end(), temp_diff.begin(), temp_diff.end());
25788 {
"op",
"remove"}, {
"path", path_key}
25794 for (
auto it = target.cbegin(); it != target.cend(); ++it)
25796 if (source.find(it.key()) == source.end())
25799 const auto path_key = path +
"/" + detail::escape(it.key());
25802 {
"op",
"add"}, {
"path", path_key},
25803 {
"value", it.value()}
25816 {
"op",
"replace"}, {
"path", path}, {
"value", target}
25878 if (apply_patch.is_object())
25884 for (
auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
25886 if (it.value().is_null())
25898 *
this = apply_patch;
25914 NLOHMANN_BASIC_JSON_TPL_DECLARATION
25915 std::string
to_string(
const NLOHMANN_BASIC_JSON_TPL& j)
25940 return nlohmann::detail::hash(j);
25948 struct less<::nlohmann::detail::value_t>
25954 bool operator()(nlohmann::detail::value_t lhs,
25955 nlohmann::detail::value_t rhs)
const noexcept
25957 return nlohmann::detail::operator<(lhs, rhs);
25962 #ifndef JSON_HAS_CPP_20
25971 is_nothrow_move_constructible<nlohmann::json>::value&&
25972 is_nothrow_move_assignable<nlohmann::json>::value
25995 JSON_HEDLEY_NON_NULL(1)
25996 inline
nlohmann::json operator "" _json(const
char* s, std::
size_t n)
26014 JSON_HEDLEY_NON_NULL(1)
26015 inline
nlohmann::json::json_pointer operator "" _json_pointer(const
char* s, std::
size_t n)
26024 #if defined(__clang__)
26025 #pragma GCC diagnostic pop
26030 #undef JSON_INTERNAL_CATCH
26034 #undef JSON_PRIVATE_UNLESS_TESTED
26035 #undef JSON_HAS_CPP_11
26036 #undef JSON_HAS_CPP_14
26037 #undef JSON_HAS_CPP_17
26038 #undef JSON_HAS_CPP_20
26039 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
26040 #undef NLOHMANN_BASIC_JSON_TPL
26041 #undef JSON_EXPLICIT
26046 #undef JSON_HEDLEY_ALWAYS_INLINE
26047 #undef JSON_HEDLEY_ARM_VERSION
26048 #undef JSON_HEDLEY_ARM_VERSION_CHECK
26049 #undef JSON_HEDLEY_ARRAY_PARAM
26050 #undef JSON_HEDLEY_ASSUME
26051 #undef JSON_HEDLEY_BEGIN_C_DECLS
26052 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
26053 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
26054 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
26055 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
26056 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
26057 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
26058 #undef JSON_HEDLEY_CLANG_HAS_WARNING
26059 #undef JSON_HEDLEY_COMPCERT_VERSION
26060 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
26061 #undef JSON_HEDLEY_CONCAT
26062 #undef JSON_HEDLEY_CONCAT3
26063 #undef JSON_HEDLEY_CONCAT3_EX
26064 #undef JSON_HEDLEY_CONCAT_EX
26065 #undef JSON_HEDLEY_CONST
26066 #undef JSON_HEDLEY_CONSTEXPR
26067 #undef JSON_HEDLEY_CONST_CAST
26068 #undef JSON_HEDLEY_CPP_CAST
26069 #undef JSON_HEDLEY_CRAY_VERSION
26070 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
26071 #undef JSON_HEDLEY_C_DECL
26072 #undef JSON_HEDLEY_DEPRECATED
26073 #undef JSON_HEDLEY_DEPRECATED_FOR
26074 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
26075 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
26076 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
26077 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
26078 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
26079 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
26080 #undef JSON_HEDLEY_DIAGNOSTIC_POP
26081 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
26082 #undef JSON_HEDLEY_DMC_VERSION
26083 #undef JSON_HEDLEY_DMC_VERSION_CHECK
26084 #undef JSON_HEDLEY_EMPTY_BASES
26085 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
26086 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
26087 #undef JSON_HEDLEY_END_C_DECLS
26088 #undef JSON_HEDLEY_FLAGS
26089 #undef JSON_HEDLEY_FLAGS_CAST
26090 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
26091 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
26092 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
26093 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
26094 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
26095 #undef JSON_HEDLEY_GCC_HAS_FEATURE
26096 #undef JSON_HEDLEY_GCC_HAS_WARNING
26097 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
26098 #undef JSON_HEDLEY_GCC_VERSION
26099 #undef JSON_HEDLEY_GCC_VERSION_CHECK
26100 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
26101 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
26102 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
26103 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
26104 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
26105 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
26106 #undef JSON_HEDLEY_GNUC_HAS_WARNING
26107 #undef JSON_HEDLEY_GNUC_VERSION
26108 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
26109 #undef JSON_HEDLEY_HAS_ATTRIBUTE
26110 #undef JSON_HEDLEY_HAS_BUILTIN
26111 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
26112 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
26113 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
26114 #undef JSON_HEDLEY_HAS_EXTENSION
26115 #undef JSON_HEDLEY_HAS_FEATURE
26116 #undef JSON_HEDLEY_HAS_WARNING
26117 #undef JSON_HEDLEY_IAR_VERSION
26118 #undef JSON_HEDLEY_IAR_VERSION_CHECK
26119 #undef JSON_HEDLEY_IBM_VERSION
26120 #undef JSON_HEDLEY_IBM_VERSION_CHECK
26121 #undef JSON_HEDLEY_IMPORT
26122 #undef JSON_HEDLEY_INLINE
26123 #undef JSON_HEDLEY_INTEL_CL_VERSION
26124 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
26125 #undef JSON_HEDLEY_INTEL_VERSION
26126 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
26127 #undef JSON_HEDLEY_IS_CONSTANT
26128 #undef JSON_HEDLEY_IS_CONSTEXPR_
26129 #undef JSON_HEDLEY_LIKELY
26130 #undef JSON_HEDLEY_MALLOC
26131 #undef JSON_HEDLEY_MCST_LCC_VERSION
26132 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
26133 #undef JSON_HEDLEY_MESSAGE
26134 #undef JSON_HEDLEY_MSVC_VERSION
26135 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
26136 #undef JSON_HEDLEY_NEVER_INLINE
26137 #undef JSON_HEDLEY_NON_NULL
26138 #undef JSON_HEDLEY_NO_ESCAPE
26139 #undef JSON_HEDLEY_NO_RETURN
26140 #undef JSON_HEDLEY_NO_THROW
26141 #undef JSON_HEDLEY_NULL
26142 #undef JSON_HEDLEY_PELLES_VERSION
26143 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
26144 #undef JSON_HEDLEY_PGI_VERSION
26145 #undef JSON_HEDLEY_PGI_VERSION_CHECK
26146 #undef JSON_HEDLEY_PREDICT
26147 #undef JSON_HEDLEY_PRINTF_FORMAT
26148 #undef JSON_HEDLEY_PRIVATE
26149 #undef JSON_HEDLEY_PUBLIC
26150 #undef JSON_HEDLEY_PURE
26151 #undef JSON_HEDLEY_REINTERPRET_CAST
26152 #undef JSON_HEDLEY_REQUIRE
26153 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
26154 #undef JSON_HEDLEY_REQUIRE_MSG
26155 #undef JSON_HEDLEY_RESTRICT
26157 #undef JSON_HEDLEY_SENTINEL
26158 #undef JSON_HEDLEY_STATIC_ASSERT
26159 #undef JSON_HEDLEY_STATIC_CAST
26160 #undef JSON_HEDLEY_STRINGIFY
26161 #undef JSON_HEDLEY_STRINGIFY_EX
26162 #undef JSON_HEDLEY_SUNPRO_VERSION
26163 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
26164 #undef JSON_HEDLEY_TINYC_VERSION
26165 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
26166 #undef JSON_HEDLEY_TI_ARMCL_VERSION
26167 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
26168 #undef JSON_HEDLEY_TI_CL2000_VERSION
26169 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
26170 #undef JSON_HEDLEY_TI_CL430_VERSION
26171 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
26172 #undef JSON_HEDLEY_TI_CL6X_VERSION
26173 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
26174 #undef JSON_HEDLEY_TI_CL7X_VERSION
26175 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
26176 #undef JSON_HEDLEY_TI_CLPRU_VERSION
26177 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
26178 #undef JSON_HEDLEY_TI_VERSION
26179 #undef JSON_HEDLEY_TI_VERSION_CHECK
26180 #undef JSON_HEDLEY_UNAVAILABLE
26181 #undef JSON_HEDLEY_UNLIKELY
26182 #undef JSON_HEDLEY_UNPREDICTABLE
26183 #undef JSON_HEDLEY_UNREACHABLE
26184 #undef JSON_HEDLEY_UNREACHABLE_RETURN
26185 #undef JSON_HEDLEY_VERSION
26186 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
26187 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
26188 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
26189 #undef JSON_HEDLEY_VERSION_ENCODE
26190 #undef JSON_HEDLEY_WARNING
26193 #undef JSON_HEDLEY_FALL_THROUGH
static basic_json binary(typename binary_t::container_type &&init, std::uint8_t subtype)
explicitly create a binary array (with subtype)
detail::parser_callback_t< basic_json > parser_callback_t
per-element parser callback type
bool contains(KeyT &&key) const
check the existence of an element in a JSON object
const_reverse_iterator crbegin() const noexcept
returns a const reverse iterator to the last element
ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const
access specified object element with default value
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
NumberIntegerType number_integer_t
a type for a number (integer)
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
comparison: equal
static bool sax_parse(InputType &&i, SAX *sax, input_format_t format=input_format_t::json, const bool strict=true, const bool ignore_comments=false)
generate SAX events
detail::exception exception
general exception of the basic_json class
ReferenceType get_ref()
get a reference value (implicit)
static basic_json parse(InputType &&i, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a compatible input
reference emplace_back(Args &&... args)
add an object to an array
static basic_json from_cbor(const T *ptr, std::size_t len, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
basic_json(const value_t v)
create an empty value with a given type
basic_json & operator=(basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
copy assignment
size_type max_size() const noexcept
returns the maximum possible number of elements
static basic_json diff(const basic_json &source, const basic_json &target, const std::string &path="")
creates a diff as a JSON patch
detail::input_format_t input_format_t
value_type & reference
the type of an element reference
const_reverse_iterator crend() const noexcept
returns a const reverse iterator to one before the first
detail::out_of_range out_of_range
exception indicating access out of the defined range
static iteration_proxy< iterator > iterator_wrapper(reference ref) noexcept
wrapper to access iterator member functions in range-based for
iterator begin() noexcept
returns an iterator to the first element
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
static std::vector< uint8_t > to_ubjson(const basic_json &j, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
basic_json(const JsonRef &ref)
static basic_json array(initializer_list_t init={})
explicitly create an array from an initializer list
const_iterator cend() const noexcept
returns a const iterator to one past the last element
reference back()
access the last element
static bool accept(InputType &&i, const bool ignore_comments=false)
check if the input is valid JSON
StringType string_t
a type for a string
size_type size() const noexcept
returns the number of elements
friend std::ostream & operator>>(const basic_json &j, std::ostream &o)
serialize to stream
static basic_json meta()
returns version information on the library
void update(const_reference j)
updates a JSON object from another object, overwriting existing keys
std::size_t size_type
a type to represent container sizes
std::ptrdiff_t difference_type
a type to represent differences between iterators
static basic_json binary(const typename binary_t::container_type &init)
explicitly create a binary array (without subtype)
reference operator+=(basic_json &&val)
add an object to an array
basic_json(const BasicJsonType &val)
create a JSON value from an existing one
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
static basic_json from_cbor(InputType &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
create a JSON value from an input in CBOR format
BooleanType boolean_t
a type for a boolean
void push_back(initializer_list_t init)
add an object to an object
const char * type_name() const noexcept
return the type as string
string_t dump(const int indent=-1, const char indent_char=' ', const bool ensure_ascii=false, const error_handler_t error_handler=error_handler_t::strict) const
serialization
IteratorType erase(IteratorType pos)
remove element given an iterator
static basic_json from_bson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
Create a JSON value from an input in BSON format.
constexpr bool is_structured() const noexcept
return whether type is structured
reference at(size_type idx)
access specified array element with bounds checking
reference front()
access the first element
constexpr bool is_primitive() const noexcept
return whether type is primitive
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
detail::cbor_tag_handler_t cbor_tag_handler_t
how to treat CBOR tags
detail::parse_error parse_error
exception indicating a parse error
constexpr bool is_object() const noexcept
return whether value is an object
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
NumberFloatType number_float_t
a type for a number (floating-point)
json_reverse_iterator< typename basic_json::iterator > reverse_iterator
a reverse iterator for a basic_json container
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
comparison: less than or equal
bool empty() const noexcept
checks whether the container is empty.
friend std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
basic_json(const basic_json &other)
copy constructor
~basic_json() noexcept
destructor
friend struct detail::external_constructor
basic_json(basic_json &&other) noexcept
move constructor
detail::invalid_iterator invalid_iterator
exception indicating errors with iterators
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
comparison: not equal
detail::other_error other_error
exception indicating other library errors
json_value m_value
the value of the current element
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
comparison: greater than or equal
reverse_iterator rend() noexcept
returns an iterator to the reverse-end
ReferenceType get_ref() const
get a reference value (implicit)
auto get() noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
void merge_patch(const basic_json &apply_patch)
applies a JSON Merge Patch
auto get_ptr() noexcept -> decltype(std::declval< basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
ArrayType< basic_json, AllocatorType< basic_json > > array_t
a type for an array
Array get_to(T(&v)[N]) const noexcept(noexcept(JSONSerializer< Array >::from_json(std::declval< const basic_json_t & >(), v)))
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
comparison: greater than
constexpr bool is_boolean() const noexcept
return whether value is a boolean
iteration_proxy< iterator > items() noexcept
helper to access iterator member functions in range-based for
iterator end() noexcept
returns an iterator to one past the last element
void swap(reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
void clear() noexcept
clears the contents
constexpr bool is_binary() const noexcept
return whether value is a binary array
static std::vector< uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
static basic_json object(initializer_list_t init={})
explicitly create an object from an initializer list
reference operator[](size_type idx)
access specified array element
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
iter_impl< basic_json > iterator
an iterator for a basic_json container
static std::vector< 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...
json_reverse_iterator< typename basic_json::const_iterator > const_reverse_iterator
a const reverse iterator for a basic_json container
static basic_json from_ubjson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in UBJSON format
::nlohmann::json_pointer< basic_json > json_pointer
JSON Pointer, see nlohmann::json_pointer.
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
comparison: less than
static basic_json binary(typename binary_t::container_type &&init)
explicitly create a binary array (without subtype)
constexpr bool is_string() const noexcept
return whether value is a string
constexpr bool is_array() const noexcept
return whether value is an array
iterator insert_iterator(const_iterator pos, Args &&... args)
basic_json flatten() const
return flattened JSON value
const value_type & const_reference
the type of an element const reference
void push_back(basic_json &&val)
add an object to an array
size_type count(KeyT &&key) const
returns the number of occurrences of a key in a JSON object
const binary_t & get_binary() const
constexpr bool is_number() const noexcept
return whether value is a number
std::less< StringType > object_comparator_t
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
std::initializer_list< detail::json_ref< basic_json > > initializer_list_t
helper type for initializer lists of basic_json values
ValueType & get_to(ValueType &v) const
static basic_json binary(const typename binary_t::container_type &init, std::uint8_t subtype)
explicitly create a binary array (with subtype)
iterator find(KeyT &&key)
find an element in a JSON object
detail::type_error type_error
exception indicating executing a member function with a wrong type
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
AllocatorType< basic_json > allocator_type
the allocator type
nlohmann::byte_container_with_subtype< BinaryType > binary_t
a type for a packed binary type
JSONSerializer< T, SFINAE > json_serializer
static std::vector< uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
static basic_json from_msgpack(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in MessagePack format
basic_json patch(const basic_json &json_patch) const
applies a JSON patch
basic_json(CompatibleType &&val) noexcept(noexcept(//NOLINT(bugprone-forwarding-reference-overload, bugprone-exception-escape) JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
create a JSON value
basic_json unflatten() const
unflatten a previously flattened JSON value
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
const_iterator cbegin() const noexcept
returns a const iterator to the first element
basic_json(initializer_list_t init, bool type_deduction=true, value_t manual_type=value_t::array)
create a container (array or object) from an initializer list
iterator insert(const_iterator pos, const basic_json &val)
inserts element
iter_impl< const basic_json > const_iterator
a const iterator for a basic_json container
constexpr bool is_discarded() const noexcept
return whether value is discarded
constexpr bool is_null() const noexcept
return whether value is null
ObjectType< StringType, basic_json, object_comparator_t, AllocatorType< std::pair< const StringType, basic_json > >> object_t
a type for an object
auto get() const noexcept(noexcept(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))) -> decltype(std::declval< const basic_json_t & >().template get_impl< ValueType >(detail::priority_tag< 4 > {}))
get a (pointer) value (explicit)
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
static allocator_type get_allocator()
returns the allocator associated with the container
constexpr auto get_ptr() const noexcept -> decltype(std::declval< const basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
reverse_iterator rbegin() noexcept
returns an iterator to the reverse-beginning
a class to store JSON values
BinaryType container_type
the type of the underlying container
void set_subtype(std::uint8_t subtype_) noexcept
sets the binary subtype
byte_container_with_subtype(const container_type &b) noexcept(noexcept(container_type(b)))
byte_container_with_subtype(container_type &&b) noexcept(noexcept(container_type(std::move(b))))
bool operator!=(const byte_container_with_subtype &rhs) const
void clear_subtype() noexcept
clears the binary subtype
byte_container_with_subtype() noexcept(noexcept(container_type()))
byte_container_with_subtype(const container_type &b, std::uint8_t subtype_) noexcept(noexcept(container_type(b)))
constexpr bool has_subtype() const noexcept
return whether the value has a subtype
byte_container_with_subtype(container_type &&b, std::uint8_t subtype_) noexcept(noexcept(container_type(std::move(b))))
constexpr std::uint8_t subtype() const noexcept
return the binary subtype
bool operator==(const byte_container_with_subtype &rhs) const
an internal type for a backed binary type
const std::string & back() const
return last reference token
std::string to_string() const
return a string representation of the JSON pointer
friend bool operator==(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for equality
void pop_back()
remove last reference token
bool empty() const noexcept
return whether pointer points to the root document
friend bool operator!=(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for inequality
void push_back(const std::string &token)
append an unescaped token at the end of the reference pointer
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON pointer
json_pointer(const std::string &s="")
create JSON pointer
friend json_pointer operator/(const json_pointer &lhs, const json_pointer &rhs)
create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
friend json_pointer operator/(const json_pointer &ptr, std::string token)
create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
json_pointer & operator/=(std::string token)
append an unescaped reference token at the end of this JSON pointer
void push_back(std::string &&token)
append an unescaped token at the end of the reference pointer
friend json_pointer operator/(const json_pointer &ptr, std::size_t array_idx)
create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
json_pointer parent_pointer() const
returns the parent of this JSON pointer
constexpr const auto & to_json
constexpr const auto & from_json
basic_json<> json
default JSON class
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
namespace for Niels Lohmann
static auto from_json(BasicJsonType &&j, TargetType &val) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), val))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), val), void())
convert a JSON value to any value type
static auto from_json(BasicJsonType &&j) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), detail::identity_tag< TargetType > {}))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), detail::identity_tag< TargetType > {}))
convert a JSON value to any value type
static auto to_json(BasicJsonType &j, TargetType &&val) noexcept(noexcept(::nlohmann::to_json(j, std::forward< TargetType >(val)))) -> decltype(::nlohmann::to_json(j, std::forward< TargetType >(val)), void())
convert any value type to a JSON value
default JSONSerializer template argument
virtual bool start_object(std::size_t elements)=0
the beginning of an object was read
virtual bool string(string_t &val)=0
a string was read
typename BasicJsonType::number_integer_t number_integer_t
typename BasicJsonType::binary_t binary_t
json_sax & operator=(const json_sax &)=default
virtual bool end_array()=0
the end of an array was read
virtual bool key(string_t &val)=0
an object key was read
typename BasicJsonType::number_unsigned_t number_unsigned_t
virtual bool binary(binary_t &val)=0
a binary string was read
typename BasicJsonType::number_float_t number_float_t
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
json_sax(json_sax &&) noexcept=default
virtual bool boolean(bool val)=0
a boolean value was read
json_sax(const json_sax &)=default
virtual bool end_object()=0
the end of an object was read
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
typename BasicJsonType::string_t string_t
virtual bool number_float(number_float_t val, const string_t &s)=0
an floating-point number was read
virtual bool number_integer(number_integer_t val)=0
an integer number was read
std::pair< iterator, bool > insert(const value_type &value)
ordered_map(std::initializer_list< T > init, const Allocator &alloc=Allocator())
std::vector< std::pair< const Key, T >, Allocator > Container
iterator find(const Key &key)
iterator erase(iterator pos)
void insert(InputIt first, InputIt last)
std::pair< iterator, bool > emplace(const key_type &key, T &&t)
const_iterator find(const Key &key) const
std::pair< iterator, bool > insert(value_type &&value)
size_type erase(const Key &key)
const T & operator[](const Key &key) const
ordered_map(const Allocator &alloc=Allocator())
typename std::enable_if< std::is_convertible< typename std::iterator_traits< InputIt >::iterator_category, std::input_iterator_tag >::value >::type require_input_iter
const T & at(const Key &key) const
ordered_map(It first, It last, const Allocator &alloc=Allocator())
T & operator[](const Key &key)
size_type count(const Key &key) const