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 0
40 #include <initializer_list>
59 #include <forward_list>
64 #include <type_traits>
65 #include <unordered_map>
89 std::size_t chars_read_total = 0;
91 std::size_t chars_read_current_line = 0;
93 std::size_t lines_read = 0;
96 constexpr
operator size_t()
const
98 return chars_read_total;
122 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 13)
123 #if defined(JSON_HEDLEY_VERSION)
124 #undef JSON_HEDLEY_VERSION
126 #define JSON_HEDLEY_VERSION 13
128 #if defined(JSON_HEDLEY_STRINGIFY_EX)
129 #undef JSON_HEDLEY_STRINGIFY_EX
131 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
133 #if defined(JSON_HEDLEY_STRINGIFY)
134 #undef JSON_HEDLEY_STRINGIFY
136 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
138 #if defined(JSON_HEDLEY_CONCAT_EX)
139 #undef JSON_HEDLEY_CONCAT_EX
141 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
143 #if defined(JSON_HEDLEY_CONCAT)
144 #undef JSON_HEDLEY_CONCAT
146 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
148 #if defined(JSON_HEDLEY_CONCAT3_EX)
149 #undef JSON_HEDLEY_CONCAT3_EX
151 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
153 #if defined(JSON_HEDLEY_CONCAT3)
154 #undef JSON_HEDLEY_CONCAT3
156 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
158 #if defined(JSON_HEDLEY_VERSION_ENCODE)
159 #undef JSON_HEDLEY_VERSION_ENCODE
161 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
163 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
164 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
166 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
168 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
169 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
171 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
173 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
174 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
176 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
178 #if defined(JSON_HEDLEY_GNUC_VERSION)
179 #undef JSON_HEDLEY_GNUC_VERSION
181 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
182 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
183 #elif defined(__GNUC__)
184 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
187 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
188 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
190 #if defined(JSON_HEDLEY_GNUC_VERSION)
191 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
193 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
196 #if defined(JSON_HEDLEY_MSVC_VERSION)
197 #undef JSON_HEDLEY_MSVC_VERSION
199 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
200 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
201 #elif defined(_MSC_FULL_VER)
202 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
203 #elif defined(_MSC_VER)
204 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
207 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
208 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
210 #if !defined(_MSC_VER)
211 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
212 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
213 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
214 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
215 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
217 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
220 #if defined(JSON_HEDLEY_INTEL_VERSION)
221 #undef JSON_HEDLEY_INTEL_VERSION
223 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
224 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
225 #elif defined(__INTEL_COMPILER)
226 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
229 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
230 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
232 #if defined(JSON_HEDLEY_INTEL_VERSION)
233 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
235 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
238 #if defined(JSON_HEDLEY_PGI_VERSION)
239 #undef JSON_HEDLEY_PGI_VERSION
241 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
242 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
245 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
246 #undef JSON_HEDLEY_PGI_VERSION_CHECK
248 #if defined(JSON_HEDLEY_PGI_VERSION)
249 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
251 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
254 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
255 #undef JSON_HEDLEY_SUNPRO_VERSION
257 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
258 #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)
259 #elif defined(__SUNPRO_C)
260 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
261 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
262 #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)
263 #elif defined(__SUNPRO_CC)
264 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
267 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
268 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
270 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
271 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
273 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
276 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
277 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
279 #if defined(__EMSCRIPTEN__)
280 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
283 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
284 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
286 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
287 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
289 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
292 #if defined(JSON_HEDLEY_ARM_VERSION)
293 #undef JSON_HEDLEY_ARM_VERSION
295 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
296 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
297 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
298 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
301 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
302 #undef JSON_HEDLEY_ARM_VERSION_CHECK
304 #if defined(JSON_HEDLEY_ARM_VERSION)
305 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
307 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
310 #if defined(JSON_HEDLEY_IBM_VERSION)
311 #undef JSON_HEDLEY_IBM_VERSION
313 #if defined(__ibmxl__)
314 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
315 #elif defined(__xlC__) && defined(__xlC_ver__)
316 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
317 #elif defined(__xlC__)
318 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
321 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
322 #undef JSON_HEDLEY_IBM_VERSION_CHECK
324 #if defined(JSON_HEDLEY_IBM_VERSION)
325 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
327 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
330 #if defined(JSON_HEDLEY_TI_VERSION)
331 #undef JSON_HEDLEY_TI_VERSION
334 defined(__TI_COMPILER_VERSION__) && \
336 defined(__TMS470__) || defined(__TI_ARM__) || \
337 defined(__MSP430__) || \
338 defined(__TMS320C2000__) \
340 #if (__TI_COMPILER_VERSION__ >= 16000000)
341 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
345 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
346 #undef JSON_HEDLEY_TI_VERSION_CHECK
348 #if defined(JSON_HEDLEY_TI_VERSION)
349 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
351 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
354 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
355 #undef JSON_HEDLEY_TI_CL2000_VERSION
357 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
358 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
361 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
362 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
364 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
365 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
367 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
370 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
371 #undef JSON_HEDLEY_TI_CL430_VERSION
373 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
374 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
377 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
378 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
380 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
381 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
383 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
386 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
387 #undef JSON_HEDLEY_TI_ARMCL_VERSION
389 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
390 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
393 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
394 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
396 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
397 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
399 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
402 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
403 #undef JSON_HEDLEY_TI_CL6X_VERSION
405 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
406 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
409 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
410 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
412 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
413 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
415 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
418 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
419 #undef JSON_HEDLEY_TI_CL7X_VERSION
421 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
422 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
425 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
426 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
428 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
429 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
431 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
434 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
435 #undef JSON_HEDLEY_TI_CLPRU_VERSION
437 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
438 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
441 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
442 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
444 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
445 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
447 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
450 #if defined(JSON_HEDLEY_CRAY_VERSION)
451 #undef JSON_HEDLEY_CRAY_VERSION
454 #if defined(_RELEASE_PATCHLEVEL)
455 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
457 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
461 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
462 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
464 #if defined(JSON_HEDLEY_CRAY_VERSION)
465 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
467 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
470 #if defined(JSON_HEDLEY_IAR_VERSION)
471 #undef JSON_HEDLEY_IAR_VERSION
473 #if defined(__IAR_SYSTEMS_ICC__)
475 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
477 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
481 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
482 #undef JSON_HEDLEY_IAR_VERSION_CHECK
484 #if defined(JSON_HEDLEY_IAR_VERSION)
485 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
487 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
490 #if defined(JSON_HEDLEY_TINYC_VERSION)
491 #undef JSON_HEDLEY_TINYC_VERSION
493 #if defined(__TINYC__)
494 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
497 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
498 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
500 #if defined(JSON_HEDLEY_TINYC_VERSION)
501 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
503 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
506 #if defined(JSON_HEDLEY_DMC_VERSION)
507 #undef JSON_HEDLEY_DMC_VERSION
510 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
513 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
514 #undef JSON_HEDLEY_DMC_VERSION_CHECK
516 #if defined(JSON_HEDLEY_DMC_VERSION)
517 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
519 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
522 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
523 #undef JSON_HEDLEY_COMPCERT_VERSION
525 #if defined(__COMPCERT_VERSION__)
526 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
529 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
530 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
532 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
533 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
535 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
538 #if defined(JSON_HEDLEY_PELLES_VERSION)
539 #undef JSON_HEDLEY_PELLES_VERSION
541 #if defined(__POCC__)
542 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
545 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
546 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
548 #if defined(JSON_HEDLEY_PELLES_VERSION)
549 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
551 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
554 #if defined(JSON_HEDLEY_GCC_VERSION)
555 #undef JSON_HEDLEY_GCC_VERSION
558 defined(JSON_HEDLEY_GNUC_VERSION) && \
559 !defined(__clang__) && \
560 !defined(JSON_HEDLEY_INTEL_VERSION) && \
561 !defined(JSON_HEDLEY_PGI_VERSION) && \
562 !defined(JSON_HEDLEY_ARM_VERSION) && \
563 !defined(JSON_HEDLEY_TI_VERSION) && \
564 !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
565 !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
566 !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
567 !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
568 !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
569 !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
570 !defined(__COMPCERT__)
571 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
574 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
575 #undef JSON_HEDLEY_GCC_VERSION_CHECK
577 #if defined(JSON_HEDLEY_GCC_VERSION)
578 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
580 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
583 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
584 #undef JSON_HEDLEY_HAS_ATTRIBUTE
586 #if defined(__has_attribute)
587 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
589 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
592 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
593 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
595 #if defined(__has_attribute)
596 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
598 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
601 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
602 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
604 #if defined(__has_attribute)
605 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
607 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
610 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
611 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
614 defined(__has_cpp_attribute) && \
615 defined(__cplusplus) && \
616 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
617 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
619 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
622 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
623 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
625 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
626 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
628 !defined(JSON_HEDLEY_PGI_VERSION) && \
629 !defined(JSON_HEDLEY_IAR_VERSION) && \
630 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
631 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
632 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
634 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
637 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
638 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
640 #if defined(__has_cpp_attribute) && defined(__cplusplus)
641 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
643 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
646 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
647 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
649 #if defined(__has_cpp_attribute) && defined(__cplusplus)
650 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
652 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
655 #if defined(JSON_HEDLEY_HAS_BUILTIN)
656 #undef JSON_HEDLEY_HAS_BUILTIN
658 #if defined(__has_builtin)
659 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
661 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
664 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
665 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
667 #if defined(__has_builtin)
668 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
670 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
673 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
674 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
676 #if defined(__has_builtin)
677 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
679 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
682 #if defined(JSON_HEDLEY_HAS_FEATURE)
683 #undef JSON_HEDLEY_HAS_FEATURE
685 #if defined(__has_feature)
686 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
688 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
691 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
692 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
694 #if defined(__has_feature)
695 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
697 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
700 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
701 #undef JSON_HEDLEY_GCC_HAS_FEATURE
703 #if defined(__has_feature)
704 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
706 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
709 #if defined(JSON_HEDLEY_HAS_EXTENSION)
710 #undef JSON_HEDLEY_HAS_EXTENSION
712 #if defined(__has_extension)
713 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
715 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
718 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
719 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
721 #if defined(__has_extension)
722 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
724 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
727 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
728 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
730 #if defined(__has_extension)
731 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
733 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
736 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
737 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
739 #if defined(__has_declspec_attribute)
740 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
742 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
745 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
746 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
748 #if defined(__has_declspec_attribute)
749 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
751 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
754 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
755 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
757 #if defined(__has_declspec_attribute)
758 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
760 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
763 #if defined(JSON_HEDLEY_HAS_WARNING)
764 #undef JSON_HEDLEY_HAS_WARNING
766 #if defined(__has_warning)
767 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
769 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
772 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
773 #undef JSON_HEDLEY_GNUC_HAS_WARNING
775 #if defined(__has_warning)
776 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
778 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
781 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
782 #undef JSON_HEDLEY_GCC_HAS_WARNING
784 #if defined(__has_warning)
785 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
787 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
792 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
793 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
795 #if defined(__cplusplus)
796 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
797 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
798 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
799 JSON_HEDLEY_DIAGNOSTIC_PUSH \
800 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
801 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
803 JSON_HEDLEY_DIAGNOSTIC_POP
805 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
806 JSON_HEDLEY_DIAGNOSTIC_PUSH \
807 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
809 JSON_HEDLEY_DIAGNOSTIC_POP
813 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
814 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
817 #if defined(JSON_HEDLEY_CONST_CAST)
818 #undef JSON_HEDLEY_CONST_CAST
820 #if defined(__cplusplus)
821 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
823 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
824 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
825 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
826 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
827 JSON_HEDLEY_DIAGNOSTIC_PUSH \
828 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
830 JSON_HEDLEY_DIAGNOSTIC_POP \
833 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
836 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
837 #undef JSON_HEDLEY_REINTERPRET_CAST
839 #if defined(__cplusplus)
840 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
842 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
845 #if defined(JSON_HEDLEY_STATIC_CAST)
846 #undef JSON_HEDLEY_STATIC_CAST
848 #if defined(__cplusplus)
849 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
851 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
854 #if defined(JSON_HEDLEY_CPP_CAST)
855 #undef JSON_HEDLEY_CPP_CAST
857 #if defined(__cplusplus)
858 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
859 # define JSON_HEDLEY_CPP_CAST(T, expr) \
860 JSON_HEDLEY_DIAGNOSTIC_PUSH \
861 _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
863 JSON_HEDLEY_DIAGNOSTIC_POP
864 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
865 # define JSON_HEDLEY_CPP_CAST(T, expr) \
866 JSON_HEDLEY_DIAGNOSTIC_PUSH \
867 _Pragma("diag_suppress=Pe137") \
868 JSON_HEDLEY_DIAGNOSTIC_POP \
870 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
873 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
877 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
878 defined(__clang__) || \
879 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
880 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
881 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
882 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
883 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
884 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
885 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
886 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
887 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
888 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
889 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
890 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
891 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
892 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
893 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
894 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
895 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
896 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
897 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
899 #define JSON_HEDLEY_PRAGMA(value)
902 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
903 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
905 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
906 #undef JSON_HEDLEY_DIAGNOSTIC_POP
908 #if defined(__clang__)
909 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
910 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
911 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
912 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
913 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
914 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
915 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
916 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
917 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
918 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
919 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
920 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
921 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
922 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
924 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
925 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
926 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
927 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
928 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
929 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
930 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
931 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
932 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
933 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
934 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
936 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
937 #define JSON_HEDLEY_DIAGNOSTIC_POP
940 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
941 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
943 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
944 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
945 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
946 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
947 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
948 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
949 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
950 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
951 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
952 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
954 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
955 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
956 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
957 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
958 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
959 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
960 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
961 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
962 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
963 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
964 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
965 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
966 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
967 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
968 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
969 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
970 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
971 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
972 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
973 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
975 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
978 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
979 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
981 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
982 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
983 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
984 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
985 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
986 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
987 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
988 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
989 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
990 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
992 JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
993 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
994 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
995 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
996 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
997 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
998 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
999 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1000 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1002 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1005 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1006 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1008 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1009 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1010 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1011 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1012 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1013 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1014 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1015 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1016 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1017 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1018 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1019 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1021 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1022 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1023 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1024 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1025 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1026 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1028 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1031 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1032 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1034 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1035 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1036 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1037 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1038 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1039 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1041 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1044 #if defined(JSON_HEDLEY_DEPRECATED)
1045 #undef JSON_HEDLEY_DEPRECATED
1047 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1048 #undef JSON_HEDLEY_DEPRECATED_FOR
1050 #if JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
1051 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1052 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1053 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1054 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1055 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1057 JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
1058 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1059 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1060 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1061 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1062 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1063 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1064 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1065 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1066 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1067 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1068 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1069 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1071 JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1072 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1073 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
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_DEPRECATED(since) __attribute__((__deprecated__))
1086 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1088 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1089 JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
1090 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1091 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1092 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1093 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1094 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1096 #define JSON_HEDLEY_DEPRECATED(since)
1097 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1100 #if defined(JSON_HEDLEY_UNAVAILABLE)
1101 #undef JSON_HEDLEY_UNAVAILABLE
1104 JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1105 JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1106 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1107 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1109 #define JSON_HEDLEY_UNAVAILABLE(available_since)
1118 #if (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1119 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1120 #define _MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1121 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1122 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1123 #define _MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1125 JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1126 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1127 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1128 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1129 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1130 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1131 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1132 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1133 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1134 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1135 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1136 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1137 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1138 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1139 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1140 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1141 #define __attribute__((__warn_unused_result__))
1142 #define _MSG(msg) __attribute__((__warn_unused_result__))
1143 #elif defined(_Check_return_)
1144 #define _Check_return_
1145 #define _MSG(msg) _Check_return_
1151 #if defined(JSON_HEDLEY_SENTINEL)
1152 #undef JSON_HEDLEY_SENTINEL
1155 JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1156 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1157 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1158 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
1159 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1161 #define JSON_HEDLEY_SENTINEL(position)
1164 #if defined(JSON_HEDLEY_NO_RETURN)
1165 #undef JSON_HEDLEY_NO_RETURN
1167 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1168 #define JSON_HEDLEY_NO_RETURN __noreturn
1169 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1170 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1171 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1172 #define JSON_HEDLEY_NO_RETURN _Noreturn
1173 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1174 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1176 JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1177 JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1178 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1179 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1180 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1181 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1182 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1183 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1184 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1185 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1186 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1187 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1188 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1189 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1190 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1191 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1192 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1193 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1194 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1195 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1196 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1197 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1198 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1199 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1200 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1201 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1202 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1204 #define JSON_HEDLEY_NO_RETURN
1207 #if defined(JSON_HEDLEY_NO_ESCAPE)
1208 #undef JSON_HEDLEY_NO_ESCAPE
1210 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1211 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1213 #define JSON_HEDLEY_NO_ESCAPE
1216 #if defined(JSON_HEDLEY_UNREACHABLE)
1217 #undef JSON_HEDLEY_UNREACHABLE
1219 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1220 #undef JSON_HEDLEY_UNREACHABLE_RETURN
1222 #if defined(JSON_HEDLEY_ASSUME)
1223 #undef JSON_HEDLEY_ASSUME
1226 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1227 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1228 #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1229 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1230 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1232 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1233 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1234 #if defined(__cplusplus)
1235 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1237 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1241 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1242 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1243 JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1244 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1245 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
1246 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1247 #elif defined(JSON_HEDLEY_ASSUME)
1248 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1250 #if !defined(JSON_HEDLEY_ASSUME)
1251 #if defined(JSON_HEDLEY_UNREACHABLE)
1252 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1254 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1257 #if defined(JSON_HEDLEY_UNREACHABLE)
1259 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1260 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1261 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1263 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1266 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1268 #if !defined(JSON_HEDLEY_UNREACHABLE)
1269 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1272 JSON_HEDLEY_DIAGNOSTIC_PUSH
1273 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1274 #pragma clang diagnostic ignored "-Wpedantic"
1276 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1277 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1279 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1280 #if defined(__clang__)
1281 #pragma clang diagnostic ignored "-Wvariadic-macros"
1282 #elif defined(JSON_HEDLEY_GCC_VERSION)
1283 #pragma GCC diagnostic ignored "-Wvariadic-macros"
1286 #if defined(JSON_HEDLEY_NON_NULL)
1287 #undef JSON_HEDLEY_NON_NULL
1290 JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1291 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1292 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1293 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1294 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1296 #define JSON_HEDLEY_NON_NULL(...)
1298 JSON_HEDLEY_DIAGNOSTIC_POP
1300 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1301 #undef JSON_HEDLEY_PRINTF_FORMAT
1303 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1304 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1305 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1306 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1308 JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1309 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1310 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1311 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1312 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1313 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1314 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1315 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1316 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1317 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1318 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1319 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1320 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1321 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1322 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1323 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1324 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1325 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1326 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1328 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1331 #if defined(JSON_HEDLEY_CONSTEXPR)
1332 #undef JSON_HEDLEY_CONSTEXPR
1334 #if defined(__cplusplus)
1335 #if __cplusplus >= 201103L
1336 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1339 #if !defined(JSON_HEDLEY_CONSTEXPR)
1340 #define JSON_HEDLEY_CONSTEXPR
1343 #if defined(JSON_HEDLEY_PREDICT)
1344 #undef JSON_HEDLEY_PREDICT
1346 #if defined(JSON_HEDLEY_LIKELY)
1347 #undef JSON_HEDLEY_LIKELY
1349 #if defined(JSON_HEDLEY_UNLIKELY)
1350 #undef JSON_HEDLEY_UNLIKELY
1352 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1353 #undef JSON_HEDLEY_UNPREDICTABLE
1355 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1356 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1359 JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
1360 JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
1361 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))
1362 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))
1363 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))
1364 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )
1365 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )
1367 JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
1368 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1369 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1370 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1371 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1372 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1373 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1374 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1375 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1376 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1377 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1378 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1379 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1380 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1381 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1382 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1383 (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1384 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1386 double hedley_probability_ = (probability); \
1387 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1389 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1391 double hedley_probability_ = (probability); \
1392 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1394 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1395 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1397 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1398 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1399 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1400 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1401 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1403 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1404 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1407 #if defined(JSON_HEDLEY_MALLOC)
1408 #undef JSON_HEDLEY_MALLOC
1411 JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1412 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1413 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1414 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1415 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1416 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1417 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1418 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1419 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1420 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1421 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1422 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1423 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1424 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1425 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1426 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1427 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1428 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1429 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1430 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1431 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
1432 #define JSON_HEDLEY_MALLOC __declspec(restrict)
1434 #define JSON_HEDLEY_MALLOC
1437 #if defined(JSON_HEDLEY_PURE)
1438 #undef JSON_HEDLEY_PURE
1441 JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1442 JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1443 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1444 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1445 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1446 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1447 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1448 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1449 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1450 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1451 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1452 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1453 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1454 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1455 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1456 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1457 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1458 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1459 # define JSON_HEDLEY_PURE __attribute__((__pure__))
1460 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1461 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1462 #elif defined(__cplusplus) && \
1464 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1465 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1466 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1468 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1470 # define JSON_HEDLEY_PURE
1473 #if defined(JSON_HEDLEY_CONST)
1474 #undef JSON_HEDLEY_CONST
1477 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1478 JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1479 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1480 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1481 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1482 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1483 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1484 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1485 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1486 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1487 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1488 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1489 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1490 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1491 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1492 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1493 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1494 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1495 #define JSON_HEDLEY_CONST __attribute__((__const__))
1497 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1498 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1500 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1503 #if defined(JSON_HEDLEY_RESTRICT)
1504 #undef JSON_HEDLEY_RESTRICT
1506 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1507 #define JSON_HEDLEY_RESTRICT restrict
1509 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1510 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1511 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1512 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1513 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1514 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1515 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1516 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1517 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1518 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1519 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1520 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1522 #define JSON_HEDLEY_RESTRICT __restrict
1523 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1524 #define JSON_HEDLEY_RESTRICT _Restrict
1526 #define JSON_HEDLEY_RESTRICT
1529 #if defined(JSON_HEDLEY_INLINE)
1530 #undef JSON_HEDLEY_INLINE
1533 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1534 (defined(__cplusplus) && (__cplusplus >= 199711L))
1535 #define JSON_HEDLEY_INLINE inline
1537 defined(JSON_HEDLEY_GCC_VERSION) || \
1538 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1539 #define JSON_HEDLEY_INLINE __inline__
1541 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1542 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1543 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1544 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1545 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1546 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1547 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1548 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1549 #define JSON_HEDLEY_INLINE __inline
1551 #define JSON_HEDLEY_INLINE
1554 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1555 #undef JSON_HEDLEY_ALWAYS_INLINE
1558 JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1559 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1560 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1561 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1562 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1563 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1564 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1565 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1566 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1567 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1568 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1569 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1570 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1571 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1572 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1573 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1574 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1575 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1576 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
1577 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1578 #elif defined(__cplusplus) && \
1580 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1581 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1582 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1583 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1584 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1585 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1587 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1588 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1589 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1591 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1594 #if defined(JSON_HEDLEY_NEVER_INLINE)
1595 #undef JSON_HEDLEY_NEVER_INLINE
1598 JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1599 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1600 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1601 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1602 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1603 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1604 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1605 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1606 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1607 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1608 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1609 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1610 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1611 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1612 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1613 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1614 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1615 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1616 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1617 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1618 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1619 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1620 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1621 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1622 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1623 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1624 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1625 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1626 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1627 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1629 #define JSON_HEDLEY_NEVER_INLINE
1632 #if defined(JSON_HEDLEY_PRIVATE)
1633 #undef JSON_HEDLEY_PRIVATE
1635 #if defined(JSON_HEDLEY_PUBLIC)
1636 #undef JSON_HEDLEY_PUBLIC
1638 #if defined(JSON_HEDLEY_IMPORT)
1639 #undef JSON_HEDLEY_IMPORT
1641 #if defined(_WIN32) || defined(__CYGWIN__)
1642 # define JSON_HEDLEY_PRIVATE
1643 # define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1644 # define JSON_HEDLEY_IMPORT __declspec(dllimport)
1647 JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1648 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1649 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1650 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1651 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1652 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1654 defined(__TI_EABI__) && \
1656 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1657 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1660 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1661 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1663 # define JSON_HEDLEY_PRIVATE
1664 # define JSON_HEDLEY_PUBLIC
1666 # define JSON_HEDLEY_IMPORT extern
1669 #if defined(JSON_HEDLEY_NO_THROW)
1670 #undef JSON_HEDLEY_NO_THROW
1673 JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1674 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1675 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1676 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1678 JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1679 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1680 #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1682 #define JSON_HEDLEY_NO_THROW
1685 #if defined(JSON_HEDLEY_FALL_THROUGH)
1686 #undef JSON_HEDLEY_FALL_THROUGH
1689 JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1690 JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
1691 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1692 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1693 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1694 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1695 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1696 #elif defined(__fallthrough)
1697 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1699 #define JSON_HEDLEY_FALL_THROUGH
1706 JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1707 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
1708 #define __attribute__((__returns_nonnull__))
1709 #elif defined(_Ret_notnull_)
1710 #define _Ret_notnull_
1715 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1716 #undef JSON_HEDLEY_ARRAY_PARAM
1719 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1720 !defined(__STDC_NO_VLA__) && \
1721 !defined(__cplusplus) && \
1722 !defined(JSON_HEDLEY_PGI_VERSION) && \
1723 !defined(JSON_HEDLEY_TINYC_VERSION)
1724 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1726 #define JSON_HEDLEY_ARRAY_PARAM(name)
1729 #if defined(JSON_HEDLEY_IS_CONSTANT)
1730 #undef JSON_HEDLEY_IS_CONSTANT
1732 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1733 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1737 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1738 #undef JSON_HEDLEY_IS_CONSTEXPR_
1741 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1742 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1743 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1744 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1745 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1746 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1747 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1748 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1749 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1750 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1752 #if !defined(__cplusplus)
1754 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1755 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1756 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1757 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1758 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1759 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1760 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1761 #if defined(__INTPTR_TYPE__)
1762 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1765 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1769 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1770 !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1771 !defined(JSON_HEDLEY_PGI_VERSION) && \
1772 !defined(JSON_HEDLEY_IAR_VERSION)) || \
1773 JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
1774 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1775 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1776 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1777 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1778 #if defined(__INTPTR_TYPE__)
1779 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1782 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1785 defined(JSON_HEDLEY_GCC_VERSION) || \
1786 defined(JSON_HEDLEY_INTEL_VERSION) || \
1787 defined(JSON_HEDLEY_TINYC_VERSION) || \
1788 defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1789 JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1790 defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1791 defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1792 defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1793 defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1795 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1799 ((void*) ((expr) * 0L) ) : \
1800 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1806 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1807 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1808 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1810 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1812 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1813 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1815 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1818 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1819 #undef JSON_HEDLEY_BEGIN_C_DECLS
1821 #if defined(JSON_HEDLEY_END_C_DECLS)
1822 #undef JSON_HEDLEY_END_C_DECLS
1824 #if defined(JSON_HEDLEY_C_DECL)
1825 #undef JSON_HEDLEY_C_DECL
1827 #if defined(__cplusplus)
1828 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1829 #define JSON_HEDLEY_END_C_DECLS }
1830 #define JSON_HEDLEY_C_DECL extern "C"
1832 #define JSON_HEDLEY_BEGIN_C_DECLS
1833 #define JSON_HEDLEY_END_C_DECLS
1834 #define JSON_HEDLEY_C_DECL
1837 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1838 #undef JSON_HEDLEY_STATIC_ASSERT
1841 !defined(__cplusplus) && ( \
1842 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1843 JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
1844 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1845 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1846 defined(_Static_assert) \
1848 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1850 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1851 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0)
1852 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1854 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1857 #if defined(JSON_HEDLEY_NULL)
1858 #undef JSON_HEDLEY_NULL
1860 #if defined(__cplusplus)
1861 #if __cplusplus >= 201103L
1862 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1864 #define JSON_HEDLEY_NULL NULL
1866 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1869 #define JSON_HEDLEY_NULL NULL
1871 #define JSON_HEDLEY_NULL ((void*) 0)
1874 #if defined(JSON_HEDLEY_MESSAGE)
1875 #undef JSON_HEDLEY_MESSAGE
1877 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1878 # define JSON_HEDLEY_MESSAGE(msg) \
1879 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1880 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1881 JSON_HEDLEY_PRAGMA(message msg) \
1882 JSON_HEDLEY_DIAGNOSTIC_POP
1884 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1885 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1886 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1887 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1888 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1889 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1890 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1891 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1892 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1894 # define JSON_HEDLEY_MESSAGE(msg)
1897 #if defined(JSON_HEDLEY_WARNING)
1898 #undef JSON_HEDLEY_WARNING
1900 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1901 # define JSON_HEDLEY_WARNING(msg) \
1902 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1903 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1904 JSON_HEDLEY_PRAGMA(clang warning msg) \
1905 JSON_HEDLEY_DIAGNOSTIC_POP
1907 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1908 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1909 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1910 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1911 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1912 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1914 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1917 #if defined(JSON_HEDLEY_REQUIRE)
1918 #undef JSON_HEDLEY_REQUIRE
1920 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1921 #undef JSON_HEDLEY_REQUIRE_MSG
1923 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1924 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1925 # define JSON_HEDLEY_REQUIRE(expr) \
1926 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1927 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1928 __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1929 JSON_HEDLEY_DIAGNOSTIC_POP
1930 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1931 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1932 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1933 __attribute__((diagnose_if(!(expr), msg, "error"))) \
1934 JSON_HEDLEY_DIAGNOSTIC_POP
1936 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1937 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1940 # define JSON_HEDLEY_REQUIRE(expr)
1941 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1944 #if defined(JSON_HEDLEY_FLAGS)
1945 #undef JSON_HEDLEY_FLAGS
1947 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1948 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1951 #if defined(JSON_HEDLEY_FLAGS_CAST)
1952 #undef JSON_HEDLEY_FLAGS_CAST
1954 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1955 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1956 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1957 _Pragma("warning(disable:188)") \
1959 JSON_HEDLEY_DIAGNOSTIC_POP \
1962 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1965 #if defined(JSON_HEDLEY_EMPTY_BASES)
1966 #undef JSON_HEDLEY_EMPTY_BASES
1968 #if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
1969 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1971 #define JSON_HEDLEY_EMPTY_BASES
1976 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1977 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1979 #if defined(__clang__)
1980 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1982 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1985 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1986 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1988 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1990 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1991 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1993 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1995 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1996 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1998 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2000 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2001 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2003 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2005 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2006 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2008 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2010 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2011 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2013 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2015 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2016 #undef JSON_HEDLEY_CLANG_HAS_WARNING
2018 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2027 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2028 #if defined(__clang__)
2029 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2030 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2032 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2033 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2034 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2040 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2041 #define JSON_HAS_CPP_20
2042 #define JSON_HAS_CPP_17
2043 #define JSON_HAS_CPP_14
2044 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2045 #define JSON_HAS_CPP_17
2046 #define JSON_HAS_CPP_14
2047 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2048 #define JSON_HAS_CPP_14
2052 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
2053 #pragma GCC diagnostic push
2054 #pragma GCC diagnostic ignored "-Wfloat-equal"
2058 #if defined(__clang__)
2059 #pragma GCC diagnostic push
2060 #pragma GCC diagnostic ignored "-Wdocumentation"
2064 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2065 #define JSON_THROW(exception) throw exception
2066 #define JSON_TRY try
2067 #define JSON_CATCH(exception) catch(exception)
2068 #define JSON_INTERNAL_CATCH(exception) catch(exception)
2071 #define JSON_THROW(exception) std::abort()
2072 #define JSON_TRY if(true)
2073 #define JSON_CATCH(exception) if(false)
2074 #define JSON_INTERNAL_CATCH(exception) if(false)
2078 #if defined(JSON_THROW_USER)
2080 #define JSON_THROW JSON_THROW_USER
2082 #if defined(JSON_TRY_USER)
2084 #define JSON_TRY JSON_TRY_USER
2086 #if defined(JSON_CATCH_USER)
2088 #define JSON_CATCH JSON_CATCH_USER
2089 #undef JSON_INTERNAL_CATCH
2090 #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2092 #if defined(JSON_INTERNAL_CATCH_USER)
2093 #undef JSON_INTERNAL_CATCH
2094 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2098 #if !defined(JSON_ASSERT)
2100 #define JSON_ASSERT(x) assert(x)
2108 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2109 template<typename BasicJsonType> \
2110 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2112 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2113 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2114 auto it = std::find_if(std::begin(m), std::end(m), \
2115 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2117 return ej_pair.first == e; \
2119 j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2121 template<typename BasicJsonType> \
2122 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2124 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2125 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2126 auto it = std::find_if(std::begin(m), std::end(m), \
2127 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2129 return ej_pair.second == j; \
2131 e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2137 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2138 template<template<typename, typename, typename...> class ObjectType, \
2139 template<typename, typename...> class ArrayType, \
2140 class StringType, class BooleanType, class NumberIntegerType, \
2141 class NumberUnsignedType, class NumberFloatType, \
2142 template<typename> class AllocatorType, \
2143 template<typename, typename = void> class JSONSerializer, \
2146 #define NLOHMANN_BASIC_JSON_TPL \
2147 basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2148 NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2149 AllocatorType, JSONSerializer, BinaryType>
2153 #define NLOHMANN_JSON_EXPAND( x ) x
2154 #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
2155 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2156 NLOHMANN_JSON_PASTE64, \
2157 NLOHMANN_JSON_PASTE63, \
2158 NLOHMANN_JSON_PASTE62, \
2159 NLOHMANN_JSON_PASTE61, \
2160 NLOHMANN_JSON_PASTE60, \
2161 NLOHMANN_JSON_PASTE59, \
2162 NLOHMANN_JSON_PASTE58, \
2163 NLOHMANN_JSON_PASTE57, \
2164 NLOHMANN_JSON_PASTE56, \
2165 NLOHMANN_JSON_PASTE55, \
2166 NLOHMANN_JSON_PASTE54, \
2167 NLOHMANN_JSON_PASTE53, \
2168 NLOHMANN_JSON_PASTE52, \
2169 NLOHMANN_JSON_PASTE51, \
2170 NLOHMANN_JSON_PASTE50, \
2171 NLOHMANN_JSON_PASTE49, \
2172 NLOHMANN_JSON_PASTE48, \
2173 NLOHMANN_JSON_PASTE47, \
2174 NLOHMANN_JSON_PASTE46, \
2175 NLOHMANN_JSON_PASTE45, \
2176 NLOHMANN_JSON_PASTE44, \
2177 NLOHMANN_JSON_PASTE43, \
2178 NLOHMANN_JSON_PASTE42, \
2179 NLOHMANN_JSON_PASTE41, \
2180 NLOHMANN_JSON_PASTE40, \
2181 NLOHMANN_JSON_PASTE39, \
2182 NLOHMANN_JSON_PASTE38, \
2183 NLOHMANN_JSON_PASTE37, \
2184 NLOHMANN_JSON_PASTE36, \
2185 NLOHMANN_JSON_PASTE35, \
2186 NLOHMANN_JSON_PASTE34, \
2187 NLOHMANN_JSON_PASTE33, \
2188 NLOHMANN_JSON_PASTE32, \
2189 NLOHMANN_JSON_PASTE31, \
2190 NLOHMANN_JSON_PASTE30, \
2191 NLOHMANN_JSON_PASTE29, \
2192 NLOHMANN_JSON_PASTE28, \
2193 NLOHMANN_JSON_PASTE27, \
2194 NLOHMANN_JSON_PASTE26, \
2195 NLOHMANN_JSON_PASTE25, \
2196 NLOHMANN_JSON_PASTE24, \
2197 NLOHMANN_JSON_PASTE23, \
2198 NLOHMANN_JSON_PASTE22, \
2199 NLOHMANN_JSON_PASTE21, \
2200 NLOHMANN_JSON_PASTE20, \
2201 NLOHMANN_JSON_PASTE19, \
2202 NLOHMANN_JSON_PASTE18, \
2203 NLOHMANN_JSON_PASTE17, \
2204 NLOHMANN_JSON_PASTE16, \
2205 NLOHMANN_JSON_PASTE15, \
2206 NLOHMANN_JSON_PASTE14, \
2207 NLOHMANN_JSON_PASTE13, \
2208 NLOHMANN_JSON_PASTE12, \
2209 NLOHMANN_JSON_PASTE11, \
2210 NLOHMANN_JSON_PASTE10, \
2211 NLOHMANN_JSON_PASTE9, \
2212 NLOHMANN_JSON_PASTE8, \
2213 NLOHMANN_JSON_PASTE7, \
2214 NLOHMANN_JSON_PASTE6, \
2215 NLOHMANN_JSON_PASTE5, \
2216 NLOHMANN_JSON_PASTE4, \
2217 NLOHMANN_JSON_PASTE3, \
2218 NLOHMANN_JSON_PASTE2, \
2219 NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2220 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2221 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2222 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2223 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2224 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2225 #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)
2226 #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)
2227 #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)
2228 #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)
2229 #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)
2230 #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)
2231 #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)
2232 #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)
2233 #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)
2234 #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)
2235 #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)
2236 #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)
2237 #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)
2238 #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)
2239 #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)
2240 #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)
2241 #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)
2242 #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)
2243 #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)
2244 #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)
2245 #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)
2246 #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)
2247 #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)
2248 #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)
2249 #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)
2250 #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)
2251 #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)
2252 #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)
2253 #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)
2254 #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)
2255 #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)
2256 #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)
2257 #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)
2258 #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)
2259 #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)
2260 #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)
2261 #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)
2262 #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)
2263 #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)
2264 #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)
2265 #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)
2266 #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)
2267 #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)
2268 #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)
2269 #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)
2270 #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)
2271 #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)
2272 #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)
2273 #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)
2274 #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)
2275 #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)
2276 #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)
2277 #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)
2278 #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)
2279 #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)
2280 #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)
2281 #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)
2282 #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)
2284 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2285 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2292 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2293 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__)) } \
2294 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__)) }
2301 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2302 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__)) } \
2303 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__)) }
2305 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2306 #define JSON_USE_IMPLICIT_CONVERSIONS 1
2309 #if JSON_USE_IMPLICIT_CONVERSIONS
2310 #define JSON_EXPLICIT
2312 #define JSON_EXPLICIT explicit
2352 class exception :
public std::exception
2357 const char* what() const noexcept
override
2366 JSON_HEDLEY_NON_NULL(3)
2367 exception(
int id_, const
char* what_arg) :
id(id_), m(what_arg) {}
2369 static std::string name(
const std::string& ename,
int id_)
2371 return "[json.exception." + ename +
"." + std::to_string(id_) +
"] ";
2376 std::runtime_error m;
2424 class parse_error :
public exception
2436 static parse_error create(
int id_,
const position_t& pos,
const std::string& what_arg)
2438 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2439 position_string(pos) +
": " + what_arg;
2440 return parse_error(id_, pos.chars_read_total, w.c_str());
2443 static parse_error create(
int id_, std::size_t byte_,
const std::string& what_arg)
2445 std::string w = exception::name(
"parse_error", id_) +
"parse error" +
2446 (byte_ != 0 ? (
" at byte " + std::to_string(byte_)) :
"") +
2448 return parse_error(id_, byte_, w.c_str());
2460 const std::size_t byte;
2463 parse_error(
int id_, std::size_t byte_,
const char* what_arg)
2464 : exception(id_, what_arg), byte(byte_) {}
2466 static std::string position_string(
const position_t& pos)
2468 return " at line " + std::to_string(pos.lines_read + 1) +
2469 ", column " + std::to_string(pos.chars_read_current_line);
2510 class invalid_iterator :
public exception
2513 static invalid_iterator create(
int id_,
const std::string& what_arg)
2515 std::string w = exception::name(
"invalid_iterator", id_) + what_arg;
2516 return invalid_iterator(id_, w.c_str());
2520 JSON_HEDLEY_NON_NULL(3)
2521 invalid_iterator(
int id_, const
char* what_arg)
2522 : exception(id_, what_arg) {}
2564 class type_error :
public exception
2567 static type_error create(
int id_,
const std::string& what_arg)
2569 std::string w = exception::name(
"type_error", id_) + what_arg;
2570 return type_error(id_, w.c_str());
2574 JSON_HEDLEY_NON_NULL(3)
2575 type_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
2611 class out_of_range :
public exception
2614 static out_of_range create(
int id_,
const std::string& what_arg)
2616 std::string w = exception::name(
"out_of_range", id_) + what_arg;
2617 return out_of_range(id_, w.c_str());
2621 JSON_HEDLEY_NON_NULL(3)
2622 out_of_range(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
2649 class other_error :
public exception
2652 static other_error create(
int id_,
const std::string& what_arg)
2654 std::string w = exception::name(
"other_error", id_) + what_arg;
2655 return other_error(id_, w.c_str());
2659 JSON_HEDLEY_NON_NULL(3)
2660 other_error(
int id_, const
char* what_arg) : exception(id_, what_arg) {}
2671 #include <type_traits>
2678 template<
bool B,
typename T =
void>
2679 using enable_if_t =
typename std::enable_if<B, T>::type;
2681 template<
typename T>
2682 using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
2686 template<std::size_t... Ints>
2687 struct index_sequence
2689 using type = index_sequence;
2690 using value_type = std::size_t;
2691 static constexpr std::size_t size() noexcept
2693 return sizeof...(Ints);
2697 template<
class Sequence1,
class Sequence2>
2698 struct merge_and_renumber;
2700 template<std::size_t... I1, std::size_t... I2>
2701 struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
2702 : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
2704 template<std::
size_t N>
2705 struct make_index_sequence
2706 : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
2707 typename make_index_sequence < N - N / 2 >::type > {};
2709 template<>
struct make_index_sequence<0> : index_sequence<> {};
2710 template<>
struct make_index_sequence<1> : index_sequence<0> {};
2712 template<
typename... Ts>
2713 using index_sequence_for = make_index_sequence<
sizeof...(Ts)>;
2716 template<
unsigned N>
struct priority_tag : priority_tag < N - 1 > {};
2717 template<>
struct priority_tag<0> {};
2720 template<
typename T>
2723 static constexpr T value{};
2726 template<
typename T>
2727 constexpr T static_const<T>::value;
2735 #include <type_traits>
2750 template<
typename ...Ts>
struct make_void
2754 template<
typename ...Ts>
using void_t =
typename make_void<Ts...>::type;
2765 template<
typename It,
typename =
void>
2766 struct iterator_types {};
2768 template<
typename It>
2769 struct iterator_types <
2771 void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
2772 typename It::reference, typename It::iterator_category >>
2774 using difference_type =
typename It::difference_type;
2775 using value_type =
typename It::value_type;
2776 using pointer =
typename It::pointer;
2777 using reference =
typename It::reference;
2778 using iterator_category =
typename It::iterator_category;
2783 template<
typename T,
typename =
void>
2784 struct iterator_traits
2788 template<
typename T>
2789 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
2794 template<
typename T>
2795 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
2797 using iterator_category = std::random_access_iterator_tag;
2798 using value_type = T;
2799 using difference_type = ptrdiff_t;
2801 using reference = T&;
2813 #include <type_traits>
2825 nonesuch() =
delete;
2826 ~nonesuch() =
delete;
2827 nonesuch(nonesuch
const&) =
delete;
2828 nonesuch(nonesuch
const&&) =
delete;
2829 void operator=(nonesuch
const&) =
delete;
2830 void operator=(nonesuch&&) =
delete;
2833 template<
class Default,
2835 template<
class...>
class Op,
2839 using value_t = std::false_type;
2840 using type = Default;
2843 template<
class Default,
template<
class...>
class Op,
class... Args>
2844 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2846 using value_t = std::true_type;
2847 using type = Op<Args...>;
2850 template<
template<
class...>
class Op,
class... Args>
2851 using is_detected =
typename detector<nonesuch, void, Op, Args...>::value_t;
2853 template<
template<
class...>
class Op,
class... Args>
2854 using detected_t =
typename detector<nonesuch, void, Op, Args...>::type;
2856 template<
class Default,
template<
class...>
class Op,
class... Args>
2857 using detected_or = detector<Default, void, Op, Args...>;
2859 template<
class Default,
template<
class...>
class Op,
class... Args>
2860 using detected_or_t =
typename detected_or<Default, Op, Args...>::type;
2862 template<
class Expected,
template<
class...>
class Op,
class... Args>
2863 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2865 template<
class To,
template<
class...>
class Op,
class... Args>
2866 using is_detected_convertible =
2867 std::is_convertible<detected_t<Op, Args...>, To>;
2872 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
2873 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
2895 template<
typename T =
void,
typename SFINAE =
void>
2898 template<
template<
typename U,
typename V,
typename... Args>
class ObjectType =
2900 template<
typename U,
typename... Args>
class ArrayType = std::vector,
2901 class StringType = std::string,
class BooleanType = bool,
2902 class NumberIntegerType = std::int64_t,
2903 class NumberUnsignedType = std::uint64_t,
2904 class NumberFloatType = double,
2905 template<
typename U>
class AllocatorType = std::allocator,
2906 template<
typename T,
typename SFINAE =
void>
class JSONSerializer =
2908 class BinaryType = std::vector<std::uint8_t>>
2922 template<
typename BasicJsonType>
2935 template<
class Key,
class T,
class IgnoredLess,
class Allocator>
2949 #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
2977 template<
typename>
struct is_basic_json : std::false_type {};
2979 NLOHMANN_BASIC_JSON_TPL_DECLARATION
2980 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
2990 struct is_json_ref : std::false_type {};
2992 template<
typename T>
2993 struct is_json_ref<json_ref<T>> : std::true_type {};
2999 template<
typename T>
3000 using mapped_type_t =
typename T::mapped_type;
3002 template<
typename T>
3003 using key_type_t =
typename T::key_type;
3005 template<
typename T>
3006 using value_type_t =
typename T::value_type;
3008 template<
typename T>
3009 using difference_type_t =
typename T::difference_type;
3011 template<
typename T>
3012 using pointer_t =
typename T::pointer;
3014 template<
typename T>
3015 using reference_t =
typename T::reference;
3017 template<
typename T>
3018 using iterator_category_t =
typename T::iterator_category;
3020 template<
typename T>
3021 using iterator_t =
typename T::iterator;
3023 template<
typename T,
typename... Args>
3024 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3026 template<
typename T,
typename... Args>
3027 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3029 template<
typename T,
typename U>
3030 using get_template_function = decltype(std::declval<T>().
template get<U>());
3033 template<
typename BasicJsonType,
typename T,
typename =
void>
3034 struct has_from_json : std::false_type {};
3040 template <
typename BasicJsonType,
typename T>
3043 static constexpr
bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3046 template<
typename BasicJsonType,
typename T>
3047 struct has_from_json < BasicJsonType, T,
3048 enable_if_t < !is_basic_json<T>::value >>
3050 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3052 static constexpr
bool value =
3053 is_detected_exact<void, from_json_function, serializer,
3054 const BasicJsonType&, T&>::value;
3059 template<
typename BasicJsonType,
typename T,
typename =
void>
3060 struct has_non_default_from_json : std::false_type {};
3062 template<
typename BasicJsonType,
typename T>
3063 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3065 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3067 static constexpr
bool value =
3068 is_detected_exact<T, from_json_function, serializer,
3069 const BasicJsonType&>::value;
3074 template<
typename BasicJsonType,
typename T,
typename =
void>
3075 struct has_to_json : std::false_type {};
3077 template<
typename BasicJsonType,
typename T>
3078 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3080 using serializer =
typename BasicJsonType::template json_serializer<T, void>;
3082 static constexpr
bool value =
3083 is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3092 template<
typename T,
typename =
void>
3093 struct is_iterator_traits : std::false_type {};
3095 template<
typename T>
3096 struct is_iterator_traits<iterator_traits<T>>
3099 using traits = iterator_traits<T>;
3102 static constexpr
auto value =
3103 is_detected<value_type_t, traits>::value &&
3104 is_detected<difference_type_t, traits>::value &&
3105 is_detected<pointer_t, traits>::value &&
3106 is_detected<iterator_category_t, traits>::value &&
3107 is_detected<reference_t, traits>::value;
3112 template<
typename T,
typename =
void>
3113 struct is_complete_type : std::false_type {};
3115 template<
typename T>
3116 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3118 template<
typename BasicJsonType,
typename CompatibleObjectType,
3120 struct is_compatible_object_type_impl : std::false_type {};
3122 template<
typename BasicJsonType,
typename CompatibleObjectType>
3123 struct is_compatible_object_type_impl <
3124 BasicJsonType, CompatibleObjectType,
3125 enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3126 is_detected<key_type_t, CompatibleObjectType>::value >>
3129 using object_t =
typename BasicJsonType::object_t;
3132 static constexpr
bool value =
3133 std::is_constructible<
typename object_t::key_type,
3134 typename CompatibleObjectType::key_type>::value &&
3135 std::is_constructible<
typename object_t::mapped_type,
3136 typename CompatibleObjectType::mapped_type>::value;
3139 template<
typename BasicJsonType,
typename CompatibleObjectType>
3140 struct is_compatible_object_type
3141 : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3143 template<
typename BasicJsonType,
typename ConstructibleObjectType,
3145 struct is_constructible_object_type_impl : std::false_type {};
3147 template<
typename BasicJsonType,
typename ConstructibleObjectType>
3148 struct is_constructible_object_type_impl <
3149 BasicJsonType, ConstructibleObjectType,
3150 enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3151 is_detected<key_type_t, ConstructibleObjectType>::value >>
3153 using object_t =
typename BasicJsonType::object_t;
3155 static constexpr
bool value =
3156 (std::is_default_constructible<ConstructibleObjectType>::value &&
3157 (std::is_move_assignable<ConstructibleObjectType>::value ||
3158 std::is_copy_assignable<ConstructibleObjectType>::value) &&
3159 (std::is_constructible<
typename ConstructibleObjectType::key_type,
3160 typename object_t::key_type>::value &&
3162 typename object_t::mapped_type,
3163 typename ConstructibleObjectType::mapped_type >::value)) ||
3164 (has_from_json<BasicJsonType,
3165 typename ConstructibleObjectType::mapped_type>::value ||
3166 has_non_default_from_json <
3168 typename ConstructibleObjectType::mapped_type >::value);
3171 template<
typename BasicJsonType,
typename ConstructibleObjectType>
3172 struct is_constructible_object_type
3173 : is_constructible_object_type_impl<BasicJsonType,
3174 ConstructibleObjectType> {};
3176 template<
typename BasicJsonType,
typename CompatibleStringType,
3178 struct is_compatible_string_type_impl : std::false_type {};
3180 template<
typename BasicJsonType,
typename CompatibleStringType>
3181 struct is_compatible_string_type_impl <
3182 BasicJsonType, CompatibleStringType,
3183 enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3184 value_type_t, CompatibleStringType>::value >>
3186 static constexpr
auto value =
3187 std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3190 template<
typename BasicJsonType,
typename ConstructibleStringType>
3191 struct is_compatible_string_type
3192 : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3194 template<
typename BasicJsonType,
typename ConstructibleStringType,
3196 struct is_constructible_string_type_impl : std::false_type {};
3198 template<
typename BasicJsonType,
typename ConstructibleStringType>
3199 struct is_constructible_string_type_impl <
3200 BasicJsonType, ConstructibleStringType,
3201 enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3202 value_type_t, ConstructibleStringType>::value >>
3204 static constexpr
auto value =
3205 std::is_constructible<ConstructibleStringType,
3206 typename BasicJsonType::string_t>::value;
3209 template<
typename BasicJsonType,
typename ConstructibleStringType>
3210 struct is_constructible_string_type
3211 : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3213 template<
typename BasicJsonType,
typename CompatibleArrayType,
typename =
void>
3214 struct is_compatible_array_type_impl : std::false_type {};
3216 template<
typename BasicJsonType,
typename CompatibleArrayType>
3217 struct is_compatible_array_type_impl <
3218 BasicJsonType, CompatibleArrayType,
3219 enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
3220 is_detected<iterator_t, CompatibleArrayType>::value&&
3224 !is_iterator_traits <
3225 iterator_traits<CompatibleArrayType >>::value >>
3227 static constexpr
bool value =
3228 std::is_constructible<BasicJsonType,
3229 typename CompatibleArrayType::value_type>::value;
3232 template<
typename BasicJsonType,
typename CompatibleArrayType>
3233 struct is_compatible_array_type
3234 : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3236 template<
typename BasicJsonType,
typename ConstructibleArrayType,
typename =
void>
3237 struct is_constructible_array_type_impl : std::false_type {};
3239 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3240 struct is_constructible_array_type_impl <
3241 BasicJsonType, ConstructibleArrayType,
3242 enable_if_t<std::is_same<ConstructibleArrayType,
3243 typename BasicJsonType::value_type>::value >>
3244 : std::true_type {};
3246 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3247 struct is_constructible_array_type_impl <
3248 BasicJsonType, ConstructibleArrayType,
3249 enable_if_t < !std::is_same<ConstructibleArrayType,
3250 typename BasicJsonType::value_type>::value&&
3251 std::is_default_constructible<ConstructibleArrayType>::value&&
3252 (std::is_move_assignable<ConstructibleArrayType>::value ||
3253 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3254 is_detected<value_type_t, ConstructibleArrayType>::value&&
3255 is_detected<iterator_t, ConstructibleArrayType>::value&&
3257 detected_t<value_type_t, ConstructibleArrayType >>::value >>
3259 static constexpr
bool value =
3265 !is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value &&
3267 (std::is_same<
typename ConstructibleArrayType::value_type,
3268 typename BasicJsonType::array_t::value_type>::value ||
3269 has_from_json<BasicJsonType,
3270 typename ConstructibleArrayType::value_type>::value ||
3271 has_non_default_from_json <
3272 BasicJsonType,
typename ConstructibleArrayType::value_type >::value);
3275 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3276 struct is_constructible_array_type
3277 : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3279 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType,
3281 struct is_compatible_integer_type_impl : std::false_type {};
3283 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3284 struct is_compatible_integer_type_impl <
3285 RealIntegerType, CompatibleNumberIntegerType,
3286 enable_if_t < std::is_integral<RealIntegerType>::value&&
3287 std::is_integral<CompatibleNumberIntegerType>::value&&
3288 !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3291 using RealLimits = std::numeric_limits<RealIntegerType>;
3292 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3294 static constexpr
auto value =
3295 std::is_constructible<RealIntegerType,
3296 CompatibleNumberIntegerType>::value &&
3297 CompatibleLimits::is_integer &&
3298 RealLimits::is_signed == CompatibleLimits::is_signed;
3301 template<
typename RealIntegerType,
typename CompatibleNumberIntegerType>
3302 struct is_compatible_integer_type
3303 : is_compatible_integer_type_impl<RealIntegerType,
3304 CompatibleNumberIntegerType> {};
3306 template<
typename BasicJsonType,
typename CompatibleType,
typename =
void>
3307 struct is_compatible_type_impl: std::false_type {};
3309 template<
typename BasicJsonType,
typename CompatibleType>
3310 struct is_compatible_type_impl <
3311 BasicJsonType, CompatibleType,
3312 enable_if_t<is_complete_type<CompatibleType>::value >>
3314 static constexpr
bool value =
3315 has_to_json<BasicJsonType, CompatibleType>::value;
3318 template<
typename BasicJsonType,
typename CompatibleType>
3319 struct is_compatible_type
3320 : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3323 template<
class...>
struct conjunction : std::true_type { };
3324 template<
class B1>
struct conjunction<B1> : B1 { };
3325 template<
class B1,
class... Bn>
3326 struct conjunction<B1, Bn...>
3327 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3329 template<
typename T1,
typename T2>
3330 struct is_constructible_tuple : std::false_type {};
3332 template<
typename T1,
typename... Args>
3333 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
3377 enum class value_t : std::uint8_t
3404 inline bool operator<(
const value_t lhs,
const value_t rhs) noexcept
3406 static constexpr std::array<std::uint8_t, 9> order = {{
3413 const auto l_index =
static_cast<std::size_t
>(lhs);
3414 const auto r_index =
static_cast<std::size_t
>(rhs);
3415 return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
3425 template<
typename BasicJsonType>
3426 void from_json(
const BasicJsonType& j,
typename std::nullptr_t& n)
3428 if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3430 JSON_THROW(type_error::create(302,
"type must be null, but is " + std::string(j.type_name())));
3436 template <
typename BasicJsonType,
typename ArithmeticType,
3437 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3438 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3440 void get_arithmetic_value(
const BasicJsonType& j, ArithmeticType& val)
3442 switch (
static_cast<value_t
>(j))
3444 case value_t::number_unsigned:
3446 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3449 case value_t::number_integer:
3451 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3454 case value_t::number_float:
3456 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3461 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name())));
3465 template<
typename BasicJsonType>
3466 void from_json(
const BasicJsonType& j,
typename BasicJsonType::boolean_t& b)
3468 if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3470 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(j.type_name())));
3472 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3475 template<
typename BasicJsonType>
3476 void from_json(
const BasicJsonType& j,
typename BasicJsonType::string_t& s)
3478 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3480 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name())));
3482 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3486 typename BasicJsonType,
typename ConstructibleStringType,
3488 is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3489 !std::is_same<
typename BasicJsonType::string_t,
3490 ConstructibleStringType>::value,
3492 void from_json(
const BasicJsonType& j, ConstructibleStringType& s)
3494 if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3496 JSON_THROW(type_error::create(302,
"type must be string, but is " + std::string(j.type_name())));
3499 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3502 template<
typename BasicJsonType>
3503 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_float_t& val)
3505 get_arithmetic_value(j, val);
3508 template<
typename BasicJsonType>
3509 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_unsigned_t& val)
3511 get_arithmetic_value(j, val);
3514 template<
typename BasicJsonType>
3515 void from_json(
const BasicJsonType& j,
typename BasicJsonType::number_integer_t& val)
3517 get_arithmetic_value(j, val);
3520 template<
typename BasicJsonType,
typename EnumType,
3521 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
3522 void from_json(
const BasicJsonType& j, EnumType& e)
3524 typename std::underlying_type<EnumType>::type val;
3525 get_arithmetic_value(j, val);
3526 e =
static_cast<EnumType
>(val);
3530 template<
typename BasicJsonType,
typename T,
typename Allocator,
3531 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
3532 void from_json(
const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3534 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3536 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name())));
3539 std::transform(j.rbegin(), j.rend(),
3540 std::front_inserter(l), [](
const BasicJsonType & i)
3542 return i.template get<T>();
3547 template<
typename BasicJsonType,
typename T,
3548 enable_if_t<is_getable<BasicJsonType, T>::value,
int> = 0>
3549 void from_json(
const BasicJsonType& j, std::valarray<T>& l)
3551 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3553 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name())));
3556 std::transform(j.begin(), j.end(), std::begin(l),
3557 [](
const BasicJsonType & elem)
3559 return elem.template get<T>();
3563 template<
typename BasicJsonType,
typename T, std::
size_t N>
3564 auto from_json(
const BasicJsonType& j, T (&arr)[N])
3565 -> decltype(j.template get<T>(),
void())
3567 for (std::size_t i = 0; i < N; ++i)
3569 arr[i] = j.at(i).template get<T>();
3573 template<
typename BasicJsonType>
3574 void from_json_array_impl(
const BasicJsonType& j,
typename BasicJsonType::array_t& arr, priority_tag<3> )
3576 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3579 template<
typename BasicJsonType,
typename T, std::
size_t N>
3580 auto from_json_array_impl(
const BasicJsonType& j, std::array<T, N>& arr,
3582 -> decltype(j.template get<T>(),
void())
3584 for (std::size_t i = 0; i < N; ++i)
3586 arr[i] = j.at(i).template get<T>();
3590 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3591 auto from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> )
3593 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
3594 j.template get<typename ConstructibleArrayType::value_type>(),
3599 ConstructibleArrayType ret;
3600 ret.reserve(j.size());
3601 std::transform(j.begin(), j.end(),
3602 std::inserter(ret, end(ret)), [](
const BasicJsonType & i)
3606 return i.template get<typename ConstructibleArrayType::value_type>();
3608 arr = std::move(ret);
3611 template<
typename BasicJsonType,
typename ConstructibleArrayType>
3612 void from_json_array_impl(
const BasicJsonType& j, ConstructibleArrayType& arr,
3617 ConstructibleArrayType ret;
3619 j.begin(), j.end(), std::inserter(ret, end(ret)),
3620 [](
const BasicJsonType & i)
3624 return i.template get<typename ConstructibleArrayType::value_type>();
3626 arr = std::move(ret);
3629 template <
typename BasicJsonType,
typename ConstructibleArrayType,
3631 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
3632 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
3633 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3634 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
3635 !is_basic_json<ConstructibleArrayType>::value,
3637 auto from_json(
const BasicJsonType& j, ConstructibleArrayType& arr)
3638 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
3639 j.template get<typename ConstructibleArrayType::value_type>(),
3642 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3644 JSON_THROW(type_error::create(302,
"type must be array, but is " +
3645 std::string(j.type_name())));
3648 from_json_array_impl(j, arr, priority_tag<3> {});
3651 template<
typename BasicJsonType>
3652 void from_json(
const BasicJsonType& j,
typename BasicJsonType::binary_t& bin)
3654 if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
3656 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(j.type_name())));
3659 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
3662 template<
typename BasicJsonType,
typename ConstructibleObjectType,
3663 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value,
int> = 0>
3664 void from_json(
const BasicJsonType& j, ConstructibleObjectType& obj)
3666 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
3668 JSON_THROW(type_error::create(302,
"type must be object, but is " + std::string(j.type_name())));
3671 ConstructibleObjectType ret;
3672 auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
3673 using value_type =
typename ConstructibleObjectType::value_type;
3675 inner_object->begin(), inner_object->end(),
3676 std::inserter(ret, ret.begin()),
3677 [](
typename BasicJsonType::object_t::value_type
const & p)
3679 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
3681 obj = std::move(ret);
3688 template <
typename BasicJsonType,
typename ArithmeticType,
3690 std::is_arithmetic<ArithmeticType>::value&&
3691 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
3692 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
3693 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
3694 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3696 void from_json(
const BasicJsonType& j, ArithmeticType& val)
3698 switch (
static_cast<value_t
>(j))
3700 case value_t::number_unsigned:
3702 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3705 case value_t::number_integer:
3707 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3710 case value_t::number_float:
3712 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3715 case value_t::boolean:
3717 val =
static_cast<ArithmeticType
>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
3722 JSON_THROW(type_error::create(302,
"type must be number, but is " + std::string(j.type_name())));
3726 template<
typename BasicJsonType,
typename A1,
typename A2>
3727 void from_json(
const BasicJsonType& j, std::pair<A1, A2>& p)
3729 p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
3732 template<
typename BasicJsonType,
typename Tuple, std::size_t... Idx>
3733 void from_json_tuple_impl(
const BasicJsonType& j, Tuple& t, index_sequence<Idx...> )
3735 t = std::make_tuple(j.at(Idx).template get<
typename std::tuple_element<Idx, Tuple>::type>()...);
3738 template<
typename BasicJsonType,
typename... Args>
3739 void from_json(
const BasicJsonType& j, std::tuple<Args...>& t)
3741 from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
3744 template <
typename BasicJsonType,
typename Key,
typename Value,
typename Compare,
typename Allocator,
3745 typename = enable_if_t < !std::is_constructible <
3746 typename BasicJsonType::string_t, Key >::value >>
3747 void from_json(
const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
3749 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3751 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name())));
3754 for (
const auto& p : j)
3756 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
3758 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name())));
3760 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3764 template <
typename BasicJsonType,
typename Key,
typename Value,
typename Hash,
typename KeyEqual,
typename Allocator,
3765 typename = enable_if_t < !std::is_constructible <
3766 typename BasicJsonType::string_t, Key >::value >>
3767 void from_json(
const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
3769 if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3771 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(j.type_name())));
3774 for (
const auto& p : j)
3776 if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
3778 JSON_THROW(type_error::create(302,
"type must be array, but is " + std::string(p.type_name())));
3780 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3786 template<
typename BasicJsonType,
typename T>
3787 auto operator()(
const BasicJsonType& j, T& val)
const
3801 constexpr
const auto&
from_json = detail::static_const<detail::from_json_fn>::value;
3808 #include <algorithm>
3812 #include <type_traits>
3834 template<
typename string_type>
3835 void int_to_string( string_type& target, std::size_t value )
3838 using std::to_string;
3841 template<
typename IteratorType>
class iteration_proxy_value
3844 using difference_type = std::ptrdiff_t;
3845 using value_type = iteration_proxy_value;
3846 using pointer = value_type * ;
3847 using reference = value_type & ;
3848 using iterator_category = std::input_iterator_tag;
3849 using string_type =
typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
3853 IteratorType anchor;
3855 std::size_t array_index = 0;
3857 mutable std::size_t array_index_last = 0;
3859 mutable string_type array_index_str =
"0";
3861 const string_type empty_str =
"";
3864 explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
3867 iteration_proxy_value& operator*()
3873 iteration_proxy_value& operator++()
3882 bool operator==(
const iteration_proxy_value& o)
const
3884 return anchor == o.anchor;
3888 bool operator!=(
const iteration_proxy_value& o)
const
3890 return anchor != o.anchor;
3894 const string_type& key()
const
3896 JSON_ASSERT(anchor.m_object !=
nullptr);
3898 switch (anchor.m_object->type())
3901 case value_t::array:
3903 if (array_index != array_index_last)
3905 int_to_string( array_index_str, array_index );
3906 array_index_last = array_index;
3908 return array_index_str;
3912 case value_t::object:
3913 return anchor.key();
3922 typename IteratorType::reference value()
const
3924 return anchor.value();
3929 template<
typename IteratorType>
class iteration_proxy
3933 typename IteratorType::reference container;
3937 explicit iteration_proxy(
typename IteratorType::reference cont) noexcept
3938 : container(cont) {}
3941 iteration_proxy_value<IteratorType> begin() noexcept
3943 return iteration_proxy_value<IteratorType>(container.begin());
3947 iteration_proxy_value<IteratorType> end() noexcept
3949 return iteration_proxy_value<IteratorType>(container.end());
3955 template<std::
size_t N,
typename IteratorType, enable_if_t<N == 0,
int> = 0>
3956 auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
3963 template<std::
size_t N,
typename IteratorType, enable_if_t<N == 1,
int> = 0>
3964 auto get(
const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
3977 #if defined(__clang__)
3979 #pragma clang diagnostic push
3980 #pragma clang diagnostic ignored "-Wmismatched-tags"
3982 template<
typename IteratorType>
3983 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
3984 :
public std::integral_constant<std::size_t, 2> {};
3986 template<std::
size_t N,
typename IteratorType>
3987 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
3990 using type = decltype(
3991 get<N>(std::declval <
3992 ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
3994 #if defined(__clang__)
3995 #pragma clang diagnostic pop
4014 template<value_t>
struct external_constructor;
4017 struct external_constructor<value_t::boolean>
4019 template<
typename BasicJsonType>
4020 static void construct(BasicJsonType& j,
typename BasicJsonType::boolean_t b) noexcept
4022 j.m_type = value_t::boolean;
4024 j.assert_invariant();
4029 struct external_constructor<value_t::string>
4031 template<
typename BasicJsonType>
4032 static void construct(BasicJsonType& j,
const typename BasicJsonType::string_t& s)
4034 j.m_type = value_t::string;
4036 j.assert_invariant();
4039 template<
typename BasicJsonType>
4040 static void construct(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4042 j.m_type = value_t::string;
4043 j.m_value = std::move(s);
4044 j.assert_invariant();
4047 template <
typename BasicJsonType,
typename CompatibleStringType,
4048 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4050 static void construct(BasicJsonType& j,
const CompatibleStringType& str)
4052 j.m_type = value_t::string;
4053 j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4054 j.assert_invariant();
4059 struct external_constructor<value_t::binary>
4061 template<
typename BasicJsonType>
4062 static void construct(BasicJsonType& j,
const typename BasicJsonType::binary_t& b)
4064 j.m_type = value_t::binary;
4065 typename BasicJsonType::binary_t value{b};
4067 j.assert_invariant();
4070 template<
typename BasicJsonType>
4071 static void construct(BasicJsonType& j,
typename BasicJsonType::binary_t&& b)
4073 j.m_type = value_t::binary;
4074 typename BasicJsonType::binary_t value{std::move(b)};
4076 j.assert_invariant();
4081 struct external_constructor<value_t::number_float>
4083 template<
typename BasicJsonType>
4084 static void construct(BasicJsonType& j,
typename BasicJsonType::number_float_t val) noexcept
4086 j.m_type = value_t::number_float;
4088 j.assert_invariant();
4093 struct external_constructor<value_t::number_unsigned>
4095 template<
typename BasicJsonType>
4096 static void construct(BasicJsonType& j,
typename BasicJsonType::number_unsigned_t val) noexcept
4098 j.m_type = value_t::number_unsigned;
4100 j.assert_invariant();
4105 struct external_constructor<value_t::number_integer>
4107 template<
typename BasicJsonType>
4108 static void construct(BasicJsonType& j,
typename BasicJsonType::number_integer_t val) noexcept
4110 j.m_type = value_t::number_integer;
4112 j.assert_invariant();
4117 struct external_constructor<value_t::array>
4119 template<
typename BasicJsonType>
4120 static void construct(BasicJsonType& j,
const typename BasicJsonType::array_t& arr)
4122 j.m_type = value_t::array;
4124 j.assert_invariant();
4127 template<
typename BasicJsonType>
4128 static void construct(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4130 j.m_type = value_t::array;
4131 j.m_value = std::move(arr);
4132 j.assert_invariant();
4135 template <
typename BasicJsonType,
typename CompatibleArrayType,
4136 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4138 static void construct(BasicJsonType& j,
const CompatibleArrayType& arr)
4142 j.m_type = value_t::array;
4143 j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4144 j.assert_invariant();
4147 template<
typename BasicJsonType>
4148 static void construct(BasicJsonType& j,
const std::vector<bool>& arr)
4150 j.m_type = value_t::array;
4151 j.m_value = value_t::array;
4152 j.m_value.array->reserve(arr.size());
4153 for (
const bool x : arr)
4155 j.m_value.array->push_back(x);
4157 j.assert_invariant();
4160 template<
typename BasicJsonType,
typename T,
4161 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4162 static void construct(BasicJsonType& j,
const std::valarray<T>& arr)
4164 j.m_type = value_t::array;
4165 j.m_value = value_t::array;
4166 j.m_value.array->resize(arr.size());
4169 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4171 j.assert_invariant();
4176 struct external_constructor<value_t::object>
4178 template<
typename BasicJsonType>
4179 static void construct(BasicJsonType& j,
const typename BasicJsonType::object_t& obj)
4181 j.m_type = value_t::object;
4183 j.assert_invariant();
4186 template<
typename BasicJsonType>
4187 static void construct(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4189 j.m_type = value_t::object;
4190 j.m_value = std::move(obj);
4191 j.assert_invariant();
4194 template <
typename BasicJsonType,
typename CompatibleObjectType,
4195 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value,
int > = 0 >
4196 static void construct(BasicJsonType& j,
const CompatibleObjectType& obj)
4201 j.m_type = value_t::object;
4202 j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4203 j.assert_invariant();
4211 template<
typename BasicJsonType,
typename T,
4212 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value,
int> = 0>
4213 void to_json(BasicJsonType& j, T b) noexcept
4215 external_constructor<value_t::boolean>::construct(j, b);
4218 template<
typename BasicJsonType,
typename CompatibleString,
4219 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value,
int> = 0>
4220 void to_json(BasicJsonType& j,
const CompatibleString& s)
4222 external_constructor<value_t::string>::construct(j, s);
4225 template<
typename BasicJsonType>
4226 void to_json(BasicJsonType& j,
typename BasicJsonType::string_t&& s)
4228 external_constructor<value_t::string>::construct(j, std::move(s));
4231 template<
typename BasicJsonType,
typename FloatType,
4232 enable_if_t<std::is_floating_point<FloatType>::value,
int> = 0>
4233 void to_json(BasicJsonType& j, FloatType val) noexcept
4235 external_constructor<value_t::number_float>::construct(j,
static_cast<typename BasicJsonType::number_float_t
>(val));
4238 template<
typename BasicJsonType,
typename CompatibleNumberUnsignedType,
4239 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value,
int> = 0>
4240 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4242 external_constructor<value_t::number_unsigned>::construct(j,
static_cast<typename BasicJsonType::number_unsigned_t
>(val));
4245 template<
typename BasicJsonType,
typename CompatibleNumberIntegerType,
4246 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value,
int> = 0>
4247 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4249 external_constructor<value_t::number_integer>::construct(j,
static_cast<typename BasicJsonType::number_integer_t
>(val));
4252 template<
typename BasicJsonType,
typename EnumType,
4253 enable_if_t<std::is_enum<EnumType>::value,
int> = 0>
4254 void to_json(BasicJsonType& j, EnumType e) noexcept
4256 using underlying_type =
typename std::underlying_type<EnumType>::type;
4257 external_constructor<value_t::number_integer>::construct(j,
static_cast<underlying_type
>(e));
4260 template<
typename BasicJsonType>
4261 void to_json(BasicJsonType& j,
const std::vector<bool>& e)
4263 external_constructor<value_t::array>::construct(j, e);
4266 template <
typename BasicJsonType,
typename CompatibleArrayType,
4267 enable_if_t < is_compatible_array_type<BasicJsonType,
4268 CompatibleArrayType>::value&&
4269 !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4270 !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4271 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4272 !is_basic_json<CompatibleArrayType>::value,
4274 void to_json(BasicJsonType& j,
const CompatibleArrayType& arr)
4276 external_constructor<value_t::array>::construct(j, arr);
4279 template<
typename BasicJsonType>
4280 void to_json(BasicJsonType& j,
const typename BasicJsonType::binary_t& bin)
4282 external_constructor<value_t::binary>::construct(j, bin);
4285 template<
typename BasicJsonType,
typename T,
4286 enable_if_t<std::is_convertible<T, BasicJsonType>::value,
int> = 0>
4287 void to_json(BasicJsonType& j,
const std::valarray<T>& arr)
4289 external_constructor<value_t::array>::construct(j, std::move(arr));
4292 template<
typename BasicJsonType>
4293 void to_json(BasicJsonType& j,
typename BasicJsonType::array_t&& arr)
4295 external_constructor<value_t::array>::construct(j, std::move(arr));
4298 template <
typename BasicJsonType,
typename CompatibleObjectType,
4299 enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value,
int > = 0 >
4300 void to_json(BasicJsonType& j,
const CompatibleObjectType& obj)
4302 external_constructor<value_t::object>::construct(j, obj);
4305 template<
typename BasicJsonType>
4306 void to_json(BasicJsonType& j,
typename BasicJsonType::object_t&& obj)
4308 external_constructor<value_t::object>::construct(j, std::move(obj));
4312 typename BasicJsonType,
typename T, std::size_t N,
4313 enable_if_t < !std::is_constructible<
typename BasicJsonType::string_t,
4314 const T(&)[N]>::value,
4316 void to_json(BasicJsonType& j,
const T(&arr)[N])
4318 external_constructor<value_t::array>::construct(j, arr);
4321 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value,
int > = 0 >
4322 void to_json(BasicJsonType& j,
const std::pair<T1, T2>& p)
4324 j = { p.first, p.second };
4328 template<
typename BasicJsonType,
typename T,
4329 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value,
int> = 0>
4330 void to_json(BasicJsonType& j,
const T& b)
4332 j = { {b.key(), b.value()} };
4335 template<
typename BasicJsonType,
typename Tuple, std::size_t... Idx>
4336 void to_json_tuple_impl(BasicJsonType& j,
const Tuple& t, index_sequence<Idx...> )
4338 j = { std::get<Idx>(t)... };
4341 template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value,
int > = 0>
4342 void to_json(BasicJsonType& j,
const T& t)
4344 to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4349 template<
typename BasicJsonType,
typename T>
4350 auto operator()(BasicJsonType& j, T&& val)
const noexcept(noexcept(
to_json(j, std::forward<T>(val))))
4351 -> decltype(
to_json(j, std::forward<T>(val)),
void())
4353 return to_json(j, std::forward<T>(val));
4361 constexpr
const auto&
to_json = detail::static_const<detail::to_json_fn>::value;
4369 template<
typename,
typename>
4370 struct adl_serializer
4381 template<
typename BasicJsonType,
typename ValueType>
4382 static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
4383 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4384 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val),
void())
4386 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4398 template<
typename BasicJsonType,
typename ValueType>
4399 static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
4400 noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
4401 -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)),
void())
4403 ::nlohmann::to_json(j, std::forward<ValueType>(val));
4432 template<
typename BinaryType>
4454 , m_has_subtype(true)
4460 , m_has_subtype(true)
4465 return std::tie(
static_cast<const BinaryType&
>(*
this), m_subtype, m_has_subtype) ==
4466 std::tie(
static_cast<const BinaryType&
>(rhs), rhs.m_subtype, rhs.m_has_subtype);
4471 return !(rhs == *
this);
4495 m_has_subtype =
true;
4542 return m_has_subtype;
4567 m_has_subtype =
false;
4571 std::uint8_t m_subtype = 0;
4572 bool m_has_subtype =
false;
4587 #include <functional>
4595 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
4597 seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
4612 template<
typename BasicJsonType>
4613 std::size_t hash(
const BasicJsonType& j)
4615 using string_t =
typename BasicJsonType::string_t;
4616 using number_integer_t =
typename BasicJsonType::number_integer_t;
4617 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
4618 using number_float_t =
typename BasicJsonType::number_float_t;
4620 const auto type =
static_cast<std::size_t
>(j.type());
4623 case BasicJsonType::value_t::null:
4624 case BasicJsonType::value_t::discarded:
4626 return combine(type, 0);
4629 case BasicJsonType::value_t::object:
4631 auto seed = combine(type, j.size());
4632 for (
const auto& element : j.items())
4634 const auto h = std::hash<string_t> {}(element.key());
4635 seed = combine(seed, h);
4636 seed = combine(seed, hash(element.value()));
4641 case BasicJsonType::value_t::array:
4643 auto seed = combine(type, j.size());
4644 for (
const auto& element : j)
4646 seed = combine(seed, hash(element));
4651 case BasicJsonType::value_t::string:
4653 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
4654 return combine(type, h);
4657 case BasicJsonType::value_t::boolean:
4659 const auto h = std::hash<bool> {}(j.template get<bool>());
4660 return combine(type, h);
4663 case BasicJsonType::value_t::number_integer:
4665 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
4666 return combine(type, h);
4669 case nlohmann::detail::value_t::number_unsigned:
4671 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
4672 return combine(type, h);
4675 case nlohmann::detail::value_t::number_float:
4677 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
4678 return combine(type, h);
4681 case nlohmann::detail::value_t::binary:
4683 auto seed = combine(type, j.get_binary().size());
4684 const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
4685 seed = combine(seed, h);
4686 seed = combine(seed, j.get_binary().subtype());
4687 for (
const auto byte : j.get_binary())
4689 seed = combine(seed, std::hash<std::uint8_t> {}(byte));
4705 #include <algorithm>
4731 #include <type_traits>
4744 enum class input_format_t {
json, cbor, msgpack, ubjson, bson };
4754 class file_input_adapter
4757 using char_type = char;
4759 JSON_HEDLEY_NON_NULL(2)
4760 explicit file_input_adapter(std::FILE* f) noexcept
4765 file_input_adapter(
const file_input_adapter&) =
delete;
4766 file_input_adapter(file_input_adapter&&) =
default;
4767 file_input_adapter& operator=(
const file_input_adapter&) =
delete;
4768 file_input_adapter& operator=(file_input_adapter&&) =
delete;
4770 std::char_traits<char>::int_type get_character() noexcept
4772 return std::fgetc(m_file);
4790 class input_stream_adapter
4793 using char_type = char;
4795 ~input_stream_adapter()
4801 is->clear(is->rdstate() & std::ios::eofbit);
4805 explicit input_stream_adapter(std::istream& i)
4806 : is(&i), sb(i.rdbuf())
4810 input_stream_adapter(
const input_stream_adapter&) =
delete;
4811 input_stream_adapter& operator=(input_stream_adapter&) =
delete;
4812 input_stream_adapter& operator=(input_stream_adapter&& rhs) =
delete;
4814 input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
4823 std::char_traits<char>::int_type get_character()
4825 auto res = sb->sbumpc();
4827 if (JSON_HEDLEY_UNLIKELY(res == EOF))
4829 is->clear(is->rdstate() | std::ios::eofbit);
4836 std::istream* is =
nullptr;
4837 std::streambuf* sb =
nullptr;
4842 template<
typename IteratorType>
4843 class iterator_input_adapter
4846 using char_type =
typename std::iterator_traits<IteratorType>::value_type;
4848 iterator_input_adapter(IteratorType first, IteratorType last)
4849 : current(std::move(first)), end(std::move(last)) {}
4851 typename std::char_traits<char_type>::int_type get_character()
4853 if (JSON_HEDLEY_LIKELY(current != end))
4855 auto result = std::char_traits<char_type>::to_int_type(*current);
4856 std::advance(current, 1);
4861 return std::char_traits<char_type>::eof();
4866 IteratorType current;
4869 template<
typename BaseInputAdapter,
size_t T>
4870 friend struct wide_string_input_helper;
4874 return current == end;
4880 template<
typename BaseInputAdapter,
size_t T>
4881 struct wide_string_input_helper;
4883 template<
typename BaseInputAdapter>
4884 struct wide_string_input_helper<BaseInputAdapter, 4>
4887 static void fill_buffer(BaseInputAdapter& input,
4888 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
4889 size_t& utf8_bytes_index,
4890 size_t& utf8_bytes_filled)
4892 utf8_bytes_index = 0;
4894 if (JSON_HEDLEY_UNLIKELY(input.empty()))
4896 utf8_bytes[0] = std::char_traits<char>::eof();
4897 utf8_bytes_filled = 1;
4902 const auto wc = input.get_character();
4907 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
4908 utf8_bytes_filled = 1;
4910 else if (wc <= 0x7FF)
4912 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
4913 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
4914 utf8_bytes_filled = 2;
4916 else if (wc <= 0xFFFF)
4918 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
4919 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
4920 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
4921 utf8_bytes_filled = 3;
4923 else if (wc <= 0x10FFFF)
4925 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | ((
static_cast<unsigned int>(wc) >> 18u) & 0x07u));
4926 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
4927 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
4928 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
4929 utf8_bytes_filled = 4;
4934 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
4935 utf8_bytes_filled = 1;
4941 template<
typename BaseInputAdapter>
4942 struct wide_string_input_helper<BaseInputAdapter, 2>
4945 static void fill_buffer(BaseInputAdapter& input,
4946 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
4947 size_t& utf8_bytes_index,
4948 size_t& utf8_bytes_filled)
4950 utf8_bytes_index = 0;
4952 if (JSON_HEDLEY_UNLIKELY(input.empty()))
4954 utf8_bytes[0] = std::char_traits<char>::eof();
4955 utf8_bytes_filled = 1;
4960 const auto wc = input.get_character();
4965 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
4966 utf8_bytes_filled = 1;
4968 else if (wc <= 0x7FF)
4970 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xC0u | ((
static_cast<unsigned int>(wc) >> 6u)));
4971 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
4972 utf8_bytes_filled = 2;
4974 else if (0xD800 > wc || wc >= 0xE000)
4976 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xE0u | ((
static_cast<unsigned int>(wc) >> 12u)));
4977 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((
static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
4978 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (
static_cast<unsigned int>(wc) & 0x3Fu));
4979 utf8_bytes_filled = 3;
4983 if (JSON_HEDLEY_UNLIKELY(!input.empty()))
4985 const auto wc2 =
static_cast<unsigned int>(input.get_character());
4986 const auto charcode = 0x10000u + (((
static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
4987 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(0xF0u | (charcode >> 18u));
4988 utf8_bytes[1] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 12u) & 0x3Fu));
4989 utf8_bytes[2] =
static_cast<std::char_traits<char>::int_type
>(0x80u | ((charcode >> 6u) & 0x3Fu));
4990 utf8_bytes[3] =
static_cast<std::char_traits<char>::int_type
>(0x80u | (charcode & 0x3Fu));
4991 utf8_bytes_filled = 4;
4995 utf8_bytes[0] =
static_cast<std::char_traits<char>::int_type
>(wc);
4996 utf8_bytes_filled = 1;
5004 template<
typename BaseInputAdapter,
typename W
ideCharType>
5005 class wide_string_input_adapter
5008 using char_type = char;
5010 wide_string_input_adapter(BaseInputAdapter base)
5011 : base_adapter(base) {}
5013 typename std::char_traits<char>::int_type get_character() noexcept
5016 if (utf8_bytes_index == utf8_bytes_filled)
5018 fill_buffer<sizeof(WideCharType)>();
5020 JSON_ASSERT(utf8_bytes_filled > 0);
5021 JSON_ASSERT(utf8_bytes_index == 0);
5025 JSON_ASSERT(utf8_bytes_filled > 0);
5026 JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5027 return utf8_bytes[utf8_bytes_index++];
5031 BaseInputAdapter base_adapter;
5036 wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
5040 std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5043 std::size_t utf8_bytes_index = 0;
5045 std::size_t utf8_bytes_filled = 0;
5049 template<
typename IteratorType,
typename Enable =
void>
5050 struct iterator_input_adapter_factory
5052 using iterator_type = IteratorType;
5053 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5054 using adapter_type = iterator_input_adapter<iterator_type>;
5056 static adapter_type create(IteratorType first, IteratorType last)
5058 return adapter_type(std::move(first), std::move(last));
5062 template<
typename T>
5063 struct is_iterator_of_multibyte
5065 using value_type =
typename std::iterator_traits<T>::value_type;
5068 value =
sizeof(value_type) > 1
5072 template<
typename IteratorType>
5073 struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5075 using iterator_type = IteratorType;
5076 using char_type =
typename std::iterator_traits<iterator_type>::value_type;
5077 using base_adapter_type = iterator_input_adapter<iterator_type>;
5078 using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
5080 static adapter_type create(IteratorType first, IteratorType last)
5082 return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5087 template<
typename IteratorType>
5088 typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5090 using factory_type = iterator_input_adapter_factory<IteratorType>;
5091 return factory_type::create(first, last);
5095 template<
typename ContainerType>
5096 auto input_adapter(
const ContainerType& container) -> decltype(input_adapter(begin(container), end(container)))
5102 return input_adapter(begin(container), end(container));
5106 inline file_input_adapter input_adapter(std::FILE* file)
5108 return file_input_adapter(file);
5111 inline input_stream_adapter input_adapter(std::istream& stream)
5113 return input_stream_adapter(stream);
5116 inline input_stream_adapter input_adapter(std::istream&& stream)
5118 return input_stream_adapter(stream);
5121 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5124 template <
typename CharT,
5125 typename std::enable_if <
5126 std::is_pointer<CharT>::value&&
5127 !std::is_array<CharT>::value&&
5128 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5129 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5131 contiguous_bytes_input_adapter input_adapter(CharT b)
5133 auto length = std::strlen(
reinterpret_cast<const char*
>(b));
5134 const auto* ptr =
reinterpret_cast<const char*
>(b);
5135 return input_adapter(ptr, ptr + length);
5138 template<
typename T, std::
size_t N>
5139 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
5141 return input_adapter(array, array + N);
5147 class span_input_adapter
5150 template <
typename CharT,
5151 typename std::enable_if <
5152 std::is_pointer<CharT>::value&&
5153 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5154 sizeof(
typename std::remove_pointer<CharT>::type) == 1,
5156 span_input_adapter(CharT b, std::size_t l)
5157 : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5159 template<
class IteratorType,
5160 typename std::enable_if<
5161 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5163 span_input_adapter(IteratorType first, IteratorType last)
5164 : ia(input_adapter(first, last)) {}
5166 contiguous_bytes_input_adapter&& get()
5168 return std::move(ia);
5172 contiguous_bytes_input_adapter ia;
5201 template<
typename BasicJsonType>
5214 virtual bool null() = 0;
5305 const std::string& last_token,
5306 const detail::exception& ex) = 0;
5327 template<
typename BasicJsonType>
5328 class json_sax_dom_parser
5331 using number_integer_t =
typename BasicJsonType::number_integer_t;
5332 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5333 using number_float_t =
typename BasicJsonType::number_float_t;
5334 using string_t =
typename BasicJsonType::string_t;
5335 using binary_t =
typename BasicJsonType::binary_t;
5342 explicit json_sax_dom_parser(BasicJsonType& r,
const bool allow_exceptions_ =
true)
5343 : root(r), allow_exceptions(allow_exceptions_)
5347 json_sax_dom_parser(
const json_sax_dom_parser&) =
delete;
5348 json_sax_dom_parser(json_sax_dom_parser&&) =
default;
5349 json_sax_dom_parser& operator=(
const json_sax_dom_parser&) =
delete;
5350 json_sax_dom_parser& operator=(json_sax_dom_parser&&) =
default;
5351 ~json_sax_dom_parser() =
default;
5355 handle_value(
nullptr);
5359 bool boolean(
bool val)
5365 bool number_integer(number_integer_t val)
5371 bool number_unsigned(number_unsigned_t val)
5377 bool number_float(number_float_t val,
const string_t& )
5383 bool string(string_t& val)
5389 bool binary(binary_t& val)
5391 handle_value(std::move(val));
5395 bool start_object(std::size_t len)
5397 ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
5399 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5401 JSON_THROW(out_of_range::create(408,
5402 "excessive object size: " + std::to_string(len)));
5408 bool key(string_t& val)
5411 object_element = &(ref_stack.back()->m_value.object->operator[](val));
5417 ref_stack.pop_back();
5421 bool start_array(std::size_t len)
5423 ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
5425 if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5427 JSON_THROW(out_of_range::create(408,
5428 "excessive array size: " + std::to_string(len)));
5436 ref_stack.pop_back();
5440 template<
class Exception>
5441 bool parse_error(std::size_t ,
const std::string& ,
5442 const Exception& ex)
5445 static_cast<void>(ex);
5446 if (allow_exceptions)
5453 constexpr
bool is_errored()
const
5465 template<
typename Value>
5467 BasicJsonType* handle_value(Value&& v)
5469 if (ref_stack.empty())
5471 root = BasicJsonType(std::forward<Value>(v));
5475 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5477 if (ref_stack.back()->is_array())
5479 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
5480 return &(ref_stack.back()->m_value.array->back());
5483 JSON_ASSERT(ref_stack.back()->is_object());
5484 JSON_ASSERT(object_element);
5485 *object_element = BasicJsonType(std::forward<Value>(v));
5486 return object_element;
5490 BasicJsonType& root;
5492 std::vector<BasicJsonType*> ref_stack {};
5494 BasicJsonType* object_element =
nullptr;
5496 bool errored =
false;
5498 const bool allow_exceptions =
true;
5501 template<
typename BasicJsonType>
5502 class json_sax_dom_callback_parser
5505 using number_integer_t =
typename BasicJsonType::number_integer_t;
5506 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5507 using number_float_t =
typename BasicJsonType::number_float_t;
5508 using string_t =
typename BasicJsonType::string_t;
5509 using binary_t =
typename BasicJsonType::binary_t;
5510 using parser_callback_t =
typename BasicJsonType::parser_callback_t;
5511 using parse_event_t =
typename BasicJsonType::parse_event_t;
5513 json_sax_dom_callback_parser(BasicJsonType& r,
5514 const parser_callback_t cb,
5515 const bool allow_exceptions_ =
true)
5516 : root(r), callback(cb), allow_exceptions(allow_exceptions_)
5518 keep_stack.push_back(
true);
5522 json_sax_dom_callback_parser(
const json_sax_dom_callback_parser&) =
delete;
5523 json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) =
default;
5524 json_sax_dom_callback_parser& operator=(
const json_sax_dom_callback_parser&) =
delete;
5525 json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) =
default;
5526 ~json_sax_dom_callback_parser() =
default;
5530 handle_value(
nullptr);
5534 bool boolean(
bool val)
5540 bool number_integer(number_integer_t val)
5546 bool number_unsigned(number_unsigned_t val)
5552 bool number_float(number_float_t val,
const string_t& )
5558 bool string(string_t& val)
5564 bool binary(binary_t& val)
5566 handle_value(std::move(val));
5570 bool start_object(std::size_t len)
5573 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
5574 keep_stack.push_back(keep);
5576 auto val = handle_value(BasicJsonType::value_t::object,
true);
5577 ref_stack.push_back(val.second);
5580 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5582 JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
5588 bool key(string_t& val)
5590 BasicJsonType k = BasicJsonType(val);
5593 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::key, k);
5594 key_keep_stack.push_back(keep);
5597 if (keep && ref_stack.back())
5599 object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
5607 if (ref_stack.back() && !callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
5610 *ref_stack.back() = discarded;
5613 JSON_ASSERT(!ref_stack.empty());
5614 JSON_ASSERT(!keep_stack.empty());
5615 ref_stack.pop_back();
5616 keep_stack.pop_back();
5618 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
5621 for (
auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
5623 if (it->is_discarded())
5625 ref_stack.back()->erase(it);
5634 bool start_array(std::size_t len)
5636 const bool keep = callback(
static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
5637 keep_stack.push_back(keep);
5639 auto val = handle_value(BasicJsonType::value_t::array,
true);
5640 ref_stack.push_back(val.second);
5643 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5645 JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len)));
5655 if (ref_stack.back())
5657 keep = callback(
static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
5661 *ref_stack.back() = discarded;
5665 JSON_ASSERT(!ref_stack.empty());
5666 JSON_ASSERT(!keep_stack.empty());
5667 ref_stack.pop_back();
5668 keep_stack.pop_back();
5671 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
5673 ref_stack.back()->m_value.array->pop_back();
5679 template<
class Exception>
5680 bool parse_error(std::size_t ,
const std::string& ,
5681 const Exception& ex)
5684 static_cast<void>(ex);
5685 if (allow_exceptions)
5692 constexpr
bool is_errored()
const
5713 template<
typename Value>
5714 std::pair<bool, BasicJsonType*> handle_value(Value&& v,
const bool skip_callback =
false)
5716 JSON_ASSERT(!keep_stack.empty());
5720 if (!keep_stack.back())
5722 return {
false,
nullptr};
5726 auto value = BasicJsonType(std::forward<Value>(v));
5729 const bool keep = skip_callback || callback(
static_cast<int>(ref_stack.size()), parse_event_t::value, value);
5734 return {
false,
nullptr};
5737 if (ref_stack.empty())
5739 root = std::move(value);
5740 return {
true, &root};
5745 if (!ref_stack.back())
5747 return {
false,
nullptr};
5751 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5754 if (ref_stack.back()->is_array())
5756 ref_stack.back()->m_value.array->push_back(std::move(value));
5757 return {
true, &(ref_stack.back()->m_value.array->back())};
5761 JSON_ASSERT(ref_stack.back()->is_object());
5763 JSON_ASSERT(!key_keep_stack.empty());
5764 const bool store_element = key_keep_stack.back();
5765 key_keep_stack.pop_back();
5769 return {
false,
nullptr};
5772 JSON_ASSERT(object_element);
5773 *object_element = std::move(value);
5774 return {
true, object_element};
5778 BasicJsonType& root;
5780 std::vector<BasicJsonType*> ref_stack {};
5782 std::vector<bool> keep_stack {};
5784 std::vector<bool> key_keep_stack {};
5786 BasicJsonType* object_element =
nullptr;
5788 bool errored =
false;
5790 const parser_callback_t callback =
nullptr;
5792 const bool allow_exceptions =
true;
5794 BasicJsonType discarded = BasicJsonType::value_t::discarded;
5797 template<
typename BasicJsonType>
5798 class json_sax_acceptor
5801 using number_integer_t =
typename BasicJsonType::number_integer_t;
5802 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5803 using number_float_t =
typename BasicJsonType::number_float_t;
5804 using string_t =
typename BasicJsonType::string_t;
5805 using binary_t =
typename BasicJsonType::binary_t;
5817 bool number_integer(number_integer_t )
5822 bool number_unsigned(number_unsigned_t )
5827 bool number_float(number_float_t ,
const string_t& )
5832 bool string(string_t& )
5837 bool binary(binary_t& )
5842 bool start_object(std::size_t = std::size_t(-1))
5847 bool key(string_t& )
5857 bool start_array(std::size_t = std::size_t(-1))
5867 bool parse_error(std::size_t ,
const std::string& ,
const detail::exception& )
5884 #include <initializer_list>
5904 template<
typename BasicJsonType>
5909 enum class token_type
5933 static const char* token_type_name(
const token_type t) noexcept
5937 case token_type::uninitialized:
5938 return "<uninitialized>";
5939 case token_type::literal_true:
5940 return "true literal";
5941 case token_type::literal_false:
5942 return "false literal";
5943 case token_type::literal_null:
5944 return "null literal";
5945 case token_type::value_string:
5946 return "string literal";
5947 case token_type::value_unsigned:
5948 case token_type::value_integer:
5949 case token_type::value_float:
5950 return "number literal";
5951 case token_type::begin_array:
5953 case token_type::begin_object:
5955 case token_type::end_array:
5957 case token_type::end_object:
5959 case token_type::name_separator:
5961 case token_type::value_separator:
5963 case token_type::parse_error:
5964 return "<parse error>";
5965 case token_type::end_of_input:
5966 return "end of input";
5967 case token_type::literal_or_value:
5968 return "'[', '{', or a literal";
5971 return "unknown token";
5981 template<
typename BasicJsonType,
typename InputAdapterType>
5982 class lexer :
public lexer_base<BasicJsonType>
5984 using number_integer_t =
typename BasicJsonType::number_integer_t;
5985 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
5986 using number_float_t =
typename BasicJsonType::number_float_t;
5987 using string_t =
typename BasicJsonType::string_t;
5988 using char_type =
typename InputAdapterType::char_type;
5989 using char_int_type =
typename std::char_traits<char_type>::int_type;
5992 using token_type =
typename lexer_base<BasicJsonType>::token_type;
5994 explicit lexer(InputAdapterType&& adapter,
bool ignore_comments_ =
false)
5995 : ia(std::move(adapter))
5996 , ignore_comments(ignore_comments_)
5997 , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
6001 lexer(
const lexer&) =
delete;
6002 lexer(lexer&&) =
default;
6003 lexer& operator=(lexer&) =
delete;
6004 lexer& operator=(lexer&&) =
default;
6014 static char get_decimal_point() noexcept
6016 const auto* loc = localeconv();
6017 JSON_ASSERT(loc !=
nullptr);
6018 return (loc->decimal_point ==
nullptr) ?
'.' : *(loc->decimal_point);
6043 JSON_ASSERT(current ==
'u');
6046 const auto factors = { 12u, 8u, 4u, 0u };
6047 for (
const auto factor : factors)
6051 if (current >=
'0' && current <=
'9')
6053 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x30u) << factor);
6055 else if (current >=
'A' && current <=
'F')
6057 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x37u) << factor);
6059 else if (current >=
'a' && current <=
'f')
6061 codepoint +=
static_cast<int>((
static_cast<unsigned int>(current) - 0x57u) << factor);
6069 JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6088 bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6090 JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6093 for (
auto range = ranges.begin(); range != ranges.end(); ++range)
6096 if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6102 error_message =
"invalid string: ill-formed UTF-8 byte";
6125 token_type scan_string()
6131 JSON_ASSERT(current ==
'\"');
6139 case std::char_traits<char_type>::eof():
6141 error_message =
"invalid string: missing closing quote";
6142 return token_type::parse_error;
6148 return token_type::value_string;
6192 const int codepoint1 = get_codepoint();
6193 int codepoint = codepoint1;
6195 if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6197 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6198 return token_type::parse_error;
6202 if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6205 if (JSON_HEDLEY_LIKELY(get() ==
'\\' && get() ==
'u'))
6207 const int codepoint2 = get_codepoint();
6209 if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6211 error_message =
"invalid string: '\\u' must be followed by 4 hex digits";
6212 return token_type::parse_error;
6216 if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6219 codepoint =
static_cast<int>(
6221 (
static_cast<unsigned int>(codepoint1) << 10u)
6223 +
static_cast<unsigned int>(codepoint2)
6231 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6232 return token_type::parse_error;
6237 error_message =
"invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6238 return token_type::parse_error;
6243 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6245 error_message =
"invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6246 return token_type::parse_error;
6251 JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6254 if (codepoint < 0x80)
6257 add(
static_cast<char_int_type
>(codepoint));
6259 else if (codepoint <= 0x7FF)
6262 add(
static_cast<char_int_type
>(0xC0u | (
static_cast<unsigned int>(codepoint) >> 6u)));
6263 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6265 else if (codepoint <= 0xFFFF)
6268 add(
static_cast<char_int_type
>(0xE0u | (
static_cast<unsigned int>(codepoint) >> 12u)));
6269 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6270 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6275 add(
static_cast<char_int_type
>(0xF0u | (
static_cast<unsigned int>(codepoint) >> 18u)));
6276 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6277 add(
static_cast<char_int_type
>(0x80u | ((
static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6278 add(
static_cast<char_int_type
>(0x80u | (
static_cast<unsigned int>(codepoint) & 0x3Fu)));
6286 error_message =
"invalid string: forbidden character after backslash";
6287 return token_type::parse_error;
6296 error_message =
"invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6297 return token_type::parse_error;
6302 error_message =
"invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6303 return token_type::parse_error;
6308 error_message =
"invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6309 return token_type::parse_error;
6314 error_message =
"invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6315 return token_type::parse_error;
6320 error_message =
"invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6321 return token_type::parse_error;
6326 error_message =
"invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6327 return token_type::parse_error;
6332 error_message =
"invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6333 return token_type::parse_error;
6338 error_message =
"invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6339 return token_type::parse_error;
6344 error_message =
"invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6345 return token_type::parse_error;
6350 error_message =
"invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6351 return token_type::parse_error;
6356 error_message =
"invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6357 return token_type::parse_error;
6362 error_message =
"invalid string: control character U+000B (VT) must be escaped to \\u000B";
6363 return token_type::parse_error;
6368 error_message =
"invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
6369 return token_type::parse_error;
6374 error_message =
"invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
6375 return token_type::parse_error;
6380 error_message =
"invalid string: control character U+000E (SO) must be escaped to \\u000E";
6381 return token_type::parse_error;
6386 error_message =
"invalid string: control character U+000F (SI) must be escaped to \\u000F";
6387 return token_type::parse_error;
6392 error_message =
"invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
6393 return token_type::parse_error;
6398 error_message =
"invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
6399 return token_type::parse_error;
6404 error_message =
"invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
6405 return token_type::parse_error;
6410 error_message =
"invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
6411 return token_type::parse_error;
6416 error_message =
"invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
6417 return token_type::parse_error;
6422 error_message =
"invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
6423 return token_type::parse_error;
6428 error_message =
"invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
6429 return token_type::parse_error;
6434 error_message =
"invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
6435 return token_type::parse_error;
6440 error_message =
"invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
6441 return token_type::parse_error;
6446 error_message =
"invalid string: control character U+0019 (EM) must be escaped to \\u0019";
6447 return token_type::parse_error;
6452 error_message =
"invalid string: control character U+001A (SUB) must be escaped to \\u001A";
6453 return token_type::parse_error;
6458 error_message =
"invalid string: control character U+001B (ESC) must be escaped to \\u001B";
6459 return token_type::parse_error;
6464 error_message =
"invalid string: control character U+001C (FS) must be escaped to \\u001C";
6465 return token_type::parse_error;
6470 error_message =
"invalid string: control character U+001D (GS) must be escaped to \\u001D";
6471 return token_type::parse_error;
6476 error_message =
"invalid string: control character U+001E (RS) must be escaped to \\u001E";
6477 return token_type::parse_error;
6482 error_message =
"invalid string: control character U+001F (US) must be escaped to \\u001F";
6483 return token_type::parse_error;
6618 if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
6620 return token_type::parse_error;
6628 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
6630 return token_type::parse_error;
6652 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
6654 return token_type::parse_error;
6662 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
6664 return token_type::parse_error;
6672 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
6674 return token_type::parse_error;
6684 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
6686 return token_type::parse_error;
6694 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
6696 return token_type::parse_error;
6704 error_message =
"invalid string: ill-formed UTF-8 byte";
6705 return token_type::parse_error;
6728 case std::char_traits<char_type>::eof():
6745 case std::char_traits<char_type>::eof():
6748 error_message =
"invalid comment; missing closing '*/'";
6776 error_message =
"invalid comment; expecting '/' or '*' after '/'";
6782 JSON_HEDLEY_NON_NULL(2)
6783 static
void strtof(
float& f, const
char* str,
char** endptr) noexcept
6785 f = std::strtof(str, endptr);
6788 JSON_HEDLEY_NON_NULL(2)
6789 static
void strtof(
double& f, const
char* str,
char** endptr) noexcept
6791 f = std::strtod(str, endptr);
6794 JSON_HEDLEY_NON_NULL(2)
6795 static
void strtof(
long double& f, const
char* str,
char** endptr) noexcept
6797 f = std::strtold(str, endptr);
6840 token_type scan_number()
6847 token_type number_type = token_type::value_unsigned;
6855 goto scan_number_minus;
6861 goto scan_number_zero;
6875 goto scan_number_any1;
6885 number_type = token_type::value_integer;
6891 goto scan_number_zero;
6905 goto scan_number_any1;
6910 error_message =
"invalid number; expected digit after '-'";
6911 return token_type::parse_error;
6921 add(decimal_point_char);
6922 goto scan_number_decimal1;
6929 goto scan_number_exponent;
6933 goto scan_number_done;
6952 goto scan_number_any1;
6957 add(decimal_point_char);
6958 goto scan_number_decimal1;
6965 goto scan_number_exponent;
6969 goto scan_number_done;
6972 scan_number_decimal1:
6974 number_type = token_type::value_float;
6989 goto scan_number_decimal2;
6994 error_message =
"invalid number; expected digit after '.'";
6995 return token_type::parse_error;
6999 scan_number_decimal2:
7015 goto scan_number_decimal2;
7022 goto scan_number_exponent;
7026 goto scan_number_done;
7029 scan_number_exponent:
7031 number_type = token_type::value_float;
7038 goto scan_number_sign;
7053 goto scan_number_any2;
7059 "invalid number; expected '+', '-', or digit after exponent";
7060 return token_type::parse_error;
7080 goto scan_number_any2;
7085 error_message =
"invalid number; expected digit after exponent sign";
7086 return token_type::parse_error;
7106 goto scan_number_any2;
7110 goto scan_number_done;
7118 char* endptr =
nullptr;
7122 if (number_type == token_type::value_unsigned)
7124 const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7127 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7131 value_unsigned =
static_cast<number_unsigned_t
>(x);
7132 if (value_unsigned == x)
7134 return token_type::value_unsigned;
7138 else if (number_type == token_type::value_integer)
7140 const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7143 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7147 value_integer =
static_cast<number_integer_t
>(x);
7148 if (value_integer == x)
7150 return token_type::value_integer;
7157 strtof(value_float, token_buffer.data(), &endptr);
7160 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7162 return token_type::value_float;
7170 JSON_HEDLEY_NON_NULL(2)
7171 token_type scan_literal(const char_type* literal_text, const std::
size_t length,
7172 token_type return_type)
7174 JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7175 for (std::size_t i = 1; i < length; ++i)
7177 if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7179 error_message =
"invalid literal";
7180 return token_type::parse_error;
7191 void reset() noexcept
7193 token_buffer.clear();
7194 token_string.clear();
7195 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7210 ++position.chars_read_total;
7211 ++position.chars_read_current_line;
7220 current = ia.get_character();
7223 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7225 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7228 if (current ==
'\n')
7230 ++position.lines_read;
7231 position.chars_read_current_line = 0;
7249 --position.chars_read_total;
7252 if (position.chars_read_current_line == 0)
7254 if (position.lines_read > 0)
7256 --position.lines_read;
7261 --position.chars_read_current_line;
7264 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7266 JSON_ASSERT(!token_string.empty());
7267 token_string.pop_back();
7272 void add(char_int_type c)
7274 token_buffer.push_back(
static_cast<typename string_t::value_type
>(c));
7283 constexpr number_integer_t get_number_integer() const noexcept
7285 return value_integer;
7289 constexpr number_unsigned_t get_number_unsigned() const noexcept
7291 return value_unsigned;
7295 constexpr number_float_t get_number_float() const noexcept
7301 string_t& get_string()
7303 return token_buffer;
7311 constexpr position_t get_position() const noexcept
7319 std::string get_token_string()
const
7323 for (
const auto c : token_string)
7325 if (
static_cast<unsigned char>(c) <=
'\x1F')
7328 std::array<char, 9> cs{{}};
7329 (std::snprintf)(cs.data(), cs.size(),
"<U+%.4X>",
static_cast<unsigned char>(c));
7330 result += cs.data();
7335 result.push_back(
static_cast<std::string::value_type
>(c));
7344 constexpr
const char* get_error_message() const noexcept
7346 return error_message;
7362 return get() == 0xBB && get() == 0xBF;
7371 void skip_whitespace()
7377 while (current ==
' ' || current ==
'\t' || current ==
'\n' || current ==
'\r');
7383 if (position.chars_read_total == 0 && !skip_bom())
7385 error_message =
"invalid BOM; must be 0xEF 0xBB 0xBF if given";
7386 return token_type::parse_error;
7393 if (ignore_comments && current ==
'/')
7395 if (!scan_comment())
7397 return token_type::parse_error;
7408 return token_type::begin_array;
7410 return token_type::end_array;
7412 return token_type::begin_object;
7414 return token_type::end_object;
7416 return token_type::name_separator;
7418 return token_type::value_separator;
7423 std::array<char_type, 4> true_literal = {{
't',
'r',
'u',
'e'}};
7424 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
7428 std::array<char_type, 5> false_literal = {{
'f',
'a',
'l',
's',
'e'}};
7429 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
7433 std::array<char_type, 4> null_literal = {{
'n',
'u',
'l',
'l'}};
7434 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
7439 return scan_string();
7453 return scan_number();
7458 case std::char_traits<char_type>::eof():
7459 return token_type::end_of_input;
7463 error_message =
"invalid literal";
7464 return token_type::parse_error;
7470 InputAdapterType ia;
7473 const bool ignore_comments =
false;
7476 char_int_type current = std::char_traits<char_type>::eof();
7479 bool next_unget =
false;
7482 position_t position {};
7485 std::vector<char_type> token_string {};
7488 string_t token_buffer {};
7491 const char* error_message =
"";
7494 number_integer_t value_integer = 0;
7495 number_unsigned_t value_unsigned = 0;
7496 number_float_t value_float = 0;
7499 const char_int_type decimal_point_char =
'.';
7522 template<
typename T>
7523 using null_function_t = decltype(std::declval<T&>().
null());
7525 template<
typename T>
7526 using boolean_function_t =
7527 decltype(std::declval<T&>().
boolean(std::declval<bool>()));
7529 template<
typename T,
typename Integer>
7530 using number_integer_function_t =
7531 decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
7533 template<
typename T,
typename Un
signed>
7534 using number_unsigned_function_t =
7535 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
7537 template<
typename T,
typename Float,
typename String>
7538 using number_float_function_t = decltype(std::declval<T&>().number_float(
7539 std::declval<Float>(), std::declval<const String&>()));
7541 template<
typename T,
typename String>
7542 using string_function_t =
7543 decltype(std::declval<T&>().
string(std::declval<String&>()));
7545 template<
typename T,
typename Binary>
7546 using binary_function_t =
7547 decltype(std::declval<T&>().binary(std::declval<Binary&>()));
7549 template<
typename T>
7550 using start_object_function_t =
7551 decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
7553 template<
typename T,
typename String>
7554 using key_function_t =
7555 decltype(std::declval<T&>().key(std::declval<String&>()));
7557 template<
typename T>
7558 using end_object_function_t = decltype(std::declval<T&>().end_object());
7560 template<
typename T>
7561 using start_array_function_t =
7562 decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
7564 template<
typename T>
7565 using end_array_function_t = decltype(std::declval<T&>().end_array());
7567 template<
typename T,
typename Exception>
7568 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
7569 std::declval<std::size_t>(), std::declval<const std::string&>(),
7570 std::declval<const Exception&>()));
7572 template<
typename SAX,
typename BasicJsonType>
7576 static_assert(is_basic_json<BasicJsonType>::value,
7577 "BasicJsonType must be of type basic_json<...>");
7579 using number_integer_t =
typename BasicJsonType::number_integer_t;
7580 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
7581 using number_float_t =
typename BasicJsonType::number_float_t;
7582 using string_t =
typename BasicJsonType::string_t;
7583 using binary_t =
typename BasicJsonType::binary_t;
7584 using exception_t =
typename BasicJsonType::exception;
7587 static constexpr
bool value =
7588 is_detected_exact<bool, null_function_t, SAX>::value &&
7589 is_detected_exact<bool, boolean_function_t, SAX>::value &&
7590 is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
7591 is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
7592 is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
7593 is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
7594 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
7595 is_detected_exact<bool, start_object_function_t, SAX>::value &&
7596 is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
7597 is_detected_exact<bool, end_object_function_t, SAX>::value &&
7598 is_detected_exact<bool, start_array_function_t, SAX>::value &&
7599 is_detected_exact<bool, end_array_function_t, SAX>::value &&
7600 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
7603 template<
typename SAX,
typename BasicJsonType>
7604 struct is_sax_static_asserts
7607 static_assert(is_basic_json<BasicJsonType>::value,
7608 "BasicJsonType must be of type basic_json<...>");
7610 using number_integer_t =
typename BasicJsonType::number_integer_t;
7611 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
7612 using number_float_t =
typename BasicJsonType::number_float_t;
7613 using string_t =
typename BasicJsonType::string_t;
7614 using binary_t =
typename BasicJsonType::binary_t;
7615 using exception_t =
typename BasicJsonType::exception;
7618 static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
7619 "Missing/invalid function: bool null()");
7620 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
7621 "Missing/invalid function: bool boolean(bool)");
7622 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
7623 "Missing/invalid function: bool boolean(bool)");
7625 is_detected_exact<
bool, number_integer_function_t, SAX,
7626 number_integer_t>::value,
7627 "Missing/invalid function: bool number_integer(number_integer_t)");
7629 is_detected_exact<
bool, number_unsigned_function_t, SAX,
7630 number_unsigned_t>::value,
7631 "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
7632 static_assert(is_detected_exact<
bool, number_float_function_t, SAX,
7633 number_float_t, string_t>::value,
7634 "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
7636 is_detected_exact<bool, string_function_t, SAX, string_t>::value,
7637 "Missing/invalid function: bool string(string_t&)");
7639 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
7640 "Missing/invalid function: bool binary(binary_t&)");
7641 static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
7642 "Missing/invalid function: bool start_object(std::size_t)");
7643 static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
7644 "Missing/invalid function: bool key(string_t&)");
7645 static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
7646 "Missing/invalid function: bool end_object()");
7647 static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
7648 "Missing/invalid function: bool start_array(std::size_t)");
7649 static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
7650 "Missing/invalid function: bool end_array()");
7652 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
7653 "Missing/invalid function: bool parse_error(std::size_t, const "
7654 "std::string&, const exception&)");
7668 enum class cbor_tag_handler_t
7681 static inline bool little_endianess(
int num = 1) noexcept
7683 return *
reinterpret_cast<char*
>(&num) == 1;
7694 template<
typename BasicJsonType,
typename InputAdapterType,
typename SAX = json_sax_dom_parser<BasicJsonType>>
7697 using number_integer_t =
typename BasicJsonType::number_integer_t;
7698 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
7699 using number_float_t =
typename BasicJsonType::number_float_t;
7700 using string_t =
typename BasicJsonType::string_t;
7701 using binary_t =
typename BasicJsonType::binary_t;
7702 using json_sax_t = SAX;
7703 using char_type =
typename InputAdapterType::char_type;
7704 using char_int_type =
typename std::char_traits<char_type>::int_type;
7712 explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
7714 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
7718 binary_reader(
const binary_reader&) =
delete;
7719 binary_reader(binary_reader&&) =
default;
7720 binary_reader& operator=(
const binary_reader&) =
delete;
7721 binary_reader& operator=(binary_reader&&) =
default;
7722 ~binary_reader() =
default;
7732 JSON_HEDLEY_NON_NULL(3)
7733 bool sax_parse(const input_format_t format,
7735 const
bool strict = true,
7736 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
7739 bool result =
false;
7743 case input_format_t::bson:
7744 result = parse_bson_internal();
7747 case input_format_t::cbor:
7748 result = parse_cbor_internal(
true, tag_handler);
7751 case input_format_t::msgpack:
7752 result = parse_msgpack_internal();
7755 case input_format_t::ubjson:
7756 result = parse_ubjson_internal();
7764 if (result && strict)
7766 if (format == input_format_t::ubjson)
7775 if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
7777 return sax->parse_error(chars_read, get_token_string(),
7778 parse_error::create(110, chars_read, exception_message(format,
"expected end of input; last byte: 0x" + get_token_string(),
"value")));
7794 bool parse_bson_internal()
7796 std::int32_t document_size{};
7797 get_number<std::int32_t, true>(input_format_t::bson, document_size);
7799 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
7804 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
false)))
7809 return sax->end_object();
7819 bool get_bson_cstr(string_t& result)
7821 auto out = std::back_inserter(result);
7825 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"cstring")))
7829 if (current == 0x00)
7833 *out++ =
static_cast<typename string_t::value_type
>(current);
7848 template<
typename NumberType>
7849 bool get_bson_string(
const NumberType len, string_t& result)
7851 if (JSON_HEDLEY_UNLIKELY(len < 1))
7853 auto last_token = get_token_string();
7854 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")));
7857 return get_string(input_format_t::bson, len -
static_cast<NumberType
>(1), result) && get() != std::char_traits<char_type>::eof();
7869 template<
typename NumberType>
7870 bool get_bson_binary(
const NumberType len, binary_t& result)
7872 if (JSON_HEDLEY_UNLIKELY(len < 0))
7874 auto last_token = get_token_string();
7875 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")));
7879 std::uint8_t subtype{};
7880 get_number<std::uint8_t>(input_format_t::bson, subtype);
7881 result.set_subtype(subtype);
7883 return get_binary(input_format_t::bson, len, result);
7896 bool parse_bson_element_internal(
const char_int_type element_type,
7897 const std::size_t element_type_parse_position)
7899 switch (element_type)
7904 return get_number<double, true>(input_format_t::bson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
7911 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
7916 return parse_bson_internal();
7921 return parse_bson_array();
7928 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
7933 return sax->boolean(get() != 0);
7943 std::int32_t value{};
7944 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
7949 std::int64_t value{};
7950 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
7955 std::array<char, 3> cr{{}};
7956 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(element_type));
7957 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())));
7974 bool parse_bson_element_list(
const bool is_array)
7978 while (
auto element_type = get())
7980 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson,
"element list")))
7985 const std::size_t element_type_parse_position = chars_read;
7986 if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
7991 if (!is_array && !sax->key(key))
7996 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
8012 bool parse_bson_array()
8014 std::int32_t document_size{};
8015 get_number<std::int32_t, true>(input_format_t::bson, document_size);
8017 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
8022 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(
true)))
8027 return sax->end_array();
8042 bool parse_cbor_internal(
const bool get_char,
8043 const cbor_tag_handler_t tag_handler)
8045 switch (get_char ? get() : current)
8048 case std::char_traits<char_type>::eof():
8049 return unexpect_eof(input_format_t::cbor,
"value");
8076 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
8080 std::uint8_t number{};
8081 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8086 std::uint16_t number{};
8087 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8092 std::uint32_t number{};
8093 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8098 std::uint64_t number{};
8099 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8127 return sax->number_integer(
static_cast<std::int8_t
>(0x20 - 1 - current));
8131 std::uint8_t number{};
8132 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8137 std::uint16_t number{};
8138 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8143 std::uint32_t number{};
8144 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1) - number);
8149 std::uint64_t number{};
8150 return get_number(input_format_t::cbor, number) && sax->number_integer(
static_cast<number_integer_t
>(-1)
8151 -
static_cast<number_integer_t
>(number));
8186 return get_cbor_binary(b) && sax->binary(b);
8221 return get_cbor_string(s) && sax->string(s);
8249 return get_cbor_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8254 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8259 std::uint16_t len{};
8260 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8265 std::uint32_t len{};
8266 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8271 std::uint64_t len{};
8272 return get_number(input_format_t::cbor, len) && get_cbor_array(
static_cast<std::size_t
>(len), tag_handler);
8276 return get_cbor_array(std::size_t(-1), tag_handler);
8303 return get_cbor_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8308 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8313 std::uint16_t len{};
8314 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8319 std::uint32_t len{};
8320 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8325 std::uint64_t len{};
8326 return get_number(input_format_t::cbor, len) && get_cbor_object(
static_cast<std::size_t
>(len), tag_handler);
8330 return get_cbor_object(std::size_t(-1), tag_handler);
8352 switch (tag_handler)
8354 case cbor_tag_handler_t::error:
8356 auto last_token = get_token_string();
8357 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")));
8360 case cbor_tag_handler_t::ignore:
8367 get_number(input_format_t::cbor, len);
8372 std::uint16_t len{};
8373 get_number(input_format_t::cbor, len);
8378 std::uint32_t len{};
8379 get_number(input_format_t::cbor, len);
8384 std::uint64_t len{};
8385 get_number(input_format_t::cbor, len);
8391 return parse_cbor_internal(
true, tag_handler);
8400 return sax->boolean(
false);
8403 return sax->boolean(
true);
8410 const auto byte1_raw = get();
8411 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
8415 const auto byte2_raw = get();
8416 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"number")))
8421 const auto byte1 =
static_cast<unsigned char>(byte1_raw);
8422 const auto byte2 =
static_cast<unsigned char>(byte2_raw);
8432 const auto half =
static_cast<unsigned int>((byte1 << 8u) + byte2);
8433 const double val = [&half]
8435 const int exp = (half >> 10u) & 0x1Fu;
8436 const unsigned int mant = half & 0x3FFu;
8437 JSON_ASSERT(0 <= exp&& exp <= 32);
8438 JSON_ASSERT(mant <= 1024);
8442 return std::ldexp(mant, -24);
8445 ? std::numeric_limits<double>::infinity()
8446 : std::numeric_limits<double>::quiet_NaN();
8448 return std::ldexp(mant + 1024, exp - 25);
8451 return sax->number_float((half & 0x8000u) != 0
8452 ?
static_cast<number_float_t
>(-val)
8453 :
static_cast<number_float_t
>(val),
"");
8459 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
8465 return get_number(input_format_t::cbor, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
8470 auto last_token = get_token_string();
8471 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")));
8487 bool get_cbor_string(string_t& result)
8489 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"string")))
8522 return get_string(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
8528 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8533 std::uint16_t len{};
8534 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8539 std::uint32_t len{};
8540 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8545 std::uint64_t len{};
8546 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8551 while (get() != 0xFF)
8554 if (!get_cbor_string(chunk))
8558 result.append(chunk);
8565 auto last_token = get_token_string();
8566 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")));
8582 bool get_cbor_binary(binary_t& result)
8584 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor,
"binary")))
8617 return get_binary(input_format_t::cbor,
static_cast<unsigned int>(current) & 0x1Fu, result);
8623 return get_number(input_format_t::cbor, len) &&
8624 get_binary(input_format_t::cbor, len, result);
8629 std::uint16_t len{};
8630 return get_number(input_format_t::cbor, len) &&
8631 get_binary(input_format_t::cbor, len, result);
8636 std::uint32_t len{};
8637 return get_number(input_format_t::cbor, len) &&
8638 get_binary(input_format_t::cbor, len, result);
8643 std::uint64_t len{};
8644 return get_number(input_format_t::cbor, len) &&
8645 get_binary(input_format_t::cbor, len, result);
8650 while (get() != 0xFF)
8653 if (!get_cbor_binary(chunk))
8657 result.insert(result.end(), chunk.begin(), chunk.end());
8664 auto last_token = get_token_string();
8665 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")));
8676 bool get_cbor_array(
const std::size_t len,
8677 const cbor_tag_handler_t tag_handler)
8679 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
8684 if (len != std::size_t(-1))
8686 for (std::size_t i = 0; i < len; ++i)
8688 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
8696 while (get() != 0xFF)
8698 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
false, tag_handler)))
8705 return sax->end_array();
8714 bool get_cbor_object(
const std::size_t len,
8715 const cbor_tag_handler_t tag_handler)
8717 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
8723 if (len != std::size_t(-1))
8725 for (std::size_t i = 0; i < len; ++i)
8728 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
8733 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
8742 while (get() != 0xFF)
8744 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
8749 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(
true, tag_handler)))
8757 return sax->end_object();
8767 bool parse_msgpack_internal()
8772 case std::char_traits<char_type>::eof():
8773 return unexpect_eof(input_format_t::msgpack,
"value");
8904 return sax->number_unsigned(
static_cast<number_unsigned_t
>(current));
8923 return get_msgpack_object(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
8942 return get_msgpack_array(
static_cast<std::size_t
>(
static_cast<unsigned int>(current) & 0x0Fu));
8982 return get_msgpack_string(s) && sax->string(s);
8989 return sax->boolean(
false);
8992 return sax->boolean(
true);
9007 return get_msgpack_binary(b) && sax->binary(b);
9013 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9019 return get_number(input_format_t::msgpack, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9024 std::uint8_t number{};
9025 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9030 std::uint16_t number{};
9031 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9036 std::uint32_t number{};
9037 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9042 std::uint64_t number{};
9043 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9048 std::int8_t number{};
9049 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9054 std::int16_t number{};
9055 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9060 std::int32_t number{};
9061 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9066 std::int64_t number{};
9067 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9072 std::uint16_t len{};
9073 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9078 std::uint32_t len{};
9079 return get_number(input_format_t::msgpack, len) && get_msgpack_array(
static_cast<std::size_t
>(len));
9084 std::uint16_t len{};
9085 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9090 std::uint32_t len{};
9091 return get_number(input_format_t::msgpack, len) && get_msgpack_object(
static_cast<std::size_t
>(len));
9127 return sax->number_integer(
static_cast<std::int8_t
>(current));
9131 auto last_token = get_token_string();
9132 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")));
9147 bool get_msgpack_string(string_t& result)
9149 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack,
"string")))
9190 return get_string(input_format_t::msgpack,
static_cast<unsigned int>(current) & 0x1Fu, result);
9196 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9201 std::uint16_t len{};
9202 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9207 std::uint32_t len{};
9208 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9213 auto last_token = get_token_string();
9214 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")));
9229 bool get_msgpack_binary(binary_t& result)
9232 auto assign_and_return_true = [&result](std::int8_t subtype)
9234 result.set_subtype(
static_cast<std::uint8_t
>(subtype));
9243 return get_number(input_format_t::msgpack, len) &&
9244 get_binary(input_format_t::msgpack, len, result);
9249 std::uint16_t len{};
9250 return get_number(input_format_t::msgpack, len) &&
9251 get_binary(input_format_t::msgpack, len, result);
9256 std::uint32_t len{};
9257 return get_number(input_format_t::msgpack, len) &&
9258 get_binary(input_format_t::msgpack, len, result);
9264 std::int8_t subtype{};
9265 return get_number(input_format_t::msgpack, len) &&
9266 get_number(input_format_t::msgpack, subtype) &&
9267 get_binary(input_format_t::msgpack, len, result) &&
9268 assign_and_return_true(subtype);
9273 std::uint16_t len{};
9274 std::int8_t subtype{};
9275 return get_number(input_format_t::msgpack, len) &&
9276 get_number(input_format_t::msgpack, subtype) &&
9277 get_binary(input_format_t::msgpack, len, result) &&
9278 assign_and_return_true(subtype);
9283 std::uint32_t len{};
9284 std::int8_t subtype{};
9285 return get_number(input_format_t::msgpack, len) &&
9286 get_number(input_format_t::msgpack, subtype) &&
9287 get_binary(input_format_t::msgpack, len, result) &&
9288 assign_and_return_true(subtype);
9293 std::int8_t subtype{};
9294 return get_number(input_format_t::msgpack, subtype) &&
9295 get_binary(input_format_t::msgpack, 1, result) &&
9296 assign_and_return_true(subtype);
9301 std::int8_t subtype{};
9302 return get_number(input_format_t::msgpack, subtype) &&
9303 get_binary(input_format_t::msgpack, 2, result) &&
9304 assign_and_return_true(subtype);
9309 std::int8_t subtype{};
9310 return get_number(input_format_t::msgpack, subtype) &&
9311 get_binary(input_format_t::msgpack, 4, result) &&
9312 assign_and_return_true(subtype);
9317 std::int8_t subtype{};
9318 return get_number(input_format_t::msgpack, subtype) &&
9319 get_binary(input_format_t::msgpack, 8, result) &&
9320 assign_and_return_true(subtype);
9325 std::int8_t subtype{};
9326 return get_number(input_format_t::msgpack, subtype) &&
9327 get_binary(input_format_t::msgpack, 16, result) &&
9328 assign_and_return_true(subtype);
9340 bool get_msgpack_array(
const std::size_t len)
9342 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9347 for (std::size_t i = 0; i < len; ++i)
9349 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9355 return sax->end_array();
9362 bool get_msgpack_object(
const std::size_t len)
9364 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9370 for (std::size_t i = 0; i < len; ++i)
9373 if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
9378 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9385 return sax->end_object();
9399 bool parse_ubjson_internal(
const bool get_char =
true)
9401 return get_ubjson_value(get_char ? get_ignore_noop() : current);
9418 bool get_ubjson_string(string_t& result,
const bool get_char =
true)
9425 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
9435 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9441 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9447 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9453 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9459 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9463 auto last_token = get_token_string();
9464 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")));
9472 bool get_ubjson_size_value(std::size_t& result)
9474 switch (get_ignore_noop())
9478 std::uint8_t number{};
9479 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9483 result =
static_cast<std::size_t
>(number);
9489 std::int8_t number{};
9490 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9494 result =
static_cast<std::size_t
>(number);
9500 std::int16_t number{};
9501 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9505 result =
static_cast<std::size_t
>(number);
9511 std::int32_t number{};
9512 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9516 result =
static_cast<std::size_t
>(number);
9522 std::int64_t number{};
9523 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9527 result =
static_cast<std::size_t
>(number);
9533 auto last_token = get_token_string();
9534 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")));
9549 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
9551 result.first = string_t::npos;
9558 result.second = get();
9559 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"type")))
9565 if (JSON_HEDLEY_UNLIKELY(current !=
'#'))
9567 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"value")))
9571 auto last_token = get_token_string();
9572 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")));
9575 return get_ubjson_size_value(result.first);
9580 return get_ubjson_size_value(result.first);
9590 bool get_ubjson_value(
const char_int_type prefix)
9594 case std::char_traits<char_type>::eof():
9595 return unexpect_eof(input_format_t::ubjson,
"value");
9598 return sax->boolean(
true);
9600 return sax->boolean(
false);
9607 std::uint8_t number{};
9608 return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
9613 std::int8_t number{};
9614 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9619 std::int16_t number{};
9620 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9625 std::int32_t number{};
9626 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9631 std::int64_t number{};
9632 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9638 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9644 return get_number(input_format_t::ubjson, number) && sax->number_float(
static_cast<number_float_t
>(number),
"");
9649 return get_ubjson_high_precision_number();
9655 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"char")))
9659 if (JSON_HEDLEY_UNLIKELY(current > 127))
9661 auto last_token = get_token_string();
9662 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")));
9664 string_t s(1,
static_cast<typename string_t::value_type
>(current));
9665 return sax->string(s);
9671 return get_ubjson_string(s) && sax->string(s);
9675 return get_ubjson_array();
9678 return get_ubjson_object();
9682 auto last_token = get_token_string();
9683 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")));
9691 bool get_ubjson_array()
9693 std::pair<std::size_t, char_int_type> size_and_type;
9694 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
9699 if (size_and_type.first != string_t::npos)
9701 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
9706 if (size_and_type.second != 0)
9708 if (size_and_type.second !=
'N')
9710 for (std::size_t i = 0; i < size_and_type.first; ++i)
9712 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
9721 for (std::size_t i = 0; i < size_and_type.first; ++i)
9723 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9732 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
9737 while (current !=
']')
9739 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(
false)))
9747 return sax->end_array();
9753 bool get_ubjson_object()
9755 std::pair<std::size_t, char_int_type> size_and_type;
9756 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
9762 if (size_and_type.first != string_t::npos)
9764 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
9769 if (size_and_type.second != 0)
9771 for (std::size_t i = 0; i < size_and_type.first; ++i)
9773 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
9777 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
9786 for (std::size_t i = 0; i < size_and_type.first; ++i)
9788 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
9792 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9802 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
9807 while (current !=
'}')
9809 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key,
false) || !sax->key(key)))
9813 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9822 return sax->end_object();
9828 bool get_ubjson_high_precision_number()
9832 auto res = get_ubjson_size_value(size);
9833 if (JSON_HEDLEY_UNLIKELY(!res))
9839 std::vector<char> number_vector;
9840 for (std::size_t i = 0; i < size; ++i)
9843 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson,
"number")))
9847 number_vector.push_back(
static_cast<char>(current));
9851 auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
9852 auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia),
false);
9853 const auto result_number = number_lexer.scan();
9854 const auto number_string = number_lexer.get_token_string();
9855 const auto result_remainder = number_lexer.scan();
9857 using token_type =
typename detail::lexer_base<BasicJsonType>::token_type;
9859 if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
9861 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")));
9864 switch (result_number)
9866 case token_type::value_integer:
9867 return sax->number_integer(number_lexer.get_number_integer());
9868 case token_type::value_unsigned:
9869 return sax->number_unsigned(number_lexer.get_number_unsigned());
9870 case token_type::value_float:
9871 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
9873 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")));
9893 return current = ia.get_character();
9899 char_int_type get_ignore_noop()
9905 while (current ==
'N');
9923 template<
typename NumberType,
bool InputIsLittleEndian = false>
9924 bool get_number(
const input_format_t format, NumberType& result)
9927 std::array<std::uint8_t,
sizeof(NumberType)> vec;
9928 for (std::size_t i = 0; i <
sizeof(NumberType); ++i)
9931 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"number")))
9937 if (is_little_endian != InputIsLittleEndian)
9939 vec[
sizeof(NumberType) - i - 1] =
static_cast<std::uint8_t
>(current);
9943 vec[i] =
static_cast<std::uint8_t
>(current);
9948 std::memcpy(&result, vec.data(),
sizeof(NumberType));
9966 template<
typename NumberType>
9967 bool get_string(
const input_format_t format,
9968 const NumberType len,
9971 bool success =
true;
9972 for (NumberType i = 0; i < len; i++)
9975 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"string")))
9980 result.push_back(
static_cast<typename string_t::value_type
>(current));
9999 template<
typename NumberType>
10000 bool get_binary(
const input_format_t format,
10001 const NumberType len,
10004 bool success =
true;
10005 for (NumberType i = 0; i < len; i++)
10008 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format,
"binary")))
10013 result.push_back(
static_cast<std::uint8_t
>(current));
10023 JSON_HEDLEY_NON_NULL(3)
10024 bool unexpect_eof(const input_format_t format, const
char* context)
const
10026 if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10028 return sax->parse_error(chars_read,
"<end of file>",
10029 parse_error::create(110, chars_read, exception_message(format,
"unexpected end of input", context)));
10037 std::string get_token_string()
const
10039 std::array<char, 3> cr{{}};
10040 (std::snprintf)(cr.data(), cr.size(),
"%.2hhX",
static_cast<unsigned char>(current));
10041 return std::string{cr.data()};
10050 std::string exception_message(
const input_format_t format,
10051 const std::string& detail,
10052 const std::string& context)
const
10054 std::string error_msg =
"syntax error while parsing ";
10058 case input_format_t::cbor:
10059 error_msg +=
"CBOR";
10062 case input_format_t::msgpack:
10063 error_msg +=
"MessagePack";
10066 case input_format_t::ubjson:
10067 error_msg +=
"UBJSON";
10070 case input_format_t::bson:
10071 error_msg +=
"BSON";
10075 JSON_ASSERT(
false);
10078 return error_msg +
" " + context +
": " + detail;
10083 InputAdapterType ia;
10086 char_int_type current = std::char_traits<char_type>::eof();
10089 std::size_t chars_read = 0;
10092 const bool is_little_endian = little_endianess();
10095 json_sax_t* sax =
nullptr;
10109 #include <functional>
10137 enum class parse_event_t : uint8_t
10153 template<
typename BasicJsonType>
10154 using parser_callback_t =
10155 std::function<bool(
int depth, parse_event_t event, BasicJsonType& parsed)>;
10162 template<
typename BasicJsonType,
typename InputAdapterType>
10165 using number_integer_t =
typename BasicJsonType::number_integer_t;
10166 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
10167 using number_float_t =
typename BasicJsonType::number_float_t;
10168 using string_t =
typename BasicJsonType::string_t;
10169 using lexer_t = lexer<BasicJsonType, InputAdapterType>;
10170 using token_type =
typename lexer_t::token_type;
10174 explicit parser(InputAdapterType&& adapter,
10175 const parser_callback_t<BasicJsonType> cb =
nullptr,
10176 const bool allow_exceptions_ =
true,
10177 const bool skip_comments =
false)
10179 , m_lexer(std::move(adapter), skip_comments)
10180 , allow_exceptions(allow_exceptions_)
10196 void parse(
const bool strict, BasicJsonType& result)
10200 json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
10201 sax_parse_internal(&sdp);
10202 result.assert_invariant();
10205 if (strict && (get_token() != token_type::end_of_input))
10207 sdp.parse_error(m_lexer.get_position(),
10208 m_lexer.get_token_string(),
10209 parse_error::create(101, m_lexer.get_position(),
10210 exception_message(token_type::end_of_input,
"value")));
10214 if (sdp.is_errored())
10216 result = value_t::discarded;
10222 if (result.is_discarded())
10229 json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
10230 sax_parse_internal(&sdp);
10231 result.assert_invariant();
10234 if (strict && (get_token() != token_type::end_of_input))
10236 sdp.parse_error(m_lexer.get_position(),
10237 m_lexer.get_token_string(),
10238 parse_error::create(101, m_lexer.get_position(),
10239 exception_message(token_type::end_of_input,
"value")));
10243 if (sdp.is_errored())
10245 result = value_t::discarded;
10257 bool accept(
const bool strict =
true)
10259 json_sax_acceptor<BasicJsonType> sax_acceptor;
10260 return sax_parse(&sax_acceptor, strict);
10263 template<
typename SAX>
10264 JSON_HEDLEY_NON_NULL(2)
10265 bool sax_parse(SAX* sax, const
bool strict = true)
10267 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
10268 const bool result = sax_parse_internal(sax);
10271 if (result && strict && (get_token() != token_type::end_of_input))
10273 return sax->parse_error(m_lexer.get_position(),
10274 m_lexer.get_token_string(),
10275 parse_error::create(101, m_lexer.get_position(),
10276 exception_message(token_type::end_of_input,
"value")));
10283 template<
typename SAX>
10284 JSON_HEDLEY_NON_NULL(2)
10285 bool sax_parse_internal(SAX* sax)
10289 std::vector<bool> states;
10291 bool skip_to_state_evaluation =
false;
10295 if (!skip_to_state_evaluation)
10298 switch (last_token)
10300 case token_type::begin_object:
10302 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10308 if (get_token() == token_type::end_object)
10310 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10318 if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
10320 return sax->parse_error(m_lexer.get_position(),
10321 m_lexer.get_token_string(),
10322 parse_error::create(101, m_lexer.get_position(),
10323 exception_message(token_type::value_string,
"object key")));
10325 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10331 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10333 return sax->parse_error(m_lexer.get_position(),
10334 m_lexer.get_token_string(),
10335 parse_error::create(101, m_lexer.get_position(),
10336 exception_message(token_type::name_separator,
"object separator")));
10340 states.push_back(
false);
10347 case token_type::begin_array:
10349 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10355 if (get_token() == token_type::end_array)
10357 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10365 states.push_back(
true);
10371 case token_type::value_float:
10373 const auto res = m_lexer.get_number_float();
10375 if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
10377 return sax->parse_error(m_lexer.get_position(),
10378 m_lexer.get_token_string(),
10379 out_of_range::create(406,
"number overflow parsing '" + m_lexer.get_token_string() +
"'"));
10382 if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
10390 case token_type::literal_false:
10392 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
false)))
10399 case token_type::literal_null:
10401 if (JSON_HEDLEY_UNLIKELY(!sax->null()))
10408 case token_type::literal_true:
10410 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(
true)))
10417 case token_type::value_integer:
10419 if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
10426 case token_type::value_string:
10428 if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
10435 case token_type::value_unsigned:
10437 if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
10444 case token_type::parse_error:
10447 return sax->parse_error(m_lexer.get_position(),
10448 m_lexer.get_token_string(),
10449 parse_error::create(101, m_lexer.get_position(),
10450 exception_message(token_type::uninitialized,
"value")));
10455 return sax->parse_error(m_lexer.get_position(),
10456 m_lexer.get_token_string(),
10457 parse_error::create(101, m_lexer.get_position(),
10458 exception_message(token_type::literal_or_value,
"value")));
10464 skip_to_state_evaluation =
false;
10468 if (states.empty())
10477 if (get_token() == token_type::value_separator)
10485 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
10487 if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10496 JSON_ASSERT(!states.empty());
10498 skip_to_state_evaluation =
true;
10502 return sax->parse_error(m_lexer.get_position(),
10503 m_lexer.get_token_string(),
10504 parse_error::create(101, m_lexer.get_position(),
10505 exception_message(token_type::end_array,
"array")));
10510 if (get_token() == token_type::value_separator)
10513 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
10515 return sax->parse_error(m_lexer.get_position(),
10516 m_lexer.get_token_string(),
10517 parse_error::create(101, m_lexer.get_position(),
10518 exception_message(token_type::value_string,
"object key")));
10521 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10527 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10529 return sax->parse_error(m_lexer.get_position(),
10530 m_lexer.get_token_string(),
10531 parse_error::create(101, m_lexer.get_position(),
10532 exception_message(token_type::name_separator,
"object separator")));
10541 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
10543 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10552 JSON_ASSERT(!states.empty());
10554 skip_to_state_evaluation =
true;
10558 return sax->parse_error(m_lexer.get_position(),
10559 m_lexer.get_token_string(),
10560 parse_error::create(101, m_lexer.get_position(),
10561 exception_message(token_type::end_object,
"object")));
10567 token_type get_token()
10569 return last_token = m_lexer.scan();
10572 std::string exception_message(
const token_type expected,
const std::string& context)
10574 std::string error_msg =
"syntax error ";
10576 if (!context.empty())
10578 error_msg +=
"while parsing " + context +
" ";
10583 if (last_token == token_type::parse_error)
10585 error_msg += std::string(m_lexer.get_error_message()) +
"; last read: '" +
10586 m_lexer.get_token_string() +
"'";
10590 error_msg +=
"unexpected " + std::string(lexer_t::token_type_name(last_token));
10593 if (expected != token_type::uninitialized)
10595 error_msg +=
"; expected " + std::string(lexer_t::token_type_name(expected));
10603 const parser_callback_t<BasicJsonType> callback =
nullptr;
10605 token_type last_token = token_type::uninitialized;
10609 const bool allow_exceptions =
true;
10636 class primitive_iterator_t
10639 using difference_type = std::ptrdiff_t;
10640 static constexpr difference_type begin_value = 0;
10641 static constexpr difference_type end_value = begin_value + 1;
10644 difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
10647 constexpr difference_type get_value() const noexcept
10653 void set_begin() noexcept
10655 m_it = begin_value;
10659 void set_end() noexcept
10665 constexpr
bool is_begin() const noexcept
10667 return m_it == begin_value;
10671 constexpr
bool is_end() const noexcept
10673 return m_it == end_value;
10676 friend constexpr
bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10678 return lhs.m_it == rhs.m_it;
10681 friend constexpr
bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10683 return lhs.m_it < rhs.m_it;
10686 primitive_iterator_t operator+(difference_type n) noexcept
10688 auto result = *
this;
10693 friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10695 return lhs.m_it - rhs.m_it;
10698 primitive_iterator_t& operator++() noexcept
10704 primitive_iterator_t
const operator++(
int) noexcept
10706 auto result = *
this;
10711 primitive_iterator_t& operator--() noexcept
10717 primitive_iterator_t
const operator--(
int) noexcept
10719 auto result = *
this;
10724 primitive_iterator_t& operator+=(difference_type n) noexcept
10730 primitive_iterator_t& operator-=(difference_type n) noexcept
10750 template<
typename BasicJsonType>
struct internal_iterator
10753 typename BasicJsonType::object_t::iterator object_iterator {};
10755 typename BasicJsonType::array_t::iterator array_iterator {};
10757 primitive_iterator_t primitive_iterator {};
10765 #include <iterator>
10766 #include <type_traits>
10788 template<
typename IteratorType>
class iteration_proxy;
10789 template<
typename IteratorType>
class iteration_proxy_value;
10807 template<
typename BasicJsonType>
10811 friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value,
typename std::remove_const<BasicJsonType>::type,
const BasicJsonType>::type>;
10812 friend BasicJsonType;
10813 friend iteration_proxy<iter_impl>;
10814 friend iteration_proxy_value<iter_impl>;
10816 using object_t =
typename BasicJsonType::object_t;
10817 using array_t =
typename BasicJsonType::array_t;
10819 static_assert(is_basic_json<
typename std::remove_const<BasicJsonType>::type>::value,
10820 "iter_impl only accepts (const) basic_json");
10829 using iterator_category = std::bidirectional_iterator_tag;
10832 using value_type =
typename BasicJsonType::value_type;
10834 using difference_type =
typename BasicJsonType::difference_type;
10836 using pointer =
typename std::conditional<std::is_const<BasicJsonType>::value,
10837 typename BasicJsonType::const_pointer,
10838 typename BasicJsonType::pointer>::type;
10841 typename std::conditional<std::is_const<BasicJsonType>::value,
10842 typename BasicJsonType::const_reference,
10843 typename BasicJsonType::reference>::type;
10846 iter_impl() =
default;
10854 explicit iter_impl(pointer
object) noexcept : m_object(
object)
10856 JSON_ASSERT(m_object !=
nullptr);
10858 switch (m_object->m_type)
10860 case value_t::object:
10862 m_it.object_iterator =
typename object_t::iterator();
10866 case value_t::array:
10868 m_it.array_iterator =
typename array_t::iterator();
10874 m_it.primitive_iterator = primitive_iterator_t();
10896 iter_impl(
const iter_impl<const BasicJsonType>& other) noexcept
10897 : m_object(other.m_object), m_it(other.m_it)
10906 iter_impl& operator=(
const iter_impl<const BasicJsonType>& other) noexcept
10908 m_object = other.m_object;
10918 iter_impl(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
10919 : m_object(other.m_object), m_it(other.m_it)
10928 iter_impl& operator=(
const iter_impl<
typename std::remove_const<BasicJsonType>::type>& other) noexcept
10930 m_object = other.m_object;
10940 void set_begin() noexcept
10942 JSON_ASSERT(m_object !=
nullptr);
10944 switch (m_object->m_type)
10946 case value_t::object:
10948 m_it.object_iterator = m_object->m_value.object->begin();
10952 case value_t::array:
10954 m_it.array_iterator = m_object->m_value.array->begin();
10958 case value_t::null:
10961 m_it.primitive_iterator.set_end();
10967 m_it.primitive_iterator.set_begin();
10977 void set_end() noexcept
10979 JSON_ASSERT(m_object !=
nullptr);
10981 switch (m_object->m_type)
10983 case value_t::object:
10985 m_it.object_iterator = m_object->m_value.object->end();
10989 case value_t::array:
10991 m_it.array_iterator = m_object->m_value.array->end();
10997 m_it.primitive_iterator.set_end();
11008 reference operator*()
const
11010 JSON_ASSERT(m_object !=
nullptr);
11012 switch (m_object->m_type)
11014 case value_t::object:
11016 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11017 return m_it.object_iterator->second;
11020 case value_t::array:
11022 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11023 return *m_it.array_iterator;
11026 case value_t::null:
11027 JSON_THROW(invalid_iterator::create(214,
"cannot get value"));
11031 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11036 JSON_THROW(invalid_iterator::create(214,
"cannot get value"));
11045 pointer operator->()
const
11047 JSON_ASSERT(m_object !=
nullptr);
11049 switch (m_object->m_type)
11051 case value_t::object:
11053 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11054 return &(m_it.object_iterator->second);
11057 case value_t::array:
11059 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11060 return &*m_it.array_iterator;
11065 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11070 JSON_THROW(invalid_iterator::create(214,
"cannot get value"));
11079 iter_impl
const operator++(
int)
11081 auto result = *
this;
11090 iter_impl& operator++()
11092 JSON_ASSERT(m_object !=
nullptr);
11094 switch (m_object->m_type)
11096 case value_t::object:
11098 std::advance(m_it.object_iterator, 1);
11102 case value_t::array:
11104 std::advance(m_it.array_iterator, 1);
11110 ++m_it.primitive_iterator;
11122 iter_impl
const operator--(
int)
11124 auto result = *
this;
11133 iter_impl& operator--()
11135 JSON_ASSERT(m_object !=
nullptr);
11137 switch (m_object->m_type)
11139 case value_t::object:
11141 std::advance(m_it.object_iterator, -1);
11145 case value_t::array:
11147 std::advance(m_it.array_iterator, -1);
11153 --m_it.primitive_iterator;
11165 bool operator==(
const iter_impl& other)
const
11168 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11170 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers"));
11173 JSON_ASSERT(m_object !=
nullptr);
11175 switch (m_object->m_type)
11177 case value_t::object:
11178 return (m_it.object_iterator == other.m_it.object_iterator);
11180 case value_t::array:
11181 return (m_it.array_iterator == other.m_it.array_iterator);
11184 return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11192 bool operator!=(
const iter_impl& other)
const
11194 return !operator==(other);
11201 bool operator<(
const iter_impl& other)
const
11204 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11206 JSON_THROW(invalid_iterator::create(212,
"cannot compare iterators of different containers"));
11209 JSON_ASSERT(m_object !=
nullptr);
11211 switch (m_object->m_type)
11213 case value_t::object:
11214 JSON_THROW(invalid_iterator::create(213,
"cannot compare order of object iterators"));
11216 case value_t::array:
11217 return (m_it.array_iterator < other.m_it.array_iterator);
11220 return (m_it.primitive_iterator < other.m_it.primitive_iterator);
11228 bool operator<=(
const iter_impl& other)
const
11230 return !other.operator < (*this);
11237 bool operator>(
const iter_impl& other)
const
11239 return !operator<=(other);
11246 bool operator>=(
const iter_impl& other)
const
11248 return !operator<(other);
11255 iter_impl& operator+=(difference_type i)
11257 JSON_ASSERT(m_object !=
nullptr);
11259 switch (m_object->m_type)
11261 case value_t::object:
11262 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators"));
11264 case value_t::array:
11266 std::advance(m_it.array_iterator, i);
11272 m_it.primitive_iterator += i;
11284 iter_impl& operator-=(difference_type i)
11286 return operator+=(-i);
11293 iter_impl operator+(difference_type i)
const
11295 auto result = *
this;
11304 friend iter_impl operator+(difference_type i,
const iter_impl& it)
11315 iter_impl operator-(difference_type i)
const
11317 auto result = *
this;
11326 difference_type operator-(
const iter_impl& other)
const
11328 JSON_ASSERT(m_object !=
nullptr);
11330 switch (m_object->m_type)
11332 case value_t::object:
11333 JSON_THROW(invalid_iterator::create(209,
"cannot use offsets with object iterators"));
11335 case value_t::array:
11336 return m_it.array_iterator - other.m_it.array_iterator;
11339 return m_it.primitive_iterator - other.m_it.primitive_iterator;
11347 reference operator[](difference_type n)
const
11349 JSON_ASSERT(m_object !=
nullptr);
11351 switch (m_object->m_type)
11353 case value_t::object:
11354 JSON_THROW(invalid_iterator::create(208,
"cannot use operator[] for object iterators"));
11356 case value_t::array:
11357 return *std::next(m_it.array_iterator, n);
11359 case value_t::null:
11360 JSON_THROW(invalid_iterator::create(214,
"cannot get value"));
11364 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
11369 JSON_THROW(invalid_iterator::create(214,
"cannot get value"));
11378 const typename object_t::key_type& key()
const
11380 JSON_ASSERT(m_object !=
nullptr);
11382 if (JSON_HEDLEY_LIKELY(m_object->is_object()))
11384 return m_it.object_iterator->first;
11387 JSON_THROW(invalid_iterator::create(207,
"cannot use key() for non-object iterators"));
11394 reference value()
const
11396 return operator*();
11401 pointer m_object =
nullptr;
11403 internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
11414 #include <iterator>
11443 template<
typename Base>
11444 class json_reverse_iterator :
public std::reverse_iterator<Base>
11447 using difference_type = std::ptrdiff_t;
11449 using base_iterator = std::reverse_iterator<Base>;
11451 using reference =
typename Base::reference;
11454 explicit json_reverse_iterator(
const typename base_iterator::iterator_type& it) noexcept
11455 : base_iterator(it) {}
11458 explicit json_reverse_iterator(
const base_iterator& it) noexcept : base_iterator(it) {}
11461 json_reverse_iterator
const operator++(
int)
11463 return static_cast<json_reverse_iterator
>(base_iterator::operator++(1));
11467 json_reverse_iterator& operator++()
11469 return static_cast<json_reverse_iterator&
>(base_iterator::operator++());
11473 json_reverse_iterator
const operator--(
int)
11475 return static_cast<json_reverse_iterator
>(base_iterator::operator--(1));
11479 json_reverse_iterator& operator--()
11481 return static_cast<json_reverse_iterator&
>(base_iterator::operator--());
11485 json_reverse_iterator& operator+=(difference_type i)
11487 return static_cast<json_reverse_iterator&
>(base_iterator::operator+=(i));
11491 json_reverse_iterator operator+(difference_type i)
const
11493 return static_cast<json_reverse_iterator
>(base_iterator::operator+(i));
11497 json_reverse_iterator operator-(difference_type i)
const
11499 return static_cast<json_reverse_iterator
>(base_iterator::operator-(i));
11503 difference_type operator-(
const json_reverse_iterator& other)
const
11505 return base_iterator(*
this) - base_iterator(other);
11509 reference operator[](difference_type n)
const
11511 return *(this->operator+(n));
11515 auto key() const -> decltype(std::declval<Base>().key())
11517 auto it = --this->base();
11522 reference value()
const
11524 auto it = --this->base();
11525 return it.operator * ();
11536 #include <algorithm>
11553 template<
typename BasicJsonType>
11557 NLOHMANN_BASIC_JSON_TPL_DECLARATION
11583 : reference_tokens(split(s))
11602 return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
11604 [](
const std::string & a,
const std::string & b)
11606 return a +
"/" + escape(b);
11611 operator std::string()
const
11634 reference_tokens.insert(reference_tokens.end(),
11635 ptr.reference_tokens.begin(),
11636 ptr.reference_tokens.end());
11680 return *
this /= std::to_string(array_idx);
11784 if (JSON_HEDLEY_UNLIKELY(
empty()))
11786 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent"));
11789 reference_tokens.pop_back();
11808 if (JSON_HEDLEY_UNLIKELY(
empty()))
11810 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent"));
11813 return reference_tokens.back();
11830 reference_tokens.push_back(token);
11836 reference_tokens.push_back(std::move(token));
11855 return reference_tokens.empty();
11869 static typename BasicJsonType::size_type array_index(
const std::string& s)
11871 using size_type =
typename BasicJsonType::size_type;
11874 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] ==
'0'))
11876 JSON_THROW(detail::parse_error::create(106, 0,
11877 "array index '" + s +
11878 "' must not begin with '0'"));
11882 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >=
'1' && s[0] <=
'9')))
11884 JSON_THROW(detail::parse_error::create(109, 0,
"array index '" + s +
"' is not a number"));
11887 std::size_t processed_chars = 0;
11888 unsigned long long res = 0;
11891 res = std::stoull(s, &processed_chars);
11893 JSON_CATCH(std::out_of_range&)
11895 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'"));
11899 if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
11901 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + s +
"'"));
11906 if (res >=
static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
11908 JSON_THROW(detail::out_of_range::create(410,
"array index " + s +
" exceeds size_type"));
11911 return static_cast<size_type
>(res);
11916 if (JSON_HEDLEY_UNLIKELY(
empty()))
11918 JSON_THROW(detail::out_of_range::create(405,
"JSON pointer has no parent"));
11922 result.reference_tokens = {reference_tokens[0]};
11934 BasicJsonType& get_and_create(BasicJsonType& j)
const
11940 for (
const auto& reference_token : reference_tokens)
11942 switch (result->type())
11944 case detail::value_t::null:
11946 if (reference_token ==
"0")
11949 result = &result->operator[](0);
11954 result = &result->operator[](reference_token);
11959 case detail::value_t::object:
11962 result = &result->operator[](reference_token);
11966 case detail::value_t::array:
11969 result = &result->operator[](array_index(reference_token));
11980 JSON_THROW(detail::type_error::create(313,
"invalid value to unflatten"));
12006 BasicJsonType& get_unchecked(BasicJsonType* ptr)
const
12008 for (
const auto& reference_token : reference_tokens)
12011 if (ptr->is_null())
12015 std::all_of(reference_token.begin(), reference_token.end(),
12016 [](
const unsigned char x)
12018 return std::isdigit(x);
12022 *ptr = (nums || reference_token ==
"-")
12023 ? detail::value_t::array
12024 : detail::value_t::object;
12027 switch (ptr->type())
12029 case detail::value_t::object:
12032 ptr = &ptr->operator[](reference_token);
12036 case detail::value_t::array:
12038 if (reference_token ==
"-")
12041 ptr = &ptr->operator[](ptr->m_value.array->size());
12046 ptr = &ptr->operator[](array_index(reference_token));
12052 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'"));
12065 BasicJsonType& get_checked(BasicJsonType* ptr)
const
12067 for (
const auto& reference_token : reference_tokens)
12069 switch (ptr->type())
12071 case detail::value_t::object:
12074 ptr = &ptr->at(reference_token);
12078 case detail::value_t::array:
12080 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12083 JSON_THROW(detail::out_of_range::create(402,
12084 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12085 ") is out of range"));
12089 ptr = &ptr->at(array_index(reference_token));
12094 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'"));
12114 const BasicJsonType& get_unchecked(
const BasicJsonType* ptr)
const
12116 for (
const auto& reference_token : reference_tokens)
12118 switch (ptr->type())
12120 case detail::value_t::object:
12123 ptr = &ptr->operator[](reference_token);
12127 case detail::value_t::array:
12129 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12132 JSON_THROW(detail::out_of_range::create(402,
12133 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12134 ") is out of range"));
12138 ptr = &ptr->operator[](array_index(reference_token));
12143 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'"));
12156 const BasicJsonType& get_checked(
const BasicJsonType* ptr)
const
12158 for (
const auto& reference_token : reference_tokens)
12160 switch (ptr->type())
12162 case detail::value_t::object:
12165 ptr = &ptr->at(reference_token);
12169 case detail::value_t::array:
12171 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12174 JSON_THROW(detail::out_of_range::create(402,
12175 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12176 ") is out of range"));
12180 ptr = &ptr->at(array_index(reference_token));
12185 JSON_THROW(detail::out_of_range::create(404,
"unresolved reference token '" + reference_token +
"'"));
12196 bool contains(
const BasicJsonType* ptr)
const
12198 for (
const auto& reference_token : reference_tokens)
12200 switch (ptr->type())
12202 case detail::value_t::object:
12204 if (!ptr->contains(reference_token))
12210 ptr = &ptr->operator[](reference_token);
12214 case detail::value_t::array:
12216 if (JSON_HEDLEY_UNLIKELY(reference_token ==
"-"))
12221 if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !(
"0" <= reference_token && reference_token <=
"9")))
12226 if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
12228 if (JSON_HEDLEY_UNLIKELY(!(
'1' <= reference_token[0] && reference_token[0] <=
'9')))
12233 for (std::size_t i = 1; i < reference_token.size(); i++)
12235 if (JSON_HEDLEY_UNLIKELY(!(
'0' <= reference_token[i] && reference_token[i] <=
'9')))
12243 const auto idx = array_index(reference_token);
12244 if (idx >= ptr->size())
12250 ptr = &ptr->operator[](idx);
12276 static std::vector<std::string> split(
const std::string& reference_string)
12278 std::vector<std::string> result;
12281 if (reference_string.empty())
12287 if (JSON_HEDLEY_UNLIKELY(reference_string[0] !=
'/'))
12289 JSON_THROW(detail::parse_error::create(107, 1,
12290 "JSON pointer must be empty or begin with '/' - was: '" +
12291 reference_string +
"'"));
12299 std::size_t slash = reference_string.find_first_of(
'/', 1),
12306 start = (slash == std::string::npos) ? 0 : slash + 1,
12308 slash = reference_string.find_first_of(
'/', start))
12312 auto reference_token = reference_string.substr(start, slash - start);
12315 for (std::size_t pos = reference_token.find_first_of(
'~');
12316 pos != std::string::npos;
12317 pos = reference_token.find_first_of(
'~', pos + 1))
12319 JSON_ASSERT(reference_token[pos] ==
'~');
12322 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
12323 (reference_token[pos + 1] !=
'0' &&
12324 reference_token[pos + 1] !=
'1')))
12326 JSON_THROW(detail::parse_error::create(108, 0,
"escape character '~' must be followed with '0' or '1'"));
12331 unescape(reference_token);
12332 result.push_back(reference_token);
12351 static void replace_substring(std::string& s,
const std::string& f,
12352 const std::string& t)
12354 JSON_ASSERT(!f.empty());
12355 for (
auto pos = s.find(f);
12356 pos != std::string::npos;
12357 s.replace(pos, f.size(), t),
12358 pos = s.find(f, pos + t.size()))
12363 static std::string escape(std::string s)
12365 replace_substring(s,
"~",
"~0");
12366 replace_substring(s,
"/",
"~1");
12371 static void unescape(std::string& s)
12373 replace_substring(s,
"~1",
"/");
12374 replace_substring(s,
"~0",
"~");
12384 static void flatten(
const std::string& reference_string,
12385 const BasicJsonType& value,
12386 BasicJsonType& result)
12388 switch (value.type())
12390 case detail::value_t::array:
12392 if (value.m_value.array->empty())
12395 result[reference_string] =
nullptr;
12400 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
12402 flatten(reference_string +
"/" + std::to_string(i),
12403 value.m_value.array->operator[](i), result);
12409 case detail::value_t::object:
12411 if (value.m_value.object->empty())
12414 result[reference_string] =
nullptr;
12419 for (
const auto& element : *value.m_value.object)
12421 flatten(reference_string +
"/" + escape(element.first), element.second, result);
12430 result[reference_string] = value;
12446 static BasicJsonType
12447 unflatten(
const BasicJsonType& value)
12449 if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
12451 JSON_THROW(detail::type_error::create(314,
"only objects can be unflattened"));
12454 BasicJsonType result;
12457 for (
const auto& element : *value.m_value.object)
12459 if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
12461 JSON_THROW(detail::type_error::create(315,
"values in object must be primitive"));
12468 json_pointer(element.first).get_and_create(result) = element.second;
12488 return lhs.reference_tokens == rhs.reference_tokens;
12505 return !(lhs == rhs);
12509 std::vector<std::string> reference_tokens;
12516 #include <initializer_list>
12526 template<
typename BasicJsonType>
12530 using value_type = BasicJsonType;
12532 json_ref(value_type&& value)
12533 : owned_value(std::move(value))
12534 , value_ref(&owned_value)
12538 json_ref(
const value_type& value)
12539 : value_ref(const_cast<value_type*>(&value))
12543 json_ref(std::initializer_list<json_ref> init)
12544 : owned_value(init)
12545 , value_ref(&owned_value)
12551 enable_if_t<std::is_constructible<value_type, Args...>::value,
int> = 0 >
12552 json_ref(Args && ... args)
12553 : owned_value(std::forward<Args>(args)...)
12554 , value_ref(&owned_value)
12559 json_ref(json_ref&&) =
default;
12560 json_ref(
const json_ref&) =
delete;
12561 json_ref& operator=(
const json_ref&) =
delete;
12562 json_ref& operator=(json_ref&&) =
delete;
12563 ~json_ref() =
default;
12565 value_type moved_or_copied()
const
12569 return std::move(*value_ref);
12574 value_type
const& operator*()
const
12576 return *
static_cast<value_type const*
>(value_ref);
12579 value_type
const* operator->()
const
12581 return static_cast<value_type const*
>(value_ref);
12585 mutable value_type owned_value =
nullptr;
12586 value_type* value_ref =
nullptr;
12587 const bool is_rvalue =
true;
12601 #include <algorithm>
12616 #include <algorithm>
12619 #include <iterator>
12632 template<
typename CharType>
struct output_adapter_protocol
12634 virtual void write_character(CharType c) = 0;
12635 virtual void write_characters(
const CharType* s, std::size_t length) = 0;
12636 virtual ~output_adapter_protocol() =
default;
12640 template<
typename CharType>
12641 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
12644 template<
typename CharType>
12645 class output_vector_adapter :
public output_adapter_protocol<CharType>
12648 explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
12652 void write_character(CharType c)
override
12657 JSON_HEDLEY_NON_NULL(2)
12658 void write_characters(const CharType* s, std::
size_t length)
override
12660 std::copy(s, s + length, std::back_inserter(v));
12664 std::vector<CharType>& v;
12668 template<
typename CharType>
12669 class output_stream_adapter :
public output_adapter_protocol<CharType>
12672 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
12676 void write_character(CharType c)
override
12681 JSON_HEDLEY_NON_NULL(2)
12682 void write_characters(const CharType* s, std::
size_t length)
override
12684 stream.write(s,
static_cast<std::streamsize
>(length));
12688 std::basic_ostream<CharType>& stream;
12692 template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
12693 class output_string_adapter :
public output_adapter_protocol<CharType>
12696 explicit output_string_adapter(StringType& s) noexcept
12700 void write_character(CharType c)
override
12705 JSON_HEDLEY_NON_NULL(2)
12706 void write_characters(const CharType* s, std::
size_t length)
override
12708 str.append(s, length);
12715 template<
typename CharType,
typename StringType = std::basic_
string<CharType>>
12716 class output_adapter
12719 output_adapter(std::vector<CharType>& vec)
12720 : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
12722 output_adapter(std::basic_ostream<CharType>& s)
12723 : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
12725 output_adapter(StringType& s)
12726 : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
12728 operator output_adapter_t<CharType>()
12734 output_adapter_t<CharType> oa =
nullptr;
12751 template<
typename BasicJsonType,
typename CharType>
12752 class binary_writer
12754 using string_t =
typename BasicJsonType::string_t;
12755 using binary_t =
typename BasicJsonType::binary_t;
12756 using number_float_t =
typename BasicJsonType::number_float_t;
12764 explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
12773 void write_bson(
const BasicJsonType& j)
12777 case value_t::object:
12779 write_bson_object(*j.m_value.object);
12785 JSON_THROW(type_error::create(317,
"to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
12793 void write_cbor(
const BasicJsonType& j)
12797 case value_t::null:
12799 oa->write_character(to_char_type(0xF6));
12803 case value_t::boolean:
12805 oa->write_character(j.m_value.boolean
12806 ? to_char_type(0xF5)
12807 : to_char_type(0xF4));
12811 case value_t::number_integer:
12813 if (j.m_value.number_integer >= 0)
12818 if (j.m_value.number_integer <= 0x17)
12820 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
12822 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
12824 oa->write_character(to_char_type(0x18));
12825 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
12827 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
12829 oa->write_character(to_char_type(0x19));
12830 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
12832 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
12834 oa->write_character(to_char_type(0x1A));
12835 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
12839 oa->write_character(to_char_type(0x1B));
12840 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
12847 const auto positive_number = -1 - j.m_value.number_integer;
12848 if (j.m_value.number_integer >= -24)
12850 write_number(
static_cast<std::uint8_t
>(0x20 + positive_number));
12852 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
12854 oa->write_character(to_char_type(0x38));
12855 write_number(
static_cast<std::uint8_t
>(positive_number));
12857 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
12859 oa->write_character(to_char_type(0x39));
12860 write_number(
static_cast<std::uint16_t
>(positive_number));
12862 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
12864 oa->write_character(to_char_type(0x3A));
12865 write_number(
static_cast<std::uint32_t
>(positive_number));
12869 oa->write_character(to_char_type(0x3B));
12870 write_number(
static_cast<std::uint64_t
>(positive_number));
12876 case value_t::number_unsigned:
12878 if (j.m_value.number_unsigned <= 0x17)
12880 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
12882 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
12884 oa->write_character(to_char_type(0x18));
12885 write_number(
static_cast<std::uint8_t
>(j.m_value.number_unsigned));
12887 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
12889 oa->write_character(to_char_type(0x19));
12890 write_number(
static_cast<std::uint16_t
>(j.m_value.number_unsigned));
12892 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
12894 oa->write_character(to_char_type(0x1A));
12895 write_number(
static_cast<std::uint32_t
>(j.m_value.number_unsigned));
12899 oa->write_character(to_char_type(0x1B));
12900 write_number(
static_cast<std::uint64_t
>(j.m_value.number_unsigned));
12905 case value_t::number_float:
12907 if (std::isnan(j.m_value.number_float))
12910 oa->write_character(to_char_type(0xF9));
12911 oa->write_character(to_char_type(0x7E));
12912 oa->write_character(to_char_type(0x00));
12914 else if (std::isinf(j.m_value.number_float))
12917 oa->write_character(to_char_type(0xf9));
12918 oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
12919 oa->write_character(to_char_type(0x00));
12923 write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
12928 case value_t::string:
12931 const auto N = j.m_value.string->size();
12934 write_number(
static_cast<std::uint8_t
>(0x60 + N));
12936 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
12938 oa->write_character(to_char_type(0x78));
12939 write_number(
static_cast<std::uint8_t
>(N));
12941 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
12943 oa->write_character(to_char_type(0x79));
12944 write_number(
static_cast<std::uint16_t
>(N));
12946 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
12948 oa->write_character(to_char_type(0x7A));
12949 write_number(
static_cast<std::uint32_t
>(N));
12952 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
12954 oa->write_character(to_char_type(0x7B));
12955 write_number(
static_cast<std::uint64_t
>(N));
12960 oa->write_characters(
12961 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
12962 j.m_value.string->size());
12966 case value_t::array:
12969 const auto N = j.m_value.array->size();
12972 write_number(
static_cast<std::uint8_t
>(0x80 + N));
12974 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
12976 oa->write_character(to_char_type(0x98));
12977 write_number(
static_cast<std::uint8_t
>(N));
12979 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
12981 oa->write_character(to_char_type(0x99));
12982 write_number(
static_cast<std::uint16_t
>(N));
12984 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
12986 oa->write_character(to_char_type(0x9A));
12987 write_number(
static_cast<std::uint32_t
>(N));
12990 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
12992 oa->write_character(to_char_type(0x9B));
12993 write_number(
static_cast<std::uint64_t
>(N));
12998 for (
const auto& el : *j.m_value.array)
13005 case value_t::binary:
13007 if (j.m_value.binary->has_subtype())
13009 write_number(
static_cast<std::uint8_t
>(0xd8));
13010 write_number(j.m_value.binary->subtype());
13014 const auto N = j.m_value.binary->size();
13017 write_number(
static_cast<std::uint8_t
>(0x40 + N));
13019 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13021 oa->write_character(to_char_type(0x58));
13022 write_number(
static_cast<std::uint8_t
>(N));
13024 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13026 oa->write_character(to_char_type(0x59));
13027 write_number(
static_cast<std::uint16_t
>(N));
13029 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13031 oa->write_character(to_char_type(0x5A));
13032 write_number(
static_cast<std::uint32_t
>(N));
13035 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13037 oa->write_character(to_char_type(0x5B));
13038 write_number(
static_cast<std::uint64_t
>(N));
13043 oa->write_characters(
13044 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13050 case value_t::object:
13053 const auto N = j.m_value.object->size();
13056 write_number(
static_cast<std::uint8_t
>(0xA0 + N));
13058 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13060 oa->write_character(to_char_type(0xB8));
13061 write_number(
static_cast<std::uint8_t
>(N));
13063 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13065 oa->write_character(to_char_type(0xB9));
13066 write_number(
static_cast<std::uint16_t
>(N));
13068 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13070 oa->write_character(to_char_type(0xBA));
13071 write_number(
static_cast<std::uint32_t
>(N));
13074 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13076 oa->write_character(to_char_type(0xBB));
13077 write_number(
static_cast<std::uint64_t
>(N));
13082 for (
const auto& el : *j.m_value.object)
13084 write_cbor(el.first);
13085 write_cbor(el.second);
13098 void write_msgpack(
const BasicJsonType& j)
13102 case value_t::null:
13104 oa->write_character(to_char_type(0xC0));
13108 case value_t::boolean:
13110 oa->write_character(j.m_value.boolean
13111 ? to_char_type(0xC3)
13112 : to_char_type(0xC2));
13116 case value_t::number_integer:
13118 if (j.m_value.number_integer >= 0)
13123 if (j.m_value.number_unsigned < 128)
13126 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13128 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13131 oa->write_character(to_char_type(0xCC));
13132 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13134 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13137 oa->write_character(to_char_type(0xCD));
13138 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13140 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13143 oa->write_character(to_char_type(0xCE));
13144 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13146 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13149 oa->write_character(to_char_type(0xCF));
13150 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13155 if (j.m_value.number_integer >= -32)
13158 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
13160 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
13161 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
13164 oa->write_character(to_char_type(0xD0));
13165 write_number(
static_cast<std::int8_t
>(j.m_value.number_integer));
13167 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
13168 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
13171 oa->write_character(to_char_type(0xD1));
13172 write_number(
static_cast<std::int16_t
>(j.m_value.number_integer));
13174 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
13175 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
13178 oa->write_character(to_char_type(0xD2));
13179 write_number(
static_cast<std::int32_t
>(j.m_value.number_integer));
13181 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
13182 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
13185 oa->write_character(to_char_type(0xD3));
13186 write_number(
static_cast<std::int64_t
>(j.m_value.number_integer));
13192 case value_t::number_unsigned:
13194 if (j.m_value.number_unsigned < 128)
13197 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13199 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13202 oa->write_character(to_char_type(0xCC));
13203 write_number(
static_cast<std::uint8_t
>(j.m_value.number_integer));
13205 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13208 oa->write_character(to_char_type(0xCD));
13209 write_number(
static_cast<std::uint16_t
>(j.m_value.number_integer));
13211 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13214 oa->write_character(to_char_type(0xCE));
13215 write_number(
static_cast<std::uint32_t
>(j.m_value.number_integer));
13217 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13220 oa->write_character(to_char_type(0xCF));
13221 write_number(
static_cast<std::uint64_t
>(j.m_value.number_integer));
13226 case value_t::number_float:
13228 write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
13232 case value_t::string:
13235 const auto N = j.m_value.string->size();
13239 write_number(
static_cast<std::uint8_t
>(0xA0 | N));
13241 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13244 oa->write_character(to_char_type(0xD9));
13245 write_number(
static_cast<std::uint8_t
>(N));
13247 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13250 oa->write_character(to_char_type(0xDA));
13251 write_number(
static_cast<std::uint16_t
>(N));
13253 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13256 oa->write_character(to_char_type(0xDB));
13257 write_number(
static_cast<std::uint32_t
>(N));
13261 oa->write_characters(
13262 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13263 j.m_value.string->size());
13267 case value_t::array:
13270 const auto N = j.m_value.array->size();
13274 write_number(
static_cast<std::uint8_t
>(0x90 | N));
13276 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13279 oa->write_character(to_char_type(0xDC));
13280 write_number(
static_cast<std::uint16_t
>(N));
13282 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13285 oa->write_character(to_char_type(0xDD));
13286 write_number(
static_cast<std::uint32_t
>(N));
13290 for (
const auto& el : *j.m_value.array)
13297 case value_t::binary:
13301 const bool use_ext = j.m_value.binary->has_subtype();
13304 const auto N = j.m_value.binary->size();
13305 if (N <= (std::numeric_limits<std::uint8_t>::max)())
13307 std::uint8_t output_type{};
13314 output_type = 0xD4;
13317 output_type = 0xD5;
13320 output_type = 0xD6;
13323 output_type = 0xD7;
13326 output_type = 0xD8;
13329 output_type = 0xC7;
13337 output_type = 0xC4;
13341 oa->write_character(to_char_type(output_type));
13344 write_number(
static_cast<std::uint8_t
>(N));
13347 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13349 std::uint8_t output_type = use_ext
13353 oa->write_character(to_char_type(output_type));
13354 write_number(
static_cast<std::uint16_t
>(N));
13356 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13358 std::uint8_t output_type = use_ext
13362 oa->write_character(to_char_type(output_type));
13363 write_number(
static_cast<std::uint32_t
>(N));
13369 write_number(
static_cast<std::int8_t
>(j.m_value.binary->subtype()));
13373 oa->write_characters(
13374 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13380 case value_t::object:
13383 const auto N = j.m_value.object->size();
13387 write_number(
static_cast<std::uint8_t
>(0x80 | (N & 0xF)));
13389 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13392 oa->write_character(to_char_type(0xDE));
13393 write_number(
static_cast<std::uint16_t
>(N));
13395 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13398 oa->write_character(to_char_type(0xDF));
13399 write_number(
static_cast<std::uint32_t
>(N));
13403 for (
const auto& el : *j.m_value.object)
13405 write_msgpack(el.first);
13406 write_msgpack(el.second);
13422 void write_ubjson(
const BasicJsonType& j,
const bool use_count,
13423 const bool use_type,
const bool add_prefix =
true)
13427 case value_t::null:
13431 oa->write_character(to_char_type(
'Z'));
13436 case value_t::boolean:
13440 oa->write_character(j.m_value.boolean
13441 ? to_char_type(
'T')
13442 : to_char_type(
'F'));
13447 case value_t::number_integer:
13449 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
13453 case value_t::number_unsigned:
13455 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
13459 case value_t::number_float:
13461 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
13465 case value_t::string:
13469 oa->write_character(to_char_type(
'S'));
13471 write_number_with_ubjson_prefix(j.m_value.string->size(),
true);
13472 oa->write_characters(
13473 reinterpret_cast<const CharType*
>(j.m_value.string->c_str()),
13474 j.m_value.string->size());
13478 case value_t::array:
13482 oa->write_character(to_char_type(
'['));
13485 bool prefix_required =
true;
13486 if (use_type && !j.m_value.array->empty())
13488 JSON_ASSERT(use_count);
13489 const CharType first_prefix = ubjson_prefix(j.front());
13490 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
13491 [
this, first_prefix](
const BasicJsonType & v)
13493 return ubjson_prefix(v) == first_prefix;
13498 prefix_required =
false;
13499 oa->write_character(to_char_type(
'$'));
13500 oa->write_character(first_prefix);
13506 oa->write_character(to_char_type(
'#'));
13507 write_number_with_ubjson_prefix(j.m_value.array->size(),
true);
13510 for (
const auto& el : *j.m_value.array)
13512 write_ubjson(el, use_count, use_type, prefix_required);
13517 oa->write_character(to_char_type(
']'));
13523 case value_t::binary:
13527 oa->write_character(to_char_type(
'['));
13530 if (use_type && !j.m_value.binary->empty())
13532 JSON_ASSERT(use_count);
13533 oa->write_character(to_char_type(
'$'));
13534 oa->write_character(
'U');
13539 oa->write_character(to_char_type(
'#'));
13540 write_number_with_ubjson_prefix(j.m_value.binary->size(),
true);
13545 oa->write_characters(
13546 reinterpret_cast<const CharType*
>(j.m_value.binary->data()),
13547 j.m_value.binary->size());
13551 for (
size_t i = 0; i < j.m_value.binary->size(); ++i)
13553 oa->write_character(to_char_type(
'U'));
13554 oa->write_character(j.m_value.binary->data()[i]);
13560 oa->write_character(to_char_type(
']'));
13566 case value_t::object:
13570 oa->write_character(to_char_type(
'{'));
13573 bool prefix_required =
true;
13574 if (use_type && !j.m_value.object->empty())
13576 JSON_ASSERT(use_count);
13577 const CharType first_prefix = ubjson_prefix(j.front());
13578 const bool same_prefix = std::all_of(j.begin(), j.end(),
13579 [
this, first_prefix](
const BasicJsonType & v)
13581 return ubjson_prefix(v) == first_prefix;
13586 prefix_required =
false;
13587 oa->write_character(to_char_type(
'$'));
13588 oa->write_character(first_prefix);
13594 oa->write_character(to_char_type(
'#'));
13595 write_number_with_ubjson_prefix(j.m_value.object->size(),
true);
13598 for (
const auto& el : *j.m_value.object)
13600 write_number_with_ubjson_prefix(el.first.size(),
true);
13601 oa->write_characters(
13602 reinterpret_cast<const CharType*
>(el.first.c_str()),
13604 write_ubjson(el.second, use_count, use_type, prefix_required);
13609 oa->write_character(to_char_type(
'}'));
13629 static std::size_t calc_bson_entry_header_size(
const string_t& name)
13631 const auto it = name.find(
static_cast<typename string_t::value_type
>(0));
13632 if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
13634 JSON_THROW(out_of_range::create(409,
13635 "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) +
")"));
13638 return 1ul + name.size() + 1u;
13644 void write_bson_entry_header(
const string_t& name,
13645 const std::uint8_t element_type)
13647 oa->write_character(to_char_type(element_type));
13648 oa->write_characters(
13649 reinterpret_cast<const CharType*
>(name.c_str()),
13656 void write_bson_boolean(
const string_t& name,
13659 write_bson_entry_header(name, 0x08);
13660 oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
13666 void write_bson_double(
const string_t& name,
13667 const double value)
13669 write_bson_entry_header(name, 0x01);
13670 write_number<double, true>(value);
13676 static std::size_t calc_bson_string_size(
const string_t& value)
13678 return sizeof(std::int32_t) + value.size() + 1ul;
13684 void write_bson_string(
const string_t& name,
13685 const string_t& value)
13687 write_bson_entry_header(name, 0x02);
13689 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size() + 1ul));
13690 oa->write_characters(
13691 reinterpret_cast<const CharType*
>(value.c_str()),
13698 void write_bson_null(
const string_t& name)
13700 write_bson_entry_header(name, 0x0A);
13706 static std::size_t calc_bson_integer_size(
const std::int64_t value)
13708 return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
13709 ?
sizeof(std::int32_t)
13710 :
sizeof(std::int64_t);
13716 void write_bson_integer(
const string_t& name,
13717 const std::int64_t value)
13719 if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
13721 write_bson_entry_header(name, 0x10);
13722 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value));
13726 write_bson_entry_header(name, 0x12);
13727 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(value));
13734 static constexpr std::size_t calc_bson_unsigned_size(
const std::uint64_t value) noexcept
13736 return (value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
13737 ?
sizeof(std::int32_t)
13738 :
sizeof(std::int64_t);
13744 void write_bson_unsigned(
const string_t& name,
13745 const std::uint64_t value)
13747 if (value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
13749 write_bson_entry_header(name, 0x10 );
13750 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value));
13752 else if (value <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
13754 write_bson_entry_header(name, 0x12 );
13755 write_number<std::int64_t, true>(
static_cast<std::int64_t
>(value));
13759 JSON_THROW(out_of_range::create(407,
"integer number " + std::to_string(value) +
" cannot be represented by BSON as it does not fit int64"));
13766 void write_bson_object_entry(
const string_t& name,
13767 const typename BasicJsonType::object_t& value)
13769 write_bson_entry_header(name, 0x03);
13770 write_bson_object(value);
13776 static std::size_t calc_bson_array_size(
const typename BasicJsonType::array_t& value)
13778 std::size_t array_index = 0ul;
13780 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)
13782 return result + calc_bson_element_size(std::to_string(array_index++), el);
13785 return sizeof(std::int32_t) + embedded_document_size + 1ul;
13791 static std::size_t calc_bson_binary_size(
const typename BasicJsonType::binary_t& value)
13793 return sizeof(std::int32_t) + value.size() + 1ul;
13799 void write_bson_array(
const string_t& name,
13800 const typename BasicJsonType::array_t& value)
13802 write_bson_entry_header(name, 0x04);
13803 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_array_size(value)));
13805 std::size_t array_index = 0ul;
13807 for (
const auto& el : value)
13809 write_bson_element(std::to_string(array_index++), el);
13812 oa->write_character(to_char_type(0x00));
13818 void write_bson_binary(
const string_t& name,
13819 const binary_t& value)
13821 write_bson_entry_header(name, 0x05);
13823 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(value.size()));
13824 write_number(value.has_subtype() ? value.subtype() : std::uint8_t(0x00));
13826 oa->write_characters(
reinterpret_cast<const CharType*
>(value.data()), value.size());
13833 static std::size_t calc_bson_element_size(
const string_t& name,
13834 const BasicJsonType& j)
13836 const auto header_size = calc_bson_entry_header_size(name);
13839 case value_t::object:
13840 return header_size + calc_bson_object_size(*j.m_value.object);
13842 case value_t::array:
13843 return header_size + calc_bson_array_size(*j.m_value.array);
13845 case value_t::binary:
13846 return header_size + calc_bson_binary_size(*j.m_value.binary);
13848 case value_t::boolean:
13849 return header_size + 1ul;
13851 case value_t::number_float:
13852 return header_size + 8ul;
13854 case value_t::number_integer:
13855 return header_size + calc_bson_integer_size(j.m_value.number_integer);
13857 case value_t::number_unsigned:
13858 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
13860 case value_t::string:
13861 return header_size + calc_bson_string_size(*j.m_value.string);
13863 case value_t::null:
13864 return header_size + 0ul;
13868 JSON_ASSERT(
false);
13881 void write_bson_element(
const string_t& name,
13882 const BasicJsonType& j)
13886 case value_t::object:
13887 return write_bson_object_entry(name, *j.m_value.object);
13889 case value_t::array:
13890 return write_bson_array(name, *j.m_value.array);
13892 case value_t::binary:
13893 return write_bson_binary(name, *j.m_value.binary);
13895 case value_t::boolean:
13896 return write_bson_boolean(name, j.m_value.boolean);
13898 case value_t::number_float:
13899 return write_bson_double(name, j.m_value.number_float);
13901 case value_t::number_integer:
13902 return write_bson_integer(name, j.m_value.number_integer);
13904 case value_t::number_unsigned:
13905 return write_bson_unsigned(name, j.m_value.number_unsigned);
13907 case value_t::string:
13908 return write_bson_string(name, *j.m_value.string);
13910 case value_t::null:
13911 return write_bson_null(name);
13915 JSON_ASSERT(
false);
13927 static std::size_t calc_bson_object_size(
const typename BasicJsonType::object_t& value)
13929 std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
13930 [](
size_t result,
const typename BasicJsonType::object_t::value_type & el)
13932 return result += calc_bson_element_size(el.first, el.second);
13935 return sizeof(std::int32_t) + document_size + 1ul;
13942 void write_bson_object(
const typename BasicJsonType::object_t& value)
13944 write_number<std::int32_t, true>(
static_cast<std::int32_t
>(calc_bson_object_size(value)));
13946 for (
const auto& el : value)
13948 write_bson_element(el.first, el.second);
13951 oa->write_character(to_char_type(0x00));
13958 static constexpr CharType get_cbor_float_prefix(
float )
13960 return to_char_type(0xFA);
13963 static constexpr CharType get_cbor_float_prefix(
double )
13965 return to_char_type(0xFB);
13972 static constexpr CharType get_msgpack_float_prefix(
float )
13974 return to_char_type(0xCA);
13977 static constexpr CharType get_msgpack_float_prefix(
double )
13979 return to_char_type(0xCB);
13987 template<
typename NumberType,
typename std::enable_if<
13988 std::is_floating_point<NumberType>::value,
int>::type = 0>
13989 void write_number_with_ubjson_prefix(
const NumberType n,
13990 const bool add_prefix)
13994 oa->write_character(get_ubjson_float_prefix(n));
14000 template<
typename NumberType,
typename std::enable_if<
14001 std::is_unsigned<NumberType>::value,
int>::type = 0>
14002 void write_number_with_ubjson_prefix(
const NumberType n,
14003 const bool add_prefix)
14005 if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14009 oa->write_character(to_char_type(
'i'));
14011 write_number(
static_cast<std::uint8_t
>(n));
14013 else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14017 oa->write_character(to_char_type(
'U'));
14019 write_number(
static_cast<std::uint8_t
>(n));
14021 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14025 oa->write_character(to_char_type(
'I'));
14027 write_number(
static_cast<std::int16_t
>(n));
14029 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14033 oa->write_character(to_char_type(
'l'));
14035 write_number(
static_cast<std::int32_t
>(n));
14037 else if (n <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14041 oa->write_character(to_char_type(
'L'));
14043 write_number(
static_cast<std::int64_t
>(n));
14049 oa->write_character(to_char_type(
'H'));
14052 const auto number = BasicJsonType(n).dump();
14053 write_number_with_ubjson_prefix(number.size(),
true);
14054 for (std::size_t i = 0; i < number.size(); ++i)
14056 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14062 template <
typename NumberType,
typename std::enable_if <
14063 std::is_signed<NumberType>::value&&
14064 !std::is_floating_point<NumberType>::value,
int >::type = 0 >
14065 void write_number_with_ubjson_prefix(
const NumberType n,
14066 const bool add_prefix)
14068 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14072 oa->write_character(to_char_type(
'i'));
14074 write_number(
static_cast<std::int8_t
>(n));
14076 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)()))
14080 oa->write_character(to_char_type(
'U'));
14082 write_number(
static_cast<std::uint8_t
>(n));
14084 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14088 oa->write_character(to_char_type(
'I'));
14090 write_number(
static_cast<std::int16_t
>(n));
14092 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14096 oa->write_character(to_char_type(
'l'));
14098 write_number(
static_cast<std::int32_t
>(n));
14100 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14104 oa->write_character(to_char_type(
'L'));
14106 write_number(
static_cast<std::int64_t
>(n));
14113 oa->write_character(to_char_type(
'H'));
14116 const auto number = BasicJsonType(n).dump();
14117 write_number_with_ubjson_prefix(number.size(),
true);
14118 for (std::size_t i = 0; i < number.size(); ++i)
14120 oa->write_character(to_char_type(
static_cast<std::uint8_t
>(number[i])));
14129 CharType ubjson_prefix(
const BasicJsonType& j)
const noexcept
14133 case value_t::null:
14136 case value_t::boolean:
14137 return j.m_value.boolean ?
'T' :
'F';
14139 case value_t::number_integer:
14141 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)())
14145 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)())
14149 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)())
14153 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)())
14157 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)())
14165 case value_t::number_unsigned:
14167 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int8_t>::max)()))
14171 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::uint8_t>::max)()))
14175 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int16_t>::max)()))
14179 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int32_t>::max)()))
14183 if (j.m_value.number_unsigned <=
static_cast<std::uint64_t
>((std::numeric_limits<std::int64_t>::max)()))
14191 case value_t::number_float:
14192 return get_ubjson_float_prefix(j.m_value.number_float);
14194 case value_t::string:
14197 case value_t::array:
14198 case value_t::binary:
14201 case value_t::object:
14209 static constexpr CharType get_ubjson_float_prefix(
float )
14214 static constexpr CharType get_ubjson_float_prefix(
double )
14234 template<
typename NumberType,
bool OutputIsLittleEndian = false>
14235 void write_number(
const NumberType n)
14238 std::array<CharType,
sizeof(NumberType)> vec;
14239 std::memcpy(vec.data(), &n,
sizeof(NumberType));
14242 if (is_little_endian != OutputIsLittleEndian)
14245 std::reverse(vec.begin(), vec.end());
14248 oa->write_characters(vec.data(),
sizeof(NumberType));
14251 void write_compact_float(
const number_float_t n, detail::input_format_t format)
14253 if (
static_cast<double>(n) >=
static_cast<double>(std::numeric_limits<float>::lowest()) &&
14254 static_cast<double>(n) <=
static_cast<double>((std::numeric_limits<float>::max)()) &&
14255 static_cast<double>(
static_cast<float>(n)) ==
static_cast<double>(n))
14257 oa->write_character(format == detail::input_format_t::cbor
14258 ? get_cbor_float_prefix(
static_cast<float>(n))
14259 : get_msgpack_float_prefix(
static_cast<float>(n)));
14260 write_number(
static_cast<float>(n));
14264 oa->write_character(format == detail::input_format_t::cbor
14265 ? get_cbor_float_prefix(n)
14266 : get_msgpack_float_prefix(n));
14276 template <
typename C = CharType,
14277 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * =
nullptr >
14278 static constexpr CharType to_char_type(std::uint8_t x) noexcept
14280 return *
reinterpret_cast<char*
>(&x);
14283 template <
typename C = CharType,
14284 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * =
nullptr >
14285 static CharType to_char_type(std::uint8_t x) noexcept
14287 static_assert(
sizeof(std::uint8_t) ==
sizeof(CharType),
"size of CharType must be equal to std::uint8_t");
14288 static_assert(std::is_trivial<CharType>::value,
"CharType must be trivial");
14290 std::memcpy(&result, &x,
sizeof(x));
14294 template<
typename C = CharType,
14295 enable_if_t<std::is_unsigned<C>::value>* =
nullptr>
14296 static constexpr CharType to_char_type(std::uint8_t x) noexcept
14301 template <
typename InputCharType,
typename C = CharType,
14303 std::is_signed<C>::value &&
14304 std::is_signed<char>::value &&
14305 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
14307 static constexpr CharType to_char_type(InputCharType x) noexcept
14314 const bool is_little_endian = little_endianess();
14317 output_adapter_t<CharType> oa =
nullptr;
14327 #include <algorithm>
14336 #include <type_traits>
14347 #include <type_traits>
14376 namespace dtoa_impl
14379 template<
typename Target,
typename Source>
14380 Target reinterpret_bits(
const Source source)
14382 static_assert(
sizeof(Target) ==
sizeof(Source),
"size mismatch");
14385 std::memcpy(&target, &source,
sizeof(Source));
14391 static constexpr
int kPrecision = 64;
14393 std::uint64_t f = 0;
14396 constexpr diyfp(std::uint64_t f_,
int e_) noexcept : f(f_), e(e_) {}
14402 static diyfp sub(
const diyfp& x,
const diyfp& y) noexcept
14404 JSON_ASSERT(x.e == y.e);
14405 JSON_ASSERT(x.f >= y.f);
14407 return {x.f - y.f, x.e};
14414 static diyfp mul(
const diyfp& x,
const diyfp& y) noexcept
14416 static_assert(kPrecision == 64,
"internal error");
14441 const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
14442 const std::uint64_t u_hi = x.f >> 32u;
14443 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
14444 const std::uint64_t v_hi = y.f >> 32u;
14446 const std::uint64_t p0 = u_lo * v_lo;
14447 const std::uint64_t p1 = u_lo * v_hi;
14448 const std::uint64_t p2 = u_hi * v_lo;
14449 const std::uint64_t p3 = u_hi * v_hi;
14451 const std::uint64_t p0_hi = p0 >> 32u;
14452 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
14453 const std::uint64_t p1_hi = p1 >> 32u;
14454 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
14455 const std::uint64_t p2_hi = p2 >> 32u;
14457 std::uint64_t Q = p0_hi + p1_lo + p2_lo;
14468 Q += std::uint64_t{1} << (64u - 32u - 1u);
14470 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
14472 return {h, x.e + y.e + 64};
14479 static diyfp normalize(diyfp x) noexcept
14481 JSON_ASSERT(x.f != 0);
14483 while ((x.f >> 63u) == 0)
14496 static diyfp normalize_to(
const diyfp& x,
const int target_exponent) noexcept
14498 const int delta = x.e - target_exponent;
14500 JSON_ASSERT(delta >= 0);
14501 JSON_ASSERT(((x.f << delta) >> delta) == x.f);
14503 return {x.f << delta, target_exponent};
14520 template<
typename FloatType>
14521 boundaries compute_boundaries(FloatType value)
14523 JSON_ASSERT(std::isfinite(value));
14524 JSON_ASSERT(value > 0);
14533 static_assert(std::numeric_limits<FloatType>::is_iec559,
14534 "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
14536 constexpr
int kPrecision = std::numeric_limits<FloatType>::digits;
14537 constexpr
int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
14538 constexpr
int kMinExp = 1 - kBias;
14539 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1);
14541 using bits_type =
typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
14543 const std::uint64_t bits = reinterpret_bits<bits_type>(value);
14544 const std::uint64_t E = bits >> (kPrecision - 1);
14545 const std::uint64_t F = bits & (kHiddenBit - 1);
14547 const bool is_denormal = E == 0;
14548 const diyfp v = is_denormal
14549 ? diyfp(F, kMinExp)
14550 : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
14573 const bool lower_boundary_is_closer = F == 0 && E > 1;
14574 const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
14575 const diyfp m_minus = lower_boundary_is_closer
14576 ? diyfp(4 * v.f - 1, v.e - 2)
14577 : diyfp(2 * v.f - 1, v.e - 1);
14580 const diyfp w_plus = diyfp::normalize(m_plus);
14583 const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
14585 return {diyfp::normalize(v), w_minus, w_plus};
14643 constexpr
int kAlpha = -60;
14644 constexpr
int kGamma = -32;
14646 struct cached_power
14660 inline cached_power get_cached_power_for_binary_exponent(
int e)
14712 constexpr
int kCachedPowersMinDecExp = -300;
14713 constexpr
int kCachedPowersDecStep = 8;
14715 static constexpr std::array<cached_power, 79> kCachedPowers =
14718 { 0xAB70FE17C79AC6CA, -1060, -300 },
14719 { 0xFF77B1FCBEBCDC4F, -1034, -292 },
14720 { 0xBE5691EF416BD60C, -1007, -284 },
14721 { 0x8DD01FAD907FFC3C, -980, -276 },
14722 { 0xD3515C2831559A83, -954, -268 },
14723 { 0x9D71AC8FADA6C9B5, -927, -260 },
14724 { 0xEA9C227723EE8BCB, -901, -252 },
14725 { 0xAECC49914078536D, -874, -244 },
14726 { 0x823C12795DB6CE57, -847, -236 },
14727 { 0xC21094364DFB5637, -821, -228 },
14728 { 0x9096EA6F3848984F, -794, -220 },
14729 { 0xD77485CB25823AC7, -768, -212 },
14730 { 0xA086CFCD97BF97F4, -741, -204 },
14731 { 0xEF340A98172AACE5, -715, -196 },
14732 { 0xB23867FB2A35B28E, -688, -188 },
14733 { 0x84C8D4DFD2C63F3B, -661, -180 },
14734 { 0xC5DD44271AD3CDBA, -635, -172 },
14735 { 0x936B9FCEBB25C996, -608, -164 },
14736 { 0xDBAC6C247D62A584, -582, -156 },
14737 { 0xA3AB66580D5FDAF6, -555, -148 },
14738 { 0xF3E2F893DEC3F126, -529, -140 },
14739 { 0xB5B5ADA8AAFF80B8, -502, -132 },
14740 { 0x87625F056C7C4A8B, -475, -124 },
14741 { 0xC9BCFF6034C13053, -449, -116 },
14742 { 0x964E858C91BA2655, -422, -108 },
14743 { 0xDFF9772470297EBD, -396, -100 },
14744 { 0xA6DFBD9FB8E5B88F, -369, -92 },
14745 { 0xF8A95FCF88747D94, -343, -84 },
14746 { 0xB94470938FA89BCF, -316, -76 },
14747 { 0x8A08F0F8BF0F156B, -289, -68 },
14748 { 0xCDB02555653131B6, -263, -60 },
14749 { 0x993FE2C6D07B7FAC, -236, -52 },
14750 { 0xE45C10C42A2B3B06, -210, -44 },
14751 { 0xAA242499697392D3, -183, -36 },
14752 { 0xFD87B5F28300CA0E, -157, -28 },
14753 { 0xBCE5086492111AEB, -130, -20 },
14754 { 0x8CBCCC096F5088CC, -103, -12 },
14755 { 0xD1B71758E219652C, -77, -4 },
14756 { 0x9C40000000000000, -50, 4 },
14757 { 0xE8D4A51000000000, -24, 12 },
14758 { 0xAD78EBC5AC620000, 3, 20 },
14759 { 0x813F3978F8940984, 30, 28 },
14760 { 0xC097CE7BC90715B3, 56, 36 },
14761 { 0x8F7E32CE7BEA5C70, 83, 44 },
14762 { 0xD5D238A4ABE98068, 109, 52 },
14763 { 0x9F4F2726179A2245, 136, 60 },
14764 { 0xED63A231D4C4FB27, 162, 68 },
14765 { 0xB0DE65388CC8ADA8, 189, 76 },
14766 { 0x83C7088E1AAB65DB, 216, 84 },
14767 { 0xC45D1DF942711D9A, 242, 92 },
14768 { 0x924D692CA61BE758, 269, 100 },
14769 { 0xDA01EE641A708DEA, 295, 108 },
14770 { 0xA26DA3999AEF774A, 322, 116 },
14771 { 0xF209787BB47D6B85, 348, 124 },
14772 { 0xB454E4A179DD1877, 375, 132 },
14773 { 0x865B86925B9BC5C2, 402, 140 },
14774 { 0xC83553C5C8965D3D, 428, 148 },
14775 { 0x952AB45CFA97A0B3, 455, 156 },
14776 { 0xDE469FBD99A05FE3, 481, 164 },
14777 { 0xA59BC234DB398C25, 508, 172 },
14778 { 0xF6C69A72A3989F5C, 534, 180 },
14779 { 0xB7DCBF5354E9BECE, 561, 188 },
14780 { 0x88FCF317F22241E2, 588, 196 },
14781 { 0xCC20CE9BD35C78A5, 614, 204 },
14782 { 0x98165AF37B2153DF, 641, 212 },
14783 { 0xE2A0B5DC971F303A, 667, 220 },
14784 { 0xA8D9D1535CE3B396, 694, 228 },
14785 { 0xFB9B7CD9A4A7443C, 720, 236 },
14786 { 0xBB764C4CA7A44410, 747, 244 },
14787 { 0x8BAB8EEFB6409C1A, 774, 252 },
14788 { 0xD01FEF10A657842C, 800, 260 },
14789 { 0x9B10A4E5E9913129, 827, 268 },
14790 { 0xE7109BFBA19C0C9D, 853, 276 },
14791 { 0xAC2820D9623BF429, 880, 284 },
14792 { 0x80444B5E7AA7CF85, 907, 292 },
14793 { 0xBF21E44003ACDD2D, 933, 300 },
14794 { 0x8E679C2F5E44FF8F, 960, 308 },
14795 { 0xD433179D9C8CB841, 986, 316 },
14796 { 0x9E19DB92B4E31BA9, 1013, 324 },
14804 JSON_ASSERT(e >= -1500);
14805 JSON_ASSERT(e <= 1500);
14806 const int f = kAlpha - e - 1;
14807 const int k = (f * 78913) / (1 << 18) +
static_cast<int>(f > 0);
14809 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
14810 JSON_ASSERT(index >= 0);
14811 JSON_ASSERT(
static_cast<std::size_t
>(index) < kCachedPowers.size());
14813 const cached_power cached = kCachedPowers[
static_cast<std::size_t
>(index)];
14814 JSON_ASSERT(kAlpha <= cached.e + e + 64);
14815 JSON_ASSERT(kGamma >= cached.e + e + 64);
14824 inline int find_largest_pow10(
const std::uint32_t n, std::uint32_t& pow10)
14827 if (n >= 1000000000)
14829 pow10 = 1000000000;
14833 else if (n >= 100000000)
14838 else if (n >= 10000000)
14843 else if (n >= 1000000)
14848 else if (n >= 100000)
14853 else if (n >= 10000)
14858 else if (n >= 1000)
14880 inline void grisu2_round(
char* buf,
int len, std::uint64_t dist, std::uint64_t delta,
14881 std::uint64_t rest, std::uint64_t ten_k)
14883 JSON_ASSERT(len >= 1);
14884 JSON_ASSERT(dist <= delta);
14885 JSON_ASSERT(rest <= delta);
14886 JSON_ASSERT(ten_k > 0);
14908 && delta - rest >= ten_k
14909 && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
14911 JSON_ASSERT(buf[len - 1] !=
'0');
14921 inline void grisu2_digit_gen(
char* buffer,
int& length,
int& decimal_exponent,
14922 diyfp M_minus, diyfp w, diyfp M_plus)
14924 static_assert(kAlpha >= -60,
"internal error");
14925 static_assert(kGamma <= -32,
"internal error");
14939 JSON_ASSERT(M_plus.e >= kAlpha);
14940 JSON_ASSERT(M_plus.e <= kGamma);
14942 std::uint64_t delta = diyfp::sub(M_plus, M_minus).f;
14943 std::uint64_t dist = diyfp::sub(M_plus, w ).f;
14952 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
14954 auto p1 =
static_cast<std::uint32_t
>(M_plus.f >> -one.e);
14955 std::uint64_t p2 = M_plus.f & (one.f - 1);
14961 JSON_ASSERT(p1 > 0);
14963 std::uint32_t pow10;
14964 const int k = find_largest_pow10(p1, pow10);
14991 const std::uint32_t d = p1 / pow10;
14992 const std::uint32_t r = p1 % pow10;
14997 JSON_ASSERT(d <= 9);
14998 buffer[length++] =
static_cast<char>(
'0' + d);
15017 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15022 decimal_exponent += n;
15033 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15034 grisu2_round(buffer, length, dist, delta, rest, ten_n);
15084 JSON_ASSERT(p2 > delta);
15095 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15097 const std::uint64_t d = p2 >> -one.e;
15098 const std::uint64_t r = p2 & (one.f - 1);
15104 JSON_ASSERT(d <= 9);
15105 buffer[length++] =
static_cast<char>(
'0' + d);
15130 decimal_exponent -= m;
15138 const std::uint64_t ten_m = one.f;
15139 grisu2_round(buffer, length, dist, delta, p2, ten_m);
15161 JSON_HEDLEY_NON_NULL(1)
15162 inline
void grisu2(
char* buf,
int& len,
int& decimal_exponent,
15163 diyfp m_minus, diyfp v, diyfp m_plus)
15165 JSON_ASSERT(m_plus.e == m_minus.e);
15166 JSON_ASSERT(m_plus.e == v.e);
15177 const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
15179 const diyfp c_minus_k(cached.f, cached.e);
15182 const diyfp w = diyfp::mul(v, c_minus_k);
15183 const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
15184 const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
15207 const diyfp M_minus(w_minus.f + 1, w_minus.e);
15208 const diyfp M_plus (w_plus.f - 1, w_plus.e );
15210 decimal_exponent = -cached.k;
15212 grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
15220 template<
typename FloatType>
15221 JSON_HEDLEY_NON_NULL(1)
15222 void grisu2(
char* buf,
int& len,
int& decimal_exponent, FloatType value)
15224 static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
15225 "internal error: not enough precision");
15227 JSON_ASSERT(std::isfinite(value));
15228 JSON_ASSERT(value > 0);
15247 const boundaries w = compute_boundaries(
static_cast<double>(value));
15249 const boundaries w = compute_boundaries(value);
15252 grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
15260 JSON_HEDLEY_NON_NULL(1)
15262 inline
char* append_exponent(
char* buf,
int e)
15264 JSON_ASSERT(e > -1000);
15265 JSON_ASSERT(e < 1000);
15277 auto k =
static_cast<std::uint32_t
>(e);
15283 *buf++ =
static_cast<char>(
'0' + k);
15287 *buf++ =
static_cast<char>(
'0' + k / 10);
15289 *buf++ =
static_cast<char>(
'0' + k);
15293 *buf++ =
static_cast<char>(
'0' + k / 100);
15295 *buf++ =
static_cast<char>(
'0' + k / 10);
15297 *buf++ =
static_cast<char>(
'0' + k);
15312 JSON_HEDLEY_NON_NULL(1)
15314 inline
char* format_buffer(
char* buf,
int len,
int decimal_exponent,
15315 int min_exp,
int max_exp)
15317 JSON_ASSERT(min_exp < 0);
15318 JSON_ASSERT(max_exp > 0);
15321 const int n = len + decimal_exponent;
15327 if (k <= n && n <= max_exp)
15332 std::memset(buf + k,
'0',
static_cast<size_t>(n) -
static_cast<size_t>(k));
15336 return buf + (
static_cast<size_t>(n) + 2);
15339 if (0 < n && n <= max_exp)
15344 JSON_ASSERT(k > n);
15346 std::memmove(buf + (
static_cast<size_t>(n) + 1), buf + n,
static_cast<size_t>(k) -
static_cast<size_t>(n));
15348 return buf + (
static_cast<size_t>(k) + 1U);
15351 if (min_exp < n && n <= 0)
15356 std::memmove(buf + (2 +
static_cast<size_t>(-n)), buf,
static_cast<size_t>(k));
15359 std::memset(buf + 2,
'0',
static_cast<size_t>(-n));
15360 return buf + (2U +
static_cast<size_t>(-n) +
static_cast<size_t>(k));
15375 std::memmove(buf + 2, buf + 1,
static_cast<size_t>(k) - 1);
15377 buf += 1 +
static_cast<size_t>(k);
15381 return append_exponent(buf, n - 1);
15396 template<
typename FloatType>
15397 JSON_HEDLEY_NON_NULL(1, 2)
15399 char* to_chars(
char* first, const
char* last, FloatType value)
15401 static_cast<void>(last);
15402 JSON_ASSERT(std::isfinite(value));
15405 if (std::signbit(value))
15420 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
15427 int decimal_exponent = 0;
15428 dtoa_impl::grisu2(first, len, decimal_exponent, value);
15430 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
15433 constexpr
int kMinExp = -4;
15435 constexpr
int kMaxExp = std::numeric_limits<FloatType>::digits10;
15437 JSON_ASSERT(last - first >= kMaxExp + 2);
15438 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
15439 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
15441 return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
15469 enum class error_handler_t
15476 template<
typename BasicJsonType>
15479 using string_t =
typename BasicJsonType::string_t;
15480 using number_float_t =
typename BasicJsonType::number_float_t;
15481 using number_integer_t =
typename BasicJsonType::number_integer_t;
15482 using number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
15483 using binary_char_t =
typename BasicJsonType::binary_t::value_type;
15484 static constexpr std::uint8_t UTF8_ACCEPT = 0;
15485 static constexpr std::uint8_t UTF8_REJECT = 1;
15493 serializer(output_adapter_t<char> s,
const char ichar,
15494 error_handler_t error_handler_ = error_handler_t::strict)
15496 , loc(std::localeconv())
15497 , thousands_sep(loc->thousands_sep == nullptr ?
'\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
15498 , decimal_point(loc->decimal_point == nullptr ?
'\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
15499 , indent_char(ichar)
15500 , indent_string(512, indent_char)
15501 , error_handler(error_handler_)
15505 serializer(
const serializer&) =
delete;
15506 serializer& operator=(
const serializer&) =
delete;
15507 serializer(serializer&&) =
delete;
15508 serializer& operator=(serializer&&) =
delete;
15509 ~serializer() =
default;
15533 void dump(
const BasicJsonType& val,
15534 const bool pretty_print,
15535 const bool ensure_ascii,
15536 const unsigned int indent_step,
15537 const unsigned int current_indent = 0)
15539 switch (val.m_type)
15541 case value_t::object:
15543 if (val.m_value.object->empty())
15545 o->write_characters(
"{}", 2);
15551 o->write_characters(
"{\n", 2);
15554 const auto new_indent = current_indent + indent_step;
15555 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15557 indent_string.resize(indent_string.size() * 2,
' ');
15561 auto i = val.m_value.object->cbegin();
15562 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
15564 o->write_characters(indent_string.c_str(), new_indent);
15565 o->write_character(
'\"');
15566 dump_escaped(i->first, ensure_ascii);
15567 o->write_characters(
"\": ", 3);
15568 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
15569 o->write_characters(
",\n", 2);
15573 JSON_ASSERT(i != val.m_value.object->cend());
15574 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
15575 o->write_characters(indent_string.c_str(), new_indent);
15576 o->write_character(
'\"');
15577 dump_escaped(i->first, ensure_ascii);
15578 o->write_characters(
"\": ", 3);
15579 dump(i->second,
true, ensure_ascii, indent_step, new_indent);
15581 o->write_character(
'\n');
15582 o->write_characters(indent_string.c_str(), current_indent);
15583 o->write_character(
'}');
15587 o->write_character(
'{');
15590 auto i = val.m_value.object->cbegin();
15591 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
15593 o->write_character(
'\"');
15594 dump_escaped(i->first, ensure_ascii);
15595 o->write_characters(
"\":", 2);
15596 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
15597 o->write_character(
',');
15601 JSON_ASSERT(i != val.m_value.object->cend());
15602 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
15603 o->write_character(
'\"');
15604 dump_escaped(i->first, ensure_ascii);
15605 o->write_characters(
"\":", 2);
15606 dump(i->second,
false, ensure_ascii, indent_step, current_indent);
15608 o->write_character(
'}');
15614 case value_t::array:
15616 if (val.m_value.array->empty())
15618 o->write_characters(
"[]", 2);
15624 o->write_characters(
"[\n", 2);
15627 const auto new_indent = current_indent + indent_step;
15628 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15630 indent_string.resize(indent_string.size() * 2,
' ');
15634 for (
auto i = val.m_value.array->cbegin();
15635 i != val.m_value.array->cend() - 1; ++i)
15637 o->write_characters(indent_string.c_str(), new_indent);
15638 dump(*i,
true, ensure_ascii, indent_step, new_indent);
15639 o->write_characters(
",\n", 2);
15643 JSON_ASSERT(!val.m_value.array->empty());
15644 o->write_characters(indent_string.c_str(), new_indent);
15645 dump(val.m_value.array->back(),
true, ensure_ascii, indent_step, new_indent);
15647 o->write_character(
'\n');
15648 o->write_characters(indent_string.c_str(), current_indent);
15649 o->write_character(
']');
15653 o->write_character(
'[');
15656 for (
auto i = val.m_value.array->cbegin();
15657 i != val.m_value.array->cend() - 1; ++i)
15659 dump(*i,
false, ensure_ascii, indent_step, current_indent);
15660 o->write_character(
',');
15664 JSON_ASSERT(!val.m_value.array->empty());
15665 dump(val.m_value.array->back(),
false, ensure_ascii, indent_step, current_indent);
15667 o->write_character(
']');
15673 case value_t::string:
15675 o->write_character(
'\"');
15676 dump_escaped(*val.m_value.string, ensure_ascii);
15677 o->write_character(
'\"');
15681 case value_t::binary:
15685 o->write_characters(
"{\n", 2);
15688 const auto new_indent = current_indent + indent_step;
15689 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15691 indent_string.resize(indent_string.size() * 2,
' ');
15694 o->write_characters(indent_string.c_str(), new_indent);
15696 o->write_characters(
"\"bytes\": [", 10);
15698 if (!val.m_value.binary->empty())
15700 for (
auto i = val.m_value.binary->cbegin();
15701 i != val.m_value.binary->cend() - 1; ++i)
15704 o->write_characters(
", ", 2);
15706 dump_integer(val.m_value.binary->back());
15709 o->write_characters(
"],\n", 3);
15710 o->write_characters(indent_string.c_str(), new_indent);
15712 o->write_characters(
"\"subtype\": ", 11);
15713 if (val.m_value.binary->has_subtype())
15715 dump_integer(val.m_value.binary->subtype());
15719 o->write_characters(
"null", 4);
15721 o->write_character(
'\n');
15722 o->write_characters(indent_string.c_str(), current_indent);
15723 o->write_character(
'}');
15727 o->write_characters(
"{\"bytes\":[", 10);
15729 if (!val.m_value.binary->empty())
15731 for (
auto i = val.m_value.binary->cbegin();
15732 i != val.m_value.binary->cend() - 1; ++i)
15735 o->write_character(
',');
15737 dump_integer(val.m_value.binary->back());
15740 o->write_characters(
"],\"subtype\":", 12);
15741 if (val.m_value.binary->has_subtype())
15743 dump_integer(val.m_value.binary->subtype());
15744 o->write_character(
'}');
15748 o->write_characters(
"null}", 5);
15754 case value_t::boolean:
15756 if (val.m_value.boolean)
15758 o->write_characters(
"true", 4);
15762 o->write_characters(
"false", 5);
15767 case value_t::number_integer:
15769 dump_integer(val.m_value.number_integer);
15773 case value_t::number_unsigned:
15775 dump_integer(val.m_value.number_unsigned);
15779 case value_t::number_float:
15781 dump_float(val.m_value.number_float);
15785 case value_t::discarded:
15787 o->write_characters(
"<discarded>", 11);
15791 case value_t::null:
15793 o->write_characters(
"null", 4);
15798 JSON_ASSERT(
false);
15817 void dump_escaped(
const string_t& s,
const bool ensure_ascii)
15819 std::uint32_t codepoint;
15820 std::uint8_t state = UTF8_ACCEPT;
15821 std::size_t bytes = 0;
15824 std::size_t bytes_after_last_accept = 0;
15825 std::size_t undumped_chars = 0;
15827 for (std::size_t i = 0; i < s.size(); ++i)
15829 const auto byte =
static_cast<uint8_t
>(s[i]);
15831 switch (decode(state, codepoint,
byte))
15839 string_buffer[bytes++] =
'\\';
15840 string_buffer[bytes++] =
'b';
15846 string_buffer[bytes++] =
'\\';
15847 string_buffer[bytes++] =
't';
15853 string_buffer[bytes++] =
'\\';
15854 string_buffer[bytes++] =
'n';
15860 string_buffer[bytes++] =
'\\';
15861 string_buffer[bytes++] =
'f';
15867 string_buffer[bytes++] =
'\\';
15868 string_buffer[bytes++] =
'r';
15874 string_buffer[bytes++] =
'\\';
15875 string_buffer[bytes++] =
'\"';
15881 string_buffer[bytes++] =
'\\';
15882 string_buffer[bytes++] =
'\\';
15890 if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
15892 if (codepoint <= 0xFFFF)
15894 (std::snprintf)(string_buffer.data() + bytes, 7,
"\\u%04x",
15895 static_cast<std::uint16_t
>(codepoint));
15900 (std::snprintf)(string_buffer.data() + bytes, 13,
"\\u%04x\\u%04x",
15901 static_cast<std::uint16_t
>(0xD7C0u + (codepoint >> 10u)),
15902 static_cast<std::uint16_t
>(0xDC00u + (codepoint & 0x3FFu)));
15910 string_buffer[bytes++] = s[i];
15919 if (string_buffer.size() - bytes < 13)
15921 o->write_characters(string_buffer.data(), bytes);
15926 bytes_after_last_accept = bytes;
15927 undumped_chars = 0;
15933 switch (error_handler)
15935 case error_handler_t::strict:
15937 std::string sn(3,
'\0');
15938 (std::snprintf)(&sn[0], sn.size(),
"%.2X", byte);
15939 JSON_THROW(type_error::create(316,
"invalid UTF-8 byte at index " + std::to_string(i) +
": 0x" + sn));
15942 case error_handler_t::ignore:
15943 case error_handler_t::replace:
15949 if (undumped_chars > 0)
15956 bytes = bytes_after_last_accept;
15958 if (error_handler == error_handler_t::replace)
15963 string_buffer[bytes++] =
'\\';
15964 string_buffer[bytes++] =
'u';
15965 string_buffer[bytes++] =
'f';
15966 string_buffer[bytes++] =
'f';
15967 string_buffer[bytes++] =
'f';
15968 string_buffer[bytes++] =
'd';
15972 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xEF');
15973 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBF');
15974 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type(
'\xBD');
15980 if (string_buffer.size() - bytes < 13)
15982 o->write_characters(string_buffer.data(), bytes);
15986 bytes_after_last_accept = bytes;
15989 undumped_chars = 0;
15992 state = UTF8_ACCEPT;
15997 JSON_ASSERT(
false);
16007 string_buffer[bytes++] = s[i];
16016 if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16021 o->write_characters(string_buffer.data(), bytes);
16027 switch (error_handler)
16029 case error_handler_t::strict:
16031 std::string sn(3,
'\0');
16032 (std::snprintf)(&sn[0], sn.size(),
"%.2X",
static_cast<std::uint8_t
>(s.back()));
16033 JSON_THROW(type_error::create(316,
"incomplete UTF-8 string; last byte: 0x" + sn));
16036 case error_handler_t::ignore:
16039 o->write_characters(string_buffer.data(), bytes_after_last_accept);
16043 case error_handler_t::replace:
16046 o->write_characters(string_buffer.data(), bytes_after_last_accept);
16050 o->write_characters(
"\\ufffd", 6);
16054 o->write_characters(
"\xEF\xBF\xBD", 3);
16060 JSON_ASSERT(
false);
16073 inline unsigned int count_digits(number_unsigned_t x) noexcept
16075 unsigned int n_digits = 1;
16084 return n_digits + 1;
16088 return n_digits + 2;
16092 return n_digits + 3;
16108 template <
typename NumberType, detail::enable_if_t <
16109 std::is_same<NumberType, number_unsigned_t>::value ||
16110 std::is_same<NumberType, number_integer_t>::value ||
16111 std::is_same<NumberType, binary_char_t>::value,
16113 void dump_integer(NumberType x)
16115 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16118 {{
'0',
'0'}}, {{
'0',
'1'}}, {{
'0',
'2'}}, {{
'0',
'3'}}, {{
'0',
'4'}}, {{
'0',
'5'}}, {{
'0',
'6'}}, {{
'0',
'7'}}, {{
'0',
'8'}}, {{
'0',
'9'}},
16119 {{
'1',
'0'}}, {{
'1',
'1'}}, {{
'1',
'2'}}, {{
'1',
'3'}}, {{
'1',
'4'}}, {{
'1',
'5'}}, {{
'1',
'6'}}, {{
'1',
'7'}}, {{
'1',
'8'}}, {{
'1',
'9'}},
16120 {{
'2',
'0'}}, {{
'2',
'1'}}, {{
'2',
'2'}}, {{
'2',
'3'}}, {{
'2',
'4'}}, {{
'2',
'5'}}, {{
'2',
'6'}}, {{
'2',
'7'}}, {{
'2',
'8'}}, {{
'2',
'9'}},
16121 {{
'3',
'0'}}, {{
'3',
'1'}}, {{
'3',
'2'}}, {{
'3',
'3'}}, {{
'3',
'4'}}, {{
'3',
'5'}}, {{
'3',
'6'}}, {{
'3',
'7'}}, {{
'3',
'8'}}, {{
'3',
'9'}},
16122 {{
'4',
'0'}}, {{
'4',
'1'}}, {{
'4',
'2'}}, {{
'4',
'3'}}, {{
'4',
'4'}}, {{
'4',
'5'}}, {{
'4',
'6'}}, {{
'4',
'7'}}, {{
'4',
'8'}}, {{
'4',
'9'}},
16123 {{
'5',
'0'}}, {{
'5',
'1'}}, {{
'5',
'2'}}, {{
'5',
'3'}}, {{
'5',
'4'}}, {{
'5',
'5'}}, {{
'5',
'6'}}, {{
'5',
'7'}}, {{
'5',
'8'}}, {{
'5',
'9'}},
16124 {{
'6',
'0'}}, {{
'6',
'1'}}, {{
'6',
'2'}}, {{
'6',
'3'}}, {{
'6',
'4'}}, {{
'6',
'5'}}, {{
'6',
'6'}}, {{
'6',
'7'}}, {{
'6',
'8'}}, {{
'6',
'9'}},
16125 {{
'7',
'0'}}, {{
'7',
'1'}}, {{
'7',
'2'}}, {{
'7',
'3'}}, {{
'7',
'4'}}, {{
'7',
'5'}}, {{
'7',
'6'}}, {{
'7',
'7'}}, {{
'7',
'8'}}, {{
'7',
'9'}},
16126 {{
'8',
'0'}}, {{
'8',
'1'}}, {{
'8',
'2'}}, {{
'8',
'3'}}, {{
'8',
'4'}}, {{
'8',
'5'}}, {{
'8',
'6'}}, {{
'8',
'7'}}, {{
'8',
'8'}}, {{
'8',
'9'}},
16127 {{
'9',
'0'}}, {{
'9',
'1'}}, {{
'9',
'2'}}, {{
'9',
'3'}}, {{
'9',
'4'}}, {{
'9',
'5'}}, {{
'9',
'6'}}, {{
'9',
'7'}}, {{
'9',
'8'}}, {{
'9',
'9'}},
16134 o->write_character(
'0');
16139 auto buffer_ptr = number_buffer.begin();
16141 const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0);
16142 number_unsigned_t abs_value;
16144 unsigned int n_chars;
16149 abs_value = remove_sign(
static_cast<number_integer_t
>(x));
16152 n_chars = 1 + count_digits(abs_value);
16156 abs_value =
static_cast<number_unsigned_t
>(x);
16157 n_chars = count_digits(abs_value);
16161 JSON_ASSERT(n_chars < number_buffer.size() - 1);
16165 buffer_ptr += n_chars;
16169 while (abs_value >= 100)
16171 const auto digits_index =
static_cast<unsigned>((abs_value % 100));
16173 *(--buffer_ptr) = digits_to_99[digits_index][1];
16174 *(--buffer_ptr) = digits_to_99[digits_index][0];
16177 if (abs_value >= 10)
16179 const auto digits_index =
static_cast<unsigned>(abs_value);
16180 *(--buffer_ptr) = digits_to_99[digits_index][1];
16181 *(--buffer_ptr) = digits_to_99[digits_index][0];
16185 *(--buffer_ptr) =
static_cast<char>(
'0' + abs_value);
16188 o->write_characters(number_buffer.data(), n_chars);
16199 void dump_float(number_float_t x)
16202 if (!std::isfinite(x))
16204 o->write_characters(
"null", 4);
16213 static constexpr
bool is_ieee_single_or_double
16214 = (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) ||
16215 (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);
16217 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
16220 void dump_float(number_float_t x, std::true_type )
16222 char* begin = number_buffer.data();
16223 char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
16225 o->write_characters(begin,
static_cast<size_t>(end - begin));
16228 void dump_float(number_float_t x, std::false_type )
16231 static constexpr
auto d = std::numeric_limits<number_float_t>::max_digits10;
16234 std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(),
"%.*g", d, x);
16237 JSON_ASSERT(len > 0);
16239 JSON_ASSERT(
static_cast<std::size_t
>(len) < number_buffer.size());
16242 if (thousands_sep !=
'\0')
16244 const auto end = std::remove(number_buffer.begin(),
16245 number_buffer.begin() + len, thousands_sep);
16246 std::fill(end, number_buffer.end(),
'\0');
16247 JSON_ASSERT((end - number_buffer.begin()) <= len);
16248 len = (end - number_buffer.begin());
16252 if (decimal_point !=
'\0' && decimal_point !=
'.')
16254 const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
16255 if (dec_pos != number_buffer.end())
16261 o->write_characters(number_buffer.data(),
static_cast<std::size_t
>(len));
16264 const bool value_is_int_like =
16265 std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
16268 return c ==
'.' || c ==
'e';
16271 if (value_is_int_like)
16273 o->write_characters(
".0", 2);
16298 static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep,
const std::uint8_t
byte) noexcept
16300 static const std::array<std::uint8_t, 400> utf8d =
16303 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,
16304 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,
16305 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,
16306 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,
16307 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,
16308 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,
16309 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,
16310 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3,
16311 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,
16312 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1,
16313 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,
16314 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,
16315 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,
16316 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
16320 const std::uint8_t type = utf8d[byte];
16322 codep = (state != UTF8_ACCEPT)
16323 ? (
byte & 0x3fu) | (codep << 6u)
16324 : (0xFFu >> type) & (byte);
16326 std::size_t index = 256u +
static_cast<size_t>(state) * 16u +
static_cast<size_t>(type);
16327 JSON_ASSERT(index < 400);
16328 state = utf8d[index];
16337 number_unsigned_t remove_sign(number_unsigned_t x)
16339 JSON_ASSERT(
false);
16352 inline number_unsigned_t remove_sign(number_integer_t x) noexcept
16354 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
16355 return static_cast<number_unsigned_t
>(-(x + 1)) + 1;
16360 output_adapter_t<char> o =
nullptr;
16363 std::array<char, 64> number_buffer{{}};
16366 const std::lconv* loc =
nullptr;
16368 const char thousands_sep =
'\0';
16370 const char decimal_point =
'\0';
16373 std::array<char, 512> string_buffer{{}};
16376 const char indent_char;
16378 string_t indent_string;
16381 const error_handler_t error_handler;
16393 #include <functional>
16403 template <
class Key,
class T,
class IgnoredLess = std::less<Key>,
16404 class Allocator = std::allocator<std::pair<const Key, T>>>
16405 struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
16409 using Container = std::vector<std::pair<const Key, T>, Allocator>;
16410 using typename Container::iterator;
16411 using typename Container::size_type;
16412 using typename Container::value_type;
16417 template <
class It>
16420 ordered_map(std::initializer_list<T> init,
const Allocator& alloc = Allocator() )
16425 for (
auto it = this->begin(); it != this->end(); ++it)
16427 if (it->first == key)
16429 return {it,
false};
16432 Container::emplace_back(key, t);
16433 return {--this->end(),
true};
16438 return emplace(std::move(key), T{}).first->second;
16443 for (
auto it = this->begin(); it != this->end(); ++it)
16445 if (it->first == key)
16448 for (
auto next = it; ++next != this->end(); ++it)
16451 new (&*it) value_type{std::move(*next)};
16453 Container::pop_back();
16556 NLOHMANN_BASIC_JSON_TPL_DECLARATION
16561 friend ::nlohmann::json_pointer<basic_json>;
16563 template<
typename BasicJsonType,
typename InputType>
16564 friend class ::nlohmann::detail::parser;
16565 friend ::nlohmann::detail::serializer<basic_json>;
16566 template<
typename BasicJsonType>
16567 friend class ::nlohmann::detail::iter_impl;
16568 template<
typename BasicJsonType,
typename CharType>
16569 friend class ::nlohmann::detail::binary_writer;
16570 template<
typename BasicJsonType,
typename InputType,
typename SAX>
16571 friend class ::nlohmann::detail::binary_reader;
16572 template<
typename BasicJsonType>
16573 friend class ::nlohmann::detail::json_sax_dom_parser;
16574 template<
typename BasicJsonType>
16575 friend class ::nlohmann::detail::json_sax_dom_callback_parser;
16578 using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
16581 using lexer = ::nlohmann::detail::lexer_base<basic_json>;
16583 template<
typename InputAdapterType>
16584 static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
16585 InputAdapterType adapter,
16586 detail::parser_callback_t<basic_json>cb =
nullptr,
16587 const bool allow_exceptions =
true,
16588 const bool ignore_comments =
false
16591 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
16592 std::move(cb), allow_exceptions, ignore_comments);
16595 using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
16596 template<
typename BasicJsonType>
16597 using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
16598 template<
typename BasicJsonType>
16599 using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
16600 template<
typename Iterator>
16601 using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
16602 template<
typename Base>
using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
16604 template<
typename CharType>
16605 using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
16607 template<
typename InputType>
16608 using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
16609 template<
typename CharType>
using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
16611 using serializer = ::nlohmann::detail::serializer<basic_json>;
16614 using value_t = detail::value_t;
16617 template<
typename T,
typename SFINAE>
16620 using error_handler_t = detail::error_handler_t;
16622 using cbor_tag_handler_t = detail::cbor_tag_handler_t;
16626 using input_format_t = detail::input_format_t;
16680 using pointer =
typename std::allocator_traits<allocator_type>::pointer;
16682 using const_pointer =
typename std::allocator_traits<allocator_type>::const_pointer;
16735 result[
"copyright"] =
"(C) 2013-2020 Niels Lohmann";
16736 result[
"name"] =
"JSON for Modern C++";
16737 result[
"url"] =
"https://github.com/nlohmann/json";
16738 result[
"version"][
"string"] =
16739 std::to_string(NLOHMANN_JSON_VERSION_MAJOR) +
"." +
16740 std::to_string(NLOHMANN_JSON_VERSION_MINOR) +
"." +
16741 std::to_string(NLOHMANN_JSON_VERSION_PATCH);
16742 result[
"version"][
"major"] = NLOHMANN_JSON_VERSION_MAJOR;
16743 result[
"version"][
"minor"] = NLOHMANN_JSON_VERSION_MINOR;
16744 result[
"version"][
"patch"] = NLOHMANN_JSON_VERSION_PATCH;
16747 result[
"platform"] =
"win32";
16748 #elif defined __linux__
16749 result[
"platform"] =
"linux";
16750 #elif defined __APPLE__
16751 result[
"platform"] =
"apple";
16752 #elif defined __unix__
16753 result[
"platform"] =
"unix";
16755 result[
"platform"] =
"unknown";
16758 #if defined(__ICC) || defined(__INTEL_COMPILER)
16759 result[
"compiler"] = {{
"family",
"icc"}, {
"version", __INTEL_COMPILER}};
16760 #elif defined(__clang__)
16761 result[
"compiler"] = {{
"family",
"clang"}, {
"version", __clang_version__}};
16762 #elif defined(__GNUC__) || defined(__GNUG__)
16763 result[
"compiler"] = {{
"family",
"gcc"}, {
"version", std::to_string(__GNUC__) +
"." + std::to_string(__GNUC_MINOR__) +
"." + std::to_string(__GNUC_PATCHLEVEL__)}};
16764 #elif defined(__HP_cc) || defined(__HP_aCC)
16765 result[
"compiler"] =
"hp"
16766 #elif defined(__IBMCPP__)
16767 result[
"compiler"] = {{
"family",
"ilecpp"}, {
"version", __IBMCPP__}};
16768 #elif defined(_MSC_VER)
16769 result[
"compiler"] = {{
"family",
"msvc"}, {
"version", _MSC_VER}};
16770 #elif defined(__PGI)
16771 result[
"compiler"] = {{
"family",
"pgcpp"}, {
"version", __PGI}};
16772 #elif defined(__SUNPRO_CC)
16773 result[
"compiler"] = {{
"family",
"sunpro"}, {
"version", __SUNPRO_CC}};
16775 result[
"compiler"] = {{
"family",
"unknown"}, {
"version",
"unknown"}};
16779 result[
"compiler"][
"c++"] = std::to_string(__cplusplus);
16781 result[
"compiler"][
"c++"] =
"unknown";
16796 #if defined(JSON_HAS_CPP_14)
16890 AllocatorType<std::pair<
const StringType,
16937 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
17304 template<
typename T,
typename... Args>
17306 static T* create(Args&& ... args)
17308 AllocatorType<T> alloc;
17309 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
17311 auto deleter = [&](T *
object)
17313 AllocatorTraits::deallocate(alloc,
object, 1);
17315 std::unique_ptr<T, decltype(deleter)>
object(AllocatorTraits::allocate(alloc, 1), deleter);
17316 AllocatorTraits::construct(alloc,
object.
get(), std::forward<Args>(args)...);
17317 JSON_ASSERT(
object !=
nullptr);
17318 return object.release();
17370 json_value() =
default;
17372 json_value(
boolean_t v) noexcept : boolean(v) {}
17384 case value_t::object:
17386 object = create<object_t>();
17390 case value_t::array:
17392 array = create<array_t>();
17396 case value_t::string:
17398 string = create<string_t>(
"");
17402 case value_t::binary:
17404 binary = create<binary_t>();
17408 case value_t::boolean:
17414 case value_t::number_integer:
17420 case value_t::number_unsigned:
17426 case value_t::number_float:
17432 case value_t::null:
17441 if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
17443 JSON_THROW(other_error::create(500,
"961c151d2e87f2686a955a9be24d316f1362bf21 3.9.0"));
17453 string = create<string_t>(
value);
17459 string = create<string_t>(std::move(
value));
17465 object = create<object_t>(
value);
17471 object = create<object_t>(std::move(
value));
17510 void destroy(
value_t t) noexcept
17513 std::vector<basic_json> stack;
17516 if (t == value_t::array)
17521 else if (t == value_t::object)
17524 for (
auto&& it : *
object)
17526 stack.push_back(std::move(it.second));
17530 while (!stack.empty())
17533 basic_json current_item(std::move(stack.back()));
17538 if (current_item.is_array())
17540 std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
17541 std::back_inserter(stack));
17543 current_item.m_value.array->clear();
17545 else if (current_item.is_object())
17547 for (
auto&& it : *current_item.m_value.object)
17549 stack.push_back(std::move(it.second));
17552 current_item.m_value.object->clear();
17561 case value_t::object:
17563 AllocatorType<object_t> alloc;
17564 std::allocator_traits<decltype(alloc)>::destroy(alloc,
object);
17565 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
object, 1);
17569 case value_t::array:
17571 AllocatorType<array_t> alloc;
17572 std::allocator_traits<decltype(alloc)>::destroy(alloc,
array);
17573 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
array, 1);
17577 case value_t::string:
17579 AllocatorType<string_t> alloc;
17580 std::allocator_traits<decltype(alloc)>::destroy(alloc,
string);
17581 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
string, 1);
17585 case value_t::binary:
17587 AllocatorType<binary_t> alloc;
17588 std::allocator_traits<decltype(alloc)>::destroy(alloc,
binary);
17589 std::allocator_traits<decltype(alloc)>::deallocate(alloc,
binary, 1);
17610 void assert_invariant() const noexcept
17612 JSON_ASSERT(m_type != value_t::object || m_value.object !=
nullptr);
17613 JSON_ASSERT(m_type != value_t::array || m_value.array !=
nullptr);
17614 JSON_ASSERT(m_type != value_t::string || m_value.string !=
nullptr);
17615 JSON_ASSERT(m_type != value_t::binary || m_value.binary !=
nullptr);
17638 using parse_event_t = detail::parse_event_t;
17731 : m_type(v), m_value(v)
17733 assert_invariant();
17757 assert_invariant();
17823 template <
typename CompatibleType,
17824 typename U = detail::uncvref_t<CompatibleType>,
17825 detail::enable_if_t <
17826 !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value,
int > = 0 >
17828 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
17829 std::forward<CompatibleType>(val))))
17831 JSONSerializer<U>::to_json(*
this, std::forward<CompatibleType>(val));
17832 assert_invariant();
17861 template <
typename BasicJsonType,
17862 detail::enable_if_t <
17863 detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value,
int > = 0 >
17866 using other_boolean_t =
typename BasicJsonType::boolean_t;
17867 using other_number_float_t =
typename BasicJsonType::number_float_t;
17868 using other_number_integer_t =
typename BasicJsonType::number_integer_t;
17869 using other_number_unsigned_t =
typename BasicJsonType::number_unsigned_t;
17870 using other_string_t =
typename BasicJsonType::string_t;
17871 using other_object_t =
typename BasicJsonType::object_t;
17872 using other_array_t =
typename BasicJsonType::array_t;
17873 using other_binary_t =
typename BasicJsonType::binary_t;
17875 switch (val.type())
17877 case value_t::boolean:
17878 JSONSerializer<other_boolean_t>::to_json(*
this, val.template get<other_boolean_t>());
17880 case value_t::number_float:
17881 JSONSerializer<other_number_float_t>::to_json(*
this, val.template get<other_number_float_t>());
17883 case value_t::number_integer:
17884 JSONSerializer<other_number_integer_t>::to_json(*
this, val.template get<other_number_integer_t>());
17886 case value_t::number_unsigned:
17887 JSONSerializer<other_number_unsigned_t>::to_json(*
this, val.template get<other_number_unsigned_t>());
17889 case value_t::string:
17890 JSONSerializer<other_string_t>::to_json(*
this, val.template get_ref<const other_string_t&>());
17892 case value_t::object:
17893 JSONSerializer<other_object_t>::to_json(*
this, val.template get_ref<const other_object_t&>());
17895 case value_t::array:
17896 JSONSerializer<other_array_t>::to_json(*
this, val.template get_ref<const other_array_t&>());
17898 case value_t::binary:
17899 JSONSerializer<other_binary_t>::to_json(*
this, val.template get_ref<const other_binary_t&>());
17901 case value_t::null:
17904 case value_t::discarded:
17905 m_type = value_t::discarded;
17908 JSON_ASSERT(
false);
17910 assert_invariant();
17988 bool type_deduction =
true,
17989 value_t manual_type = value_t::array)
17993 bool is_an_object = std::all_of(init.begin(), init.end(),
17994 [](
const detail::json_ref<basic_json>& element_ref)
17996 return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
18000 if (!type_deduction)
18003 if (manual_type == value_t::array)
18005 is_an_object =
false;
18009 if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
18011 JSON_THROW(type_error::create(301,
"cannot create object from initializer list"));
18018 m_type = value_t::object;
18019 m_value = value_t::object;
18021 std::for_each(init.begin(), init.end(), [
this](
const detail::json_ref<basic_json>& element_ref)
18023 auto element = element_ref.moved_or_copied();
18024 m_value.object->emplace(
18025 std::move(*((*element.m_value.array)[0].m_value.string)),
18026 std::move((*element.m_value.array)[1]));
18032 m_type = value_t::array;
18033 m_value.array = create<array_t>(init.begin(), init.end());
18036 assert_invariant();
18070 res.m_type = value_t::binary;
18071 res.m_value = init;
18107 res.m_type = value_t::binary;
18108 res.m_value =
binary_t(init, subtype);
18117 res.m_type = value_t::binary;
18118 res.m_value = std::move(init);
18127 res.m_type = value_t::binary;
18128 res.m_value =
binary_t(std::move(init), subtype);
18172 return basic_json(init,
false, value_t::array);
18216 return basic_json(init,
false, value_t::object);
18242 : m_type(value_t::
array)
18244 m_value.array = create<array_t>(cnt, val);
18245 assert_invariant();
18303 template <
class InputIT,
typename std::enable_if <
18304 std::is_same<InputIT, typename basic_json_t::iterator>::value ||
18305 std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
int >
::type = 0 >
18308 JSON_ASSERT(first.m_object !=
nullptr);
18309 JSON_ASSERT(last.m_object !=
nullptr);
18312 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
18314 JSON_THROW(invalid_iterator::create(201,
"iterators are not compatible"));
18318 m_type = first.m_object->m_type;
18323 case value_t::boolean:
18324 case value_t::number_float:
18325 case value_t::number_integer:
18326 case value_t::number_unsigned:
18327 case value_t::string:
18329 if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
18330 || !last.m_it.primitive_iterator.is_end()))
18332 JSON_THROW(invalid_iterator::create(204,
"iterators out of range"));
18343 case value_t::number_integer:
18345 m_value.number_integer = first.m_object->m_value.number_integer;
18349 case value_t::number_unsigned:
18351 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
18355 case value_t::number_float:
18357 m_value.number_float = first.m_object->m_value.number_float;
18361 case value_t::boolean:
18363 m_value.boolean = first.m_object->m_value.boolean;
18367 case value_t::string:
18369 m_value = *first.m_object->m_value.string;
18373 case value_t::object:
18375 m_value.object = create<object_t>(first.m_it.object_iterator,
18376 last.m_it.object_iterator);
18380 case value_t::array:
18382 m_value.array = create<array_t>(first.m_it.array_iterator,
18383 last.m_it.array_iterator);
18387 case value_t::binary:
18389 m_value = *first.m_object->m_value.binary;
18394 JSON_THROW(invalid_iterator::create(206,
"cannot construct with iterators from " +
18395 std::string(first.m_object->type_name())));
18398 assert_invariant();
18406 template<
typename JsonRef,
18407 detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
18408 std::is_same<typename JsonRef::value_type, basic_json>>
::value,
int> = 0 >
18437 : m_type(other.m_type)
18440 other.assert_invariant();
18444 case value_t::object:
18446 m_value = *other.m_value.object;
18450 case value_t::array:
18452 m_value = *other.m_value.array;
18456 case value_t::string:
18458 m_value = *other.m_value.string;
18462 case value_t::boolean:
18464 m_value = other.m_value.boolean;
18468 case value_t::number_integer:
18470 m_value = other.m_value.number_integer;
18474 case value_t::number_unsigned:
18476 m_value = other.m_value.number_unsigned;
18480 case value_t::number_float:
18482 m_value = other.m_value.number_float;
18486 case value_t::binary:
18488 m_value = *other.m_value.binary;
18496 assert_invariant();
18526 : m_type(std::move(other.m_type)),
18527 m_value(std::move(other.m_value))
18530 other.assert_invariant();
18533 other.m_type = value_t::null;
18534 other.m_value = {};
18536 assert_invariant();
18563 std::is_nothrow_move_constructible<value_t>::value&&
18564 std::is_nothrow_move_assignable<value_t>::value&&
18565 std::is_nothrow_move_constructible<json_value>::value&&
18566 std::is_nothrow_move_assignable<json_value>::value
18570 other.assert_invariant();
18573 swap(m_type, other.m_type);
18574 swap(m_value, other.m_value);
18576 assert_invariant();
18597 assert_invariant();
18598 m_value.destroy(m_type);
18660 const char indent_char =
' ',
18661 const bool ensure_ascii =
false,
18662 const error_handler_t error_handler = error_handler_t::strict)
const
18665 serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
18669 s.dump(*
this,
true, ensure_ascii,
static_cast<unsigned int>(indent));
18673 s.dump(*
this,
false, ensure_ascii, 0);
18712 constexpr value_t
type() const noexcept
18794 return m_type == value_t::null;
18816 return m_type == value_t::boolean;
18875 return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
18903 return m_type == value_t::number_unsigned;
18931 return m_type == value_t::number_float;
18953 return m_type == value_t::object;
18975 return m_type == value_t::array;
18997 return m_type == value_t::string;
19019 return m_type == value_t::binary;
19046 return m_type == value_t::discarded;
19087 return m_value.boolean;
19090 JSON_THROW(type_error::create(302,
"type must be boolean, but is " + std::string(
type_name())));
19096 return is_object() ? m_value.object :
nullptr;
19102 return is_object() ? m_value.object :
nullptr;
19108 return is_array() ? m_value.array :
nullptr;
19112 constexpr
const array_t* get_impl_ptr(
const array_t* )
const noexcept
19114 return is_array() ? m_value.array :
nullptr;
19120 return is_string() ? m_value.string :
nullptr;
19126 return is_string() ? m_value.string :
nullptr;
19132 return is_boolean() ? &m_value.boolean :
nullptr;
19138 return is_boolean() ? &m_value.boolean :
nullptr;
19180 return is_binary() ? m_value.binary :
nullptr;
19186 return is_binary() ? m_value.binary :
nullptr;
19200 template<
typename ReferenceType,
typename ThisType>
19201 static ReferenceType get_ref_impl(ThisType& obj)
19204 auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
19206 if (JSON_HEDLEY_LIKELY(ptr !=
nullptr))
19211 JSON_THROW(type_error::create(303,
"incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
19233 template<
typename BasicJsonType, detail::enable_if_t<
19234 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>
::value,
19256 template <
typename BasicJsonType, detail::enable_if_t <
19257 !std::is_same<BasicJsonType, basic_json>::value&&
19258 detail::is_basic_json<BasicJsonType>::value,
int > = 0 >
19303 template <
typename ValueTypeCV,
typename ValueType = detail::uncvref_t<ValueTypeCV>,
19304 detail::enable_if_t <
19305 !detail::is_basic_json<ValueType>::value &&
19306 detail::has_from_json<basic_json_t, ValueType>::value &&
19307 !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
19309 ValueType
get() const noexcept(noexcept(
19310 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
19315 static_assert(!std::is_reference<ValueTypeCV>::value,
19316 "get() cannot be used with reference types, you might want to use get_ref()");
19317 static_assert(std::is_default_constructible<ValueType>::value,
19318 "types must be DefaultConstructible when used with get()");
19321 JSONSerializer<ValueType>::from_json(*
this, ret);
19356 template <
typename ValueTypeCV,
typename ValueType = detail::uncvref_t<ValueTypeCV>,
19357 detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
19358 detail::has_non_default_from_json<basic_json_t, ValueType>::value,
19360 ValueType
get() const noexcept(noexcept(
19361 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
19363 static_assert(!std::is_reference<ValueTypeCV>::value,
19364 "get() cannot be used with reference types, you might want to use get_ref()");
19365 return JSONSerializer<ValueType>::from_json(*
this);
19401 template <
typename ValueType,
19402 detail::enable_if_t <
19403 !detail::is_basic_json<ValueType>::value&&
19404 detail::has_from_json<basic_json_t, ValueType>::value,
19406 ValueType &
get_to(ValueType& v)
const noexcept(noexcept(
19407 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
19409 JSONSerializer<ValueType>::from_json(*
this, v);
19415 template<
typename ValueType,
19416 detail::enable_if_t <
19417 detail::is_basic_json<ValueType>::value,
19426 typename T, std::size_t N,
19427 typename Array = T (&)[N],
19428 detail::enable_if_t <
19429 detail::has_from_json<basic_json_t, Array>::value,
int > = 0 >
19431 noexcept(noexcept(JSONSerializer<Array>::from_json(
19432 std::declval<const basic_json_t&>(), v)))
19434 JSONSerializer<Array>::from_json(*
this, v);
19465 template<
typename PointerType,
typename std::enable_if<
19466 std::is_pointer<PointerType>::value,
int>
::type = 0>
19467 auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
19470 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
19477 template <
typename PointerType,
typename std::enable_if <
19478 std::is_pointer<PointerType>::value&&
19479 std::is_const<typename std::remove_pointer<PointerType>::type>
::value,
int >
::type = 0 >
19480 constexpr
auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
19483 return get_impl_ptr(
static_cast<PointerType
>(
nullptr));
19513 template<
typename PointerType,
typename std::enable_if<
19514 std::is_pointer<PointerType>::value,
int>
::type = 0>
19515 auto get() noexcept -> decltype(std::declval<basic_json_t&>().template
get_ptr<PointerType>())
19518 return get_ptr<PointerType>();
19525 template<
typename PointerType,
typename std::enable_if<
19526 std::is_pointer<PointerType>::value,
int>
::type = 0>
19527 constexpr
auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template
get_ptr<PointerType>())
19530 return get_ptr<PointerType>();
19559 template<
typename ReferenceType,
typename std::enable_if<
19560 std::is_reference<ReferenceType>::value,
int>
::type = 0>
19564 return get_ref_impl<ReferenceType>(*
this);
19571 template <
typename ReferenceType,
typename std::enable_if <
19572 std::is_reference<ReferenceType>::value&&
19573 std::is_const<typename std::remove_reference<ReferenceType>::type>
::value,
int >
::type = 0 >
19577 return get_ref_impl<ReferenceType>(*
this);
19609 template <
typename ValueType,
typename std::enable_if <
19610 !std::is_pointer<ValueType>::value&&
19611 !std::is_same<ValueType, detail::json_ref<basic_json>>
::value&&
19612 !std::is_same<ValueType, typename string_t::value_type>::value&&
19613 !detail::is_basic_json<ValueType>::value
19614 && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>
::value
19615 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
19616 && !std::is_same<ValueType, typename std::string_view>::value
19618 && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
19620 JSON_EXPLICIT
operator ValueType()
const
19623 return get<ValueType>();
19639 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name())));
19642 return *get_ptr<binary_t*>();
19650 JSON_THROW(type_error::create(302,
"type must be binary, but is " + std::string(
type_name())));
19653 return *get_ptr<const binary_t*>();
19696 if (JSON_HEDLEY_LIKELY(
is_array()))
19700 return m_value.array->at(idx);
19702 JSON_CATCH (std::out_of_range&)
19705 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range"));
19710 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name())));
19743 if (JSON_HEDLEY_LIKELY(
is_array()))
19747 return m_value.array->at(idx);
19749 JSON_CATCH (std::out_of_range&)
19752 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range"));
19757 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name())));
19791 reference at(
const typename object_t::key_type& key)
19798 return m_value.object->at(key);
19800 JSON_CATCH (std::out_of_range&)
19803 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found"));
19808 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name())));
19849 return m_value.object->at(key);
19851 JSON_CATCH (std::out_of_range&)
19854 JSON_THROW(out_of_range::create(403,
"key '" + key +
"' not found"));
19859 JSON_THROW(type_error::create(304,
"cannot use at() with " + std::string(
type_name())));
19893 m_type = value_t::array;
19894 m_value.array = create<array_t>();
19895 assert_invariant();
19899 if (JSON_HEDLEY_LIKELY(
is_array()))
19902 if (idx >= m_value.array->size())
19904 m_value.array->insert(m_value.array->end(),
19905 idx - m_value.array->size() + 1,
19909 return m_value.array->operator[](idx);
19912 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name())));
19937 if (JSON_HEDLEY_LIKELY(
is_array()))
19939 return m_value.array->operator[](idx);
19942 JSON_THROW(type_error::create(305,
"cannot use operator[] with a numeric argument with " + std::string(
type_name())));
19977 m_type = value_t::object;
19978 m_value.object = create<object_t>();
19979 assert_invariant();
19985 return m_value.object->operator[](key);
19988 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name())));
20026 JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
20027 return m_value.object->find(key)->second;
20030 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name())));
20060 template<
typename T>
20061 JSON_HEDLEY_NON_NULL(2)
20067 m_type = value_t::object;
20068 m_value = value_t::object;
20069 assert_invariant();
20075 return m_value.object->operator[](key);
20078 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name())));
20111 template<
typename T>
20112 JSON_HEDLEY_NON_NULL(2)
20118 JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
20119 return m_value.object->find(key)->second;
20122 JSON_THROW(type_error::create(305,
"cannot use operator[] with a string argument with " + std::string(
type_name())));
20176 template <
class ValueType,
typename std::enable_if <
20177 detail::is_getable<basic_json_t, ValueType>::value
20178 && !std::is_same<value_t, ValueType>::value,
int >
::type = 0 >
20179 ValueType
value(
const typename object_t::key_type& key,
const ValueType& default_value)
const
20185 const auto it =
find(key);
20188 return it->template get<ValueType>();
20191 return default_value;
20194 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name())));
20201 string_t value(
const typename object_t::key_type& key,
const char* default_value)
const
20249 template<
class ValueType,
typename std::enable_if<
20250 detail::is_getable<basic_json_t, ValueType>::value,
int>
::type = 0>
20259 return ptr.get_checked(
this).template get<ValueType>();
20263 return default_value;
20267 JSON_THROW(type_error::create(306,
"cannot use value() with " + std::string(
type_name())));
20274 JSON_HEDLEY_NON_NULL(3)
20412 template <
class IteratorType,
typename std::enable_if <
20413 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
20414 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
20416 IteratorType
erase(IteratorType pos)
20419 if (JSON_HEDLEY_UNLIKELY(
this != pos.m_object))
20421 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value"));
20424 IteratorType result =
end();
20428 case value_t::boolean:
20429 case value_t::number_float:
20430 case value_t::number_integer:
20431 case value_t::number_unsigned:
20432 case value_t::string:
20433 case value_t::binary:
20435 if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
20437 JSON_THROW(invalid_iterator::create(205,
"iterator out of range"));
20442 AllocatorType<string_t> alloc;
20443 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
20444 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
20445 m_value.string =
nullptr;
20449 AllocatorType<binary_t> alloc;
20450 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
20451 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
20452 m_value.binary =
nullptr;
20455 m_type = value_t::null;
20456 assert_invariant();
20460 case value_t::object:
20462 result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
20466 case value_t::array:
20468 result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
20473 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name())));
20525 template <
class IteratorType,
typename std::enable_if <
20526 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
20527 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
int >
::type
20529 IteratorType
erase(IteratorType first, IteratorType last)
20532 if (JSON_HEDLEY_UNLIKELY(
this != first.m_object ||
this != last.m_object))
20534 JSON_THROW(invalid_iterator::create(203,
"iterators do not fit current value"));
20537 IteratorType result =
end();
20541 case value_t::boolean:
20542 case value_t::number_float:
20543 case value_t::number_integer:
20544 case value_t::number_unsigned:
20545 case value_t::string:
20546 case value_t::binary:
20548 if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
20549 || !last.m_it.primitive_iterator.is_end()))
20551 JSON_THROW(invalid_iterator::create(204,
"iterators out of range"));
20556 AllocatorType<string_t> alloc;
20557 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
20558 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
20559 m_value.string =
nullptr;
20563 AllocatorType<binary_t> alloc;
20564 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
20565 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
20566 m_value.binary =
nullptr;
20569 m_type = value_t::null;
20570 assert_invariant();
20574 case value_t::object:
20576 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
20577 last.m_it.object_iterator);
20581 case value_t::array:
20583 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
20584 last.m_it.array_iterator);
20589 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name())));
20629 return m_value.object->erase(key);
20632 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name())));
20662 if (JSON_HEDLEY_LIKELY(
is_array()))
20664 if (JSON_HEDLEY_UNLIKELY(idx >=
size()))
20666 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range"));
20673 JSON_THROW(type_error::create(307,
"cannot use erase() with " + std::string(
type_name())));
20711 template<
typename KeyT>
20714 auto result =
end();
20718 result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
20728 template<
typename KeyT>
20731 auto result =
cend();
20735 result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
20762 template<
typename KeyT>
20766 return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
20794 template <
typename KeyT,
typename std::enable_if <
20798 return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
20829 return ptr.contains(
this);
20869 result.set_begin();
20909 result.set_begin();
21173 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
21176 return ref.items();
21182 JSON_HEDLEY_DEPRECATED_FOR(3.1.0,
items())
21185 return ref.items();
21256 iteration_proxy<iterator>
items() noexcept
21258 return iteration_proxy<iterator>(*
this);
21264 iteration_proxy<const_iterator>
items() const noexcept
21266 return iteration_proxy<const_iterator>(*
this);
21321 bool empty() const noexcept
21325 case value_t::null:
21331 case value_t::array:
21334 return m_value.array->empty();
21337 case value_t::object:
21340 return m_value.object->empty();
21398 case value_t::null:
21404 case value_t::array:
21407 return m_value.array->size();
21410 case value_t::object:
21413 return m_value.object->size();
21469 case value_t::array:
21472 return m_value.array->max_size();
21475 case value_t::object:
21478 return m_value.object->max_size();
21536 void clear() noexcept
21540 case value_t::number_integer:
21542 m_value.number_integer = 0;
21546 case value_t::number_unsigned:
21548 m_value.number_unsigned = 0;
21552 case value_t::number_float:
21554 m_value.number_float = 0.0;
21558 case value_t::boolean:
21560 m_value.boolean =
false;
21564 case value_t::string:
21566 m_value.string->clear();
21570 case value_t::binary:
21572 m_value.binary->clear();
21576 case value_t::array:
21578 m_value.array->clear();
21582 case value_t::object:
21584 m_value.object->clear();
21618 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name())));
21624 m_type = value_t::array;
21625 m_value = value_t::array;
21626 assert_invariant();
21630 m_value.array->push_back(std::move(val));
21653 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name())));
21659 m_type = value_t::array;
21660 m_value = value_t::array;
21661 assert_invariant();
21665 m_value.array->push_back(val);
21698 void push_back(
const typename object_t::value_type& val)
21703 JSON_THROW(type_error::create(308,
"cannot use push_back() with " + std::string(
type_name())));
21709 m_type = value_t::object;
21710 m_value = value_t::object;
21711 assert_invariant();
21715 m_value.object->insert(val);
21755 if (
is_object() && init.size() == 2 && (*init.begin())->is_string())
21757 basic_json&& key = init.begin()->moved_or_copied();
21758 push_back(
typename object_t::value_type(
21759 std::move(key.get_ref<
string_t&>()), (init.begin() + 1)->moved_or_copied()));
21800 template<
class... Args>
21806 JSON_THROW(type_error::create(311,
"cannot use emplace_back() with " + std::string(
type_name())));
21812 m_type = value_t::array;
21813 m_value = value_t::array;
21814 assert_invariant();
21818 #ifdef JSON_HAS_CPP_17
21819 return m_value.array->emplace_back(std::forward<Args>(args)...);
21821 m_value.array->emplace_back(std::forward<Args>(args)...);
21822 return m_value.array->back();
21853 template<
class... Args>
21854 std::pair<iterator, bool>
emplace(Args&& ... args)
21859 JSON_THROW(type_error::create(311,
"cannot use emplace() with " + std::string(
type_name())));
21865 m_type = value_t::object;
21866 m_value = value_t::object;
21867 assert_invariant();
21871 auto res = m_value.object->emplace(std::forward<Args>(args)...);
21874 it.m_it.object_iterator = res.first;
21877 return {it, res.second};
21883 template<
typename... Args>
21887 JSON_ASSERT(m_value.array !=
nullptr);
21889 auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
21890 m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
21891 result.m_it.array_iterator = m_value.array->begin() + insert_pos;
21925 if (JSON_HEDLEY_LIKELY(
is_array()))
21928 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
21930 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value"));
21937 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name())));
21946 return insert(pos, val);
21976 if (JSON_HEDLEY_LIKELY(
is_array()))
21979 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
21981 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value"));
21988 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name())));
22024 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
22026 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name())));
22030 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
22032 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value"));
22036 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22038 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit"));
22041 if (JSON_HEDLEY_UNLIKELY(first.m_object ==
this))
22043 JSON_THROW(invalid_iterator::create(211,
"passed iterators may not belong to container"));
22047 return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
22077 if (JSON_HEDLEY_UNLIKELY(!
is_array()))
22079 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name())));
22083 if (JSON_HEDLEY_UNLIKELY(pos.m_object !=
this))
22085 JSON_THROW(invalid_iterator::create(202,
"iterator does not fit current value"));
22118 if (JSON_HEDLEY_UNLIKELY(!
is_object()))
22120 JSON_THROW(type_error::create(309,
"cannot use insert() with " + std::string(
type_name())));
22124 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22126 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit"));
22130 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
22132 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects"));
22135 m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
22162 m_type = value_t::object;
22163 m_value.object = create<object_t>();
22164 assert_invariant();
22169 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name())));
22171 if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
22173 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(j.type_name())));
22176 for (
auto it = j.cbegin(); it != j.cend(); ++it)
22178 m_value.object->operator[](it.key()) = it.value();
22213 m_type = value_t::object;
22214 m_value.object = create<object_t>();
22215 assert_invariant();
22220 JSON_THROW(type_error::create(312,
"cannot use update() with " + std::string(
type_name())));
22224 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22226 JSON_THROW(invalid_iterator::create(210,
"iterators do not fit"));
22230 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
22231 || !last.m_object->is_object()))
22233 JSON_THROW(invalid_iterator::create(202,
"iterators first and last must point to objects"));
22236 for (
auto it = first; it != last; ++it)
22238 m_value.object->operator[](it.key()) = it.value();
22260 std::is_nothrow_move_constructible<value_t>::value&&
22261 std::is_nothrow_move_assignable<value_t>::value&&
22262 std::is_nothrow_move_constructible<json_value>::value&&
22263 std::is_nothrow_move_assignable<json_value>::value
22266 std::swap(m_type, other.m_type);
22267 std::swap(m_value, other.m_value);
22268 assert_invariant();
22290 std::is_nothrow_move_constructible<value_t>::value&&
22291 std::is_nothrow_move_assignable<value_t>::value&&
22292 std::is_nothrow_move_constructible<json_value>::value&&
22293 std::is_nothrow_move_assignable<json_value>::value
22322 if (JSON_HEDLEY_LIKELY(
is_array()))
22324 std::swap(*(m_value.array), other);
22328 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name())));
22357 std::swap(*(m_value.object), other);
22361 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name())));
22390 std::swap(*(m_value.string), other);
22394 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name())));
22423 std::swap(*(m_value.binary), other);
22427 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name())));
22437 std::swap(*(m_value.binary), other);
22441 JSON_THROW(type_error::create(310,
"cannot use swap() with " + std::string(
type_name())));
22512 const auto lhs_type = lhs.type();
22513 const auto rhs_type = rhs.type();
22515 if (lhs_type == rhs_type)
22519 case value_t::array:
22520 return *lhs.m_value.array == *rhs.m_value.array;
22522 case value_t::object:
22523 return *lhs.m_value.object == *rhs.m_value.object;
22525 case value_t::null:
22528 case value_t::string:
22529 return *lhs.m_value.string == *rhs.m_value.string;
22531 case value_t::boolean:
22532 return lhs.m_value.boolean == rhs.m_value.boolean;
22534 case value_t::number_integer:
22535 return lhs.m_value.number_integer == rhs.m_value.number_integer;
22537 case value_t::number_unsigned:
22538 return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
22540 case value_t::number_float:
22541 return lhs.m_value.number_float == rhs.m_value.number_float;
22543 case value_t::binary:
22544 return *lhs.m_value.binary == *rhs.m_value.binary;
22550 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
22552 return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
22554 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
22556 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_integer);
22558 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
22560 return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
22562 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
22564 return lhs.m_value.number_float ==
static_cast<number_float_t>(rhs.m_value.number_unsigned);
22566 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
22568 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
22570 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
22572 return lhs.m_value.number_integer ==
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
22582 template<
typename ScalarType,
typename std::enable_if<
22583 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22593 template<
typename ScalarType,
typename std::enable_if<
22594 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22620 return !(lhs == rhs);
22627 template<
typename ScalarType,
typename std::enable_if<
22628 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22638 template<
typename ScalarType,
typename std::enable_if<
22639 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22673 const auto lhs_type = lhs.type();
22674 const auto rhs_type = rhs.type();
22676 if (lhs_type == rhs_type)
22680 case value_t::array:
22683 return (*lhs.m_value.array) < (*rhs.m_value.array);
22685 case value_t::object:
22686 return (*lhs.m_value.object) < (*rhs.m_value.object);
22688 case value_t::null:
22691 case value_t::string:
22692 return (*lhs.m_value.string) < (*rhs.m_value.string);
22694 case value_t::boolean:
22695 return (lhs.m_value.boolean) < (rhs.m_value.boolean);
22697 case value_t::number_integer:
22698 return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
22700 case value_t::number_unsigned:
22701 return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
22703 case value_t::number_float:
22704 return (lhs.m_value.number_float) < (rhs.m_value.number_float);
22706 case value_t::binary:
22707 return (*lhs.m_value.binary) < (*rhs.m_value.binary);
22713 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
22715 return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
22717 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
22719 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_integer);
22721 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
22723 return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
22725 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
22727 return lhs.m_value.number_float <
static_cast<number_float_t>(rhs.m_value.number_unsigned);
22729 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
22731 return lhs.m_value.number_integer <
static_cast<number_integer_t>(rhs.m_value.number_unsigned);
22733 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
22735 return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
22748 template<
typename ScalarType,
typename std::enable_if<
22749 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22759 template<
typename ScalarType,
typename std::enable_if<
22760 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22787 return !(rhs < lhs);
22794 template<
typename ScalarType,
typename std::enable_if<
22795 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22805 template<
typename ScalarType,
typename std::enable_if<
22806 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22833 return !(lhs <= rhs);
22840 template<
typename ScalarType,
typename std::enable_if<
22841 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22851 template<
typename ScalarType,
typename std::enable_if<
22852 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22879 return !(lhs < rhs);
22886 template<
typename ScalarType,
typename std::enable_if<
22887 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22897 template<
typename ScalarType,
typename std::enable_if<
22898 std::is_scalar<ScalarType>::value,
int>
::type = 0>
22947 const bool pretty_print = o.width() > 0;
22948 const auto indentation = pretty_print ? o.width() : 0;
22954 serializer s(detail::output_adapter<char>(o), o.fill());
22955 s.dump(j, pretty_print,
false,
static_cast<unsigned int>(indentation));
22967 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator<<(std::ostream&,
const basic_json&))
23034 template<
typename InputType>
23038 const bool allow_exceptions =
true,
23039 const bool ignore_comments =
false)
23042 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(
true, result);
23072 template<
typename IteratorType>
23077 const bool allow_exceptions =
true,
23078 const bool ignore_comments =
false)
23081 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(
true, result);
23086 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
parse(ptr, ptr + len))
23089 const bool allow_exceptions =
true,
23090 const bool ignore_comments =
false)
23093 parser(i.get(), cb, allow_exceptions, ignore_comments).parse(
true, result);
23127 template<
typename InputType>
23128 static bool accept(InputType&& i,
23129 const bool ignore_comments =
false)
23131 return parser(detail::input_adapter(std::forward<InputType>(i)),
nullptr,
false, ignore_comments).accept(
true);
23134 template<
typename IteratorType>
23135 static bool accept(IteratorType first, IteratorType last,
23136 const bool ignore_comments =
false)
23138 return parser(detail::input_adapter(std::move(first), std::move(last)),
nullptr,
false, ignore_comments).accept(
true);
23142 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
accept(ptr, ptr + len))
23143 static bool accept(detail::span_input_adapter&& i,
23144 const bool ignore_comments =
false)
23146 return parser(i.get(),
nullptr,
false, ignore_comments).accept(
true);
23189 template <
typename InputType,
typename SAX>
23190 JSON_HEDLEY_NON_NULL(2)
23191 static
bool sax_parse(InputType&& i, SAX* sax,
23193 const
bool strict = true,
23194 const
bool ignore_comments = false)
23196 auto ia = detail::input_adapter(std::forward<InputType>(i));
23197 return format == input_format_t::json
23198 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
23199 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
23202 template<
class IteratorType,
class SAX>
23203 JSON_HEDLEY_NON_NULL(3)
23204 static
bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
23205 input_format_t format = input_format_t::
json,
23206 const
bool strict = true,
23207 const
bool ignore_comments = false)
23209 auto ia = detail::input_adapter(std::move(first), std::move(last));
23210 return format == input_format_t::json
23211 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
23212 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
23215 template <
typename SAX>
23216 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
sax_parse(ptr, ptr + len, ...))
23217 JSON_HEDLEY_NON_NULL(2)
23218 static
bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
23219 input_format_t format = input_format_t::
json,
23220 const
bool strict = true,
23221 const
bool ignore_comments = false)
23224 return format == input_format_t::json
23225 ? parser(std::move(ia),
nullptr,
true, ignore_comments).sax_parse(sax, strict)
23226 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
23237 JSON_HEDLEY_DEPRECATED_FOR(3.0.0,
operator>>(std::istream&,
basic_json&))
23270 parser(detail::input_adapter(i)).parse(
false, j);
23317 case value_t::null:
23319 case value_t::object:
23321 case value_t::array:
23323 case value_t::string:
23325 case value_t::boolean:
23327 case value_t::binary:
23329 case value_t::discarded:
23330 return "discarded";
23344 value_t m_type = value_t::null;
23347 json_value m_value = {};
23453 std::vector<uint8_t> result;
23460 binary_writer<uint8_t>(o).write_cbor(j);
23465 binary_writer<char>(o).write_cbor(j);
23548 std::vector<uint8_t> result;
23555 binary_writer<uint8_t>(o).write_msgpack(j);
23560 binary_writer<char>(o).write_msgpack(j);
23650 const bool use_size =
false,
23651 const bool use_type =
false)
23653 std::vector<uint8_t> result;
23654 to_ubjson(j, result, use_size, use_type);
23659 const bool use_size =
false,
const bool use_type =
false)
23661 binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
23665 const bool use_size =
false,
const bool use_type =
false)
23667 binary_writer<char>(o).write_ubjson(j, use_size, use_type);
23729 std::vector<uint8_t> result;
23744 binary_writer<uint8_t>(o).write_bson(j);
23752 binary_writer<char>(o).write_bson(j);
23858 template<
typename InputType>
23861 const bool strict =
true,
23862 const bool allow_exceptions =
true,
23866 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23867 auto ia = detail::input_adapter(std::forward<InputType>(i));
23868 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23869 return res ? result :
basic_json(value_t::discarded);
23875 template<
typename IteratorType>
23878 const bool strict =
true,
23879 const bool allow_exceptions =
true,
23883 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23884 auto ia = detail::input_adapter(std::move(first), std::move(last));
23885 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23886 return res ? result :
basic_json(value_t::discarded);
23889 template<
typename T>
23891 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_cbor(ptr, ptr + len))
23893 const bool strict =
true,
23894 const bool allow_exceptions =
true,
23897 return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
23904 const bool strict =
true,
23905 const bool allow_exceptions =
true,
23906 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23909 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23911 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23912 return res ? result :
basic_json(value_t::discarded);
24001 template<
typename InputType>
24004 const bool strict =
true,
24005 const bool allow_exceptions =
true)
24008 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24009 auto ia = detail::input_adapter(std::forward<InputType>(i));
24010 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24011 return res ? result :
basic_json(value_t::discarded);
24017 template<
typename IteratorType>
24020 const bool strict =
true,
24021 const bool allow_exceptions =
true)
24024 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24025 auto ia = detail::input_adapter(std::move(first), std::move(last));
24026 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24027 return res ? result :
basic_json(value_t::discarded);
24031 template<
typename T>
24033 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
24035 const bool strict =
true,
24036 const bool allow_exceptions =
true)
24038 return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
24042 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_msgpack(ptr, ptr + len))
24044 const bool strict =
true,
24045 const bool allow_exceptions =
true)
24048 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24050 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24051 return res ? result :
basic_json(value_t::discarded);
24117 template<
typename InputType>
24120 const bool strict =
true,
24121 const bool allow_exceptions =
true)
24124 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24125 auto ia = detail::input_adapter(std::forward<InputType>(i));
24126 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24127 return res ? result :
basic_json(value_t::discarded);
24133 template<
typename IteratorType>
24136 const bool strict =
true,
24137 const bool allow_exceptions =
true)
24140 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24141 auto ia = detail::input_adapter(std::move(first), std::move(last));
24142 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24143 return res ? result :
basic_json(value_t::discarded);
24146 template<
typename T>
24148 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
24150 const bool strict =
true,
24151 const bool allow_exceptions =
true)
24153 return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
24157 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_ubjson(ptr, ptr + len))
24159 const bool strict =
true,
24160 const bool allow_exceptions =
true)
24163 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24165 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24166 return res ? result :
basic_json(value_t::discarded);
24230 template<
typename InputType>
24233 const bool strict =
true,
24234 const bool allow_exceptions =
true)
24237 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24238 auto ia = detail::input_adapter(std::forward<InputType>(i));
24239 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24240 return res ? result :
basic_json(value_t::discarded);
24246 template<
typename IteratorType>
24249 const bool strict =
true,
24250 const bool allow_exceptions =
true)
24253 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24254 auto ia = detail::input_adapter(std::move(first), std::move(last));
24255 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24256 return res ? result :
basic_json(value_t::discarded);
24259 template<
typename T>
24261 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
24263 const bool strict =
true,
24264 const bool allow_exceptions =
true)
24266 return from_bson(ptr, ptr + len, strict, allow_exceptions);
24270 JSON_HEDLEY_DEPRECATED_FOR(3.8.0,
from_bson(ptr, ptr + len))
24272 const bool strict =
true,
24273 const bool allow_exceptions =
true)
24276 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24278 const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24279 return res ? result :
basic_json(value_t::discarded);
24325 return ptr.get_unchecked(
this);
24353 return ptr.get_unchecked(
this);
24396 return ptr.get_checked(
this);
24439 return ptr.get_checked(
this);
24467 json_pointer::flatten(
"", *
this, result);
24503 return json_pointer::unflatten(*
this);
24568 enum class patch_operations {add, remove, replace, move, copy, test, invalid};
24570 const auto get_op = [](
const std::string & op)
24574 return patch_operations::add;
24576 if (op ==
"remove")
24578 return patch_operations::remove;
24580 if (op ==
"replace")
24582 return patch_operations::replace;
24586 return patch_operations::move;
24590 return patch_operations::copy;
24594 return patch_operations::test;
24597 return patch_operations::invalid;
24612 if (top_pointer != ptr)
24614 result.at(top_pointer);
24618 const auto last_path = ptr.back();
24622 switch (parent.m_type)
24624 case value_t::null:
24625 case value_t::object:
24628 parent[last_path] = val;
24632 case value_t::array:
24634 if (last_path ==
"-")
24637 parent.push_back(val);
24641 const auto idx = json_pointer::array_index(last_path);
24642 if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
24645 JSON_THROW(out_of_range::create(401,
"array index " + std::to_string(idx) +
" is out of range"));
24649 parent.insert(parent.begin() +
static_cast<difference_type>(idx), val);
24656 JSON_ASSERT(
false);
24661 const auto operation_remove = [&result](
json_pointer & ptr)
24664 const auto last_path = ptr.back();
24669 if (parent.is_object())
24672 auto it = parent.find(last_path);
24673 if (JSON_HEDLEY_LIKELY(it != parent.end()))
24679 JSON_THROW(out_of_range::create(403,
"key '" + last_path +
"' not found"));
24682 else if (parent.is_array())
24685 parent.erase(json_pointer::array_index(last_path));
24690 if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
24692 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects"));
24696 for (
const auto& val : json_patch)
24699 const auto get_value = [&val](
const std::string & op,
24700 const std::string & member,
24704 auto it = val.m_value.object->find(member);
24707 const auto error_msg = (op ==
"op") ?
"operation" :
"operation '" + op +
"'";
24710 if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
24712 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have member '" + member +
"'"));
24716 if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
24718 JSON_THROW(parse_error::create(105, 0, error_msg +
" must have string member '" + member +
"'"));
24726 if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
24728 JSON_THROW(parse_error::create(104, 0,
"JSON patch must be an array of objects"));
24732 const auto op = get_value(
"op",
"op",
true).template get<std::string>();
24733 const auto path = get_value(op,
"path",
true).template get<std::string>();
24736 switch (get_op(op))
24738 case patch_operations::add:
24740 operation_add(ptr, get_value(
"add",
"value",
false));
24744 case patch_operations::remove:
24746 operation_remove(ptr);
24750 case patch_operations::replace:
24753 result.at(ptr) = get_value(
"replace",
"value",
false);
24757 case patch_operations::move:
24759 const auto from_path = get_value(
"move",
"from",
true).template get<std::string>();
24769 operation_remove(from_ptr);
24770 operation_add(ptr, v);
24774 case patch_operations::copy:
24776 const auto from_path = get_value(
"copy",
"from",
true).template get<std::string>();
24785 operation_add(ptr, v);
24789 case patch_operations::test:
24791 bool success =
false;
24796 success = (result.at(ptr) == get_value(
"test",
"value",
false));
24804 if (JSON_HEDLEY_UNLIKELY(!success))
24806 JSON_THROW(other_error::create(501,
"unsuccessful: " + val.dump()));
24816 JSON_THROW(parse_error::create(105, 0,
"operation value '" + op +
"' is invalid"));
24859 const std::string& path =
"")
24865 if (source == target)
24870 if (source.type() != target.type())
24875 {
"op",
"replace"}, {
"path", path}, {
"value", target}
24880 switch (source.type())
24882 case value_t::array:
24886 while (i < source.size() && i < target.size())
24889 auto temp_diff =
diff(source[i], target[i], path +
"/" + std::to_string(i));
24890 result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24899 while (i < source.size())
24903 result.insert(result.begin() + end_index,
object(
24906 {
"path", path +
"/" + std::to_string(i)}
24912 while (i < target.size())
24917 {
"path", path +
"/-"},
24918 {
"value", target[i]}
24926 case value_t::object:
24929 for (
auto it = source.cbegin(); it != source.cend(); ++it)
24932 const auto key = json_pointer::escape(it.key());
24934 if (target.find(it.key()) != target.end())
24937 auto temp_diff =
diff(it.value(), target[it.key()], path +
"/" + key);
24938 result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24943 result.push_back(
object(
24945 {
"op",
"remove"}, {
"path", path +
"/" + key}
24951 for (
auto it = target.cbegin(); it != target.cend(); ++it)
24953 if (source.find(it.key()) == source.end())
24956 const auto key = json_pointer::escape(it.key());
24959 {
"op",
"add"}, {
"path", path +
"/" + key},
24960 {
"value", it.value()}
24973 {
"op",
"replace"}, {
"path", path}, {
"value", target}
25035 if (apply_patch.is_object())
25041 for (
auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
25043 if (it.value().is_null())
25055 *
this = apply_patch;
25071 NLOHMANN_BASIC_JSON_TPL_DECLARATION
25072 std::string
to_string(
const NLOHMANN_BASIC_JSON_TPL& j)
25097 return nlohmann::detail::hash(j);
25105 struct less<::nlohmann::detail::value_t>
25111 bool operator()(nlohmann::detail::value_t lhs,
25112 nlohmann::detail::value_t rhs)
const noexcept
25114 return nlohmann::detail::operator<(lhs, rhs);
25119 #ifndef JSON_HAS_CPP_20
25128 is_nothrow_move_constructible<nlohmann::json>::value&&
25129 is_nothrow_move_assignable<nlohmann::json>::value
25152 JSON_HEDLEY_NON_NULL(1)
25153 inline
nlohmann::json operator "" _json(const
char* s, std::
size_t n)
25171 JSON_HEDLEY_NON_NULL(1)
25172 inline
nlohmann::json::json_pointer operator "" _json_pointer(const
char* s, std::
size_t n)
25181 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
25182 #pragma GCC diagnostic pop
25184 #if defined(__clang__)
25185 #pragma GCC diagnostic pop
25190 #undef JSON_INTERNAL_CATCH
25194 #undef JSON_HAS_CPP_14
25195 #undef JSON_HAS_CPP_17
25196 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
25197 #undef NLOHMANN_BASIC_JSON_TPL
25198 #undef JSON_EXPLICIT
25201 #undef JSON_HEDLEY_ALWAYS_INLINE
25202 #undef JSON_HEDLEY_ARM_VERSION
25203 #undef JSON_HEDLEY_ARM_VERSION_CHECK
25204 #undef JSON_HEDLEY_ARRAY_PARAM
25205 #undef JSON_HEDLEY_ASSUME
25206 #undef JSON_HEDLEY_BEGIN_C_DECLS
25207 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
25208 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
25209 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
25210 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
25211 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
25212 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
25213 #undef JSON_HEDLEY_CLANG_HAS_WARNING
25214 #undef JSON_HEDLEY_COMPCERT_VERSION
25215 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
25216 #undef JSON_HEDLEY_CONCAT
25217 #undef JSON_HEDLEY_CONCAT3
25218 #undef JSON_HEDLEY_CONCAT3_EX
25219 #undef JSON_HEDLEY_CONCAT_EX
25220 #undef JSON_HEDLEY_CONST
25221 #undef JSON_HEDLEY_CONSTEXPR
25222 #undef JSON_HEDLEY_CONST_CAST
25223 #undef JSON_HEDLEY_CPP_CAST
25224 #undef JSON_HEDLEY_CRAY_VERSION
25225 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
25226 #undef JSON_HEDLEY_C_DECL
25227 #undef JSON_HEDLEY_DEPRECATED
25228 #undef JSON_HEDLEY_DEPRECATED_FOR
25229 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
25230 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
25231 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
25232 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
25233 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
25234 #undef JSON_HEDLEY_DIAGNOSTIC_POP
25235 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
25236 #undef JSON_HEDLEY_DMC_VERSION
25237 #undef JSON_HEDLEY_DMC_VERSION_CHECK
25238 #undef JSON_HEDLEY_EMPTY_BASES
25239 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
25240 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
25241 #undef JSON_HEDLEY_END_C_DECLS
25242 #undef JSON_HEDLEY_FLAGS
25243 #undef JSON_HEDLEY_FLAGS_CAST
25244 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
25245 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
25246 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
25247 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
25248 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
25249 #undef JSON_HEDLEY_GCC_HAS_FEATURE
25250 #undef JSON_HEDLEY_GCC_HAS_WARNING
25251 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
25252 #undef JSON_HEDLEY_GCC_VERSION
25253 #undef JSON_HEDLEY_GCC_VERSION_CHECK
25254 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
25255 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
25256 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
25257 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
25258 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
25259 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
25260 #undef JSON_HEDLEY_GNUC_HAS_WARNING
25261 #undef JSON_HEDLEY_GNUC_VERSION
25262 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
25263 #undef JSON_HEDLEY_HAS_ATTRIBUTE
25264 #undef JSON_HEDLEY_HAS_BUILTIN
25265 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
25266 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
25267 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
25268 #undef JSON_HEDLEY_HAS_EXTENSION
25269 #undef JSON_HEDLEY_HAS_FEATURE
25270 #undef JSON_HEDLEY_HAS_WARNING
25271 #undef JSON_HEDLEY_IAR_VERSION
25272 #undef JSON_HEDLEY_IAR_VERSION_CHECK
25273 #undef JSON_HEDLEY_IBM_VERSION
25274 #undef JSON_HEDLEY_IBM_VERSION_CHECK
25275 #undef JSON_HEDLEY_IMPORT
25276 #undef JSON_HEDLEY_INLINE
25277 #undef JSON_HEDLEY_INTEL_VERSION
25278 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
25279 #undef JSON_HEDLEY_IS_CONSTANT
25280 #undef JSON_HEDLEY_IS_CONSTEXPR_
25281 #undef JSON_HEDLEY_LIKELY
25282 #undef JSON_HEDLEY_MALLOC
25283 #undef JSON_HEDLEY_MESSAGE
25284 #undef JSON_HEDLEY_MSVC_VERSION
25285 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
25286 #undef JSON_HEDLEY_NEVER_INLINE
25287 #undef JSON_HEDLEY_NON_NULL
25288 #undef JSON_HEDLEY_NO_ESCAPE
25289 #undef JSON_HEDLEY_NO_RETURN
25290 #undef JSON_HEDLEY_NO_THROW
25291 #undef JSON_HEDLEY_NULL
25292 #undef JSON_HEDLEY_PELLES_VERSION
25293 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
25294 #undef JSON_HEDLEY_PGI_VERSION
25295 #undef JSON_HEDLEY_PGI_VERSION_CHECK
25296 #undef JSON_HEDLEY_PREDICT
25297 #undef JSON_HEDLEY_PRINTF_FORMAT
25298 #undef JSON_HEDLEY_PRIVATE
25299 #undef JSON_HEDLEY_PUBLIC
25300 #undef JSON_HEDLEY_PURE
25301 #undef JSON_HEDLEY_REINTERPRET_CAST
25302 #undef JSON_HEDLEY_REQUIRE
25303 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
25304 #undef JSON_HEDLEY_REQUIRE_MSG
25305 #undef JSON_HEDLEY_RESTRICT
25307 #undef JSON_HEDLEY_SENTINEL
25308 #undef JSON_HEDLEY_STATIC_ASSERT
25309 #undef JSON_HEDLEY_STATIC_CAST
25310 #undef JSON_HEDLEY_STRINGIFY
25311 #undef JSON_HEDLEY_STRINGIFY_EX
25312 #undef JSON_HEDLEY_SUNPRO_VERSION
25313 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
25314 #undef JSON_HEDLEY_TINYC_VERSION
25315 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
25316 #undef JSON_HEDLEY_TI_ARMCL_VERSION
25317 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
25318 #undef JSON_HEDLEY_TI_CL2000_VERSION
25319 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
25320 #undef JSON_HEDLEY_TI_CL430_VERSION
25321 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
25322 #undef JSON_HEDLEY_TI_CL6X_VERSION
25323 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
25324 #undef JSON_HEDLEY_TI_CL7X_VERSION
25325 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
25326 #undef JSON_HEDLEY_TI_CLPRU_VERSION
25327 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
25328 #undef JSON_HEDLEY_TI_VERSION
25329 #undef JSON_HEDLEY_TI_VERSION_CHECK
25330 #undef JSON_HEDLEY_UNAVAILABLE
25331 #undef JSON_HEDLEY_UNLIKELY
25332 #undef JSON_HEDLEY_UNPREDICTABLE
25333 #undef JSON_HEDLEY_UNREACHABLE
25334 #undef JSON_HEDLEY_UNREACHABLE_RETURN
25335 #undef JSON_HEDLEY_VERSION
25336 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
25337 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
25338 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
25339 #undef JSON_HEDLEY_VERSION_ENCODE
25340 #undef JSON_HEDLEY_WARNING
25343 #undef JSON_HEDLEY_FALL_THROUGH
25347 #endif // INCLUDE_NLOHMANN_JSON_HPP_