MUQ  0.4.3
json.h
Go to the documentation of this file.
1 /*
2  __ _____ _____ _____
3  __| | __| | | | JSON for Modern C++
4 | | |__ | | | | | | version 3.9.1
5 |_____|_____|_____|_|___| https://github.com/nlohmann/json
6 
7 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
8 SPDX-License-Identifier: MIT
9 Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
10 
11 Permission is hereby granted, free of charge, to any person obtaining a copy
12 of this software and associated documentation files (the "Software"), to deal
13 in the Software without restriction, including without limitation the rights
14 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 copies of the Software, and to permit persons to whom the Software is
16 furnished to do so, subject to the following conditions:
17 
18 The above copyright notice and this permission notice shall be included in all
19 copies or substantial portions of the Software.
20 
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 SOFTWARE.
28 */
29 
30 #ifndef INCLUDE_NLOHMANN_JSON_HPP_
31 #define INCLUDE_NLOHMANN_JSON_HPP_
32 
33 #define NLOHMANN_JSON_VERSION_MAJOR 3
34 #define NLOHMANN_JSON_VERSION_MINOR 9
35 #define NLOHMANN_JSON_VERSION_PATCH 1
36 
37 #include <algorithm> // all_of, find, for_each
38 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
39 #include <functional> // hash, less
40 #include <initializer_list> // initializer_list
41 #include <iosfwd> // istream, ostream
42 #include <iterator> // random_access_iterator_tag
43 #include <memory> // unique_ptr
44 #include <numeric> // accumulate
45 #include <string> // string, stoi, to_string
46 #include <utility> // declval, forward, move, pair, swap
47 #include <vector> // vector
48 
49 // #include <nlohmann/adl_serializer.hpp>
50 
51 
52 #include <utility>
53 
54 // #include <nlohmann/detail/conversions/from_json.hpp>
55 
56 
57 #include <algorithm> // transform
58 #include <array> // array
59 #include <forward_list> // forward_list
60 #include <iterator> // inserter, front_inserter, end
61 #include <map> // map
62 #include <string> // string
63 #include <tuple> // tuple, make_tuple
64 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
65 #include <unordered_map> // unordered_map
66 #include <utility> // pair, declval
67 #include <valarray> // valarray
68 
69 // #include <nlohmann/detail/exceptions.hpp>
70 
71 
72 #include <exception> // exception
73 #include <stdexcept> // runtime_error
74 #include <string> // to_string
75 
76 // #include <nlohmann/detail/input/position_t.hpp>
77 
78 
79 #include <cstddef> // size_t
80 
81 namespace nlohmann
82 {
83 namespace detail
84 {
86 struct position_t
87 {
89  std::size_t chars_read_total = 0;
91  std::size_t chars_read_current_line = 0;
93  std::size_t lines_read = 0;
94 
96  constexpr operator size_t() const
97  {
98  return chars_read_total;
99  }
100 };
101 
102 } // namespace detail
103 } // namespace nlohmann
104 
105 // #include <nlohmann/detail/macro_scope.hpp>
106 
107 
108 #include <utility> // pair
109 // #include <nlohmann/thirdparty/hedley/hedley.hpp>
110 /* Hedley - https://nemequ.github.io/hedley
111  * Created by Evan Nemerson <evan@nemerson.com>
112  *
113  * To the extent possible under law, the author(s) have dedicated all
114  * copyright and related and neighboring rights to this software to
115  * the public domain worldwide. This software is distributed without
116  * any warranty.
117  *
118  * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
119  * SPDX-License-Identifier: CC0-1.0
120  */
121 
122 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 13)
123 #if defined(JSON_HEDLEY_VERSION)
124  #undef JSON_HEDLEY_VERSION
125 #endif
126 #define JSON_HEDLEY_VERSION 13
127 
128 #if defined(JSON_HEDLEY_STRINGIFY_EX)
129  #undef JSON_HEDLEY_STRINGIFY_EX
130 #endif
131 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
132 
133 #if defined(JSON_HEDLEY_STRINGIFY)
134  #undef JSON_HEDLEY_STRINGIFY
135 #endif
136 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
137 
138 #if defined(JSON_HEDLEY_CONCAT_EX)
139  #undef JSON_HEDLEY_CONCAT_EX
140 #endif
141 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
142 
143 #if defined(JSON_HEDLEY_CONCAT)
144  #undef JSON_HEDLEY_CONCAT
145 #endif
146 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
147 
148 #if defined(JSON_HEDLEY_CONCAT3_EX)
149  #undef JSON_HEDLEY_CONCAT3_EX
150 #endif
151 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
152 
153 #if defined(JSON_HEDLEY_CONCAT3)
154  #undef JSON_HEDLEY_CONCAT3
155 #endif
156 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
157 
158 #if defined(JSON_HEDLEY_VERSION_ENCODE)
159  #undef JSON_HEDLEY_VERSION_ENCODE
160 #endif
161 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
162 
163 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
164  #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
165 #endif
166 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
167 
168 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
169  #undef JSON_HEDLEY_VERSION_DECODE_MINOR
170 #endif
171 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
172 
173 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
174  #undef JSON_HEDLEY_VERSION_DECODE_REVISION
175 #endif
176 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
177 
178 #if defined(JSON_HEDLEY_GNUC_VERSION)
179  #undef JSON_HEDLEY_GNUC_VERSION
180 #endif
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)
185 #endif
186 
187 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
188  #undef JSON_HEDLEY_GNUC_VERSION_CHECK
189 #endif
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))
192 #else
193  #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
194 #endif
195 
196 #if defined(JSON_HEDLEY_MSVC_VERSION)
197  #undef JSON_HEDLEY_MSVC_VERSION
198 #endif
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)
205 #endif
206 
207 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
208  #undef JSON_HEDLEY_MSVC_VERSION_CHECK
209 #endif
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)))
216 #else
217  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
218 #endif
219 
220 #if defined(JSON_HEDLEY_INTEL_VERSION)
221  #undef JSON_HEDLEY_INTEL_VERSION
222 #endif
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)
227 #endif
228 
229 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
230  #undef JSON_HEDLEY_INTEL_VERSION_CHECK
231 #endif
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))
234 #else
235  #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
236 #endif
237 
238 #if defined(JSON_HEDLEY_PGI_VERSION)
239  #undef JSON_HEDLEY_PGI_VERSION
240 #endif
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__)
243 #endif
244 
245 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
246  #undef JSON_HEDLEY_PGI_VERSION_CHECK
247 #endif
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))
250 #else
251  #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
252 #endif
253 
254 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
255  #undef JSON_HEDLEY_SUNPRO_VERSION
256 #endif
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)
265 #endif
266 
267 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
268  #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
269 #endif
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))
272 #else
273  #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
274 #endif
275 
276 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
277  #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
278 #endif
279 #if defined(__EMSCRIPTEN__)
280  #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
281 #endif
282 
283 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
284  #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
285 #endif
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))
288 #else
289  #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
290 #endif
291 
292 #if defined(JSON_HEDLEY_ARM_VERSION)
293  #undef JSON_HEDLEY_ARM_VERSION
294 #endif
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)
299 #endif
300 
301 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
302  #undef JSON_HEDLEY_ARM_VERSION_CHECK
303 #endif
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))
306 #else
307  #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
308 #endif
309 
310 #if defined(JSON_HEDLEY_IBM_VERSION)
311  #undef JSON_HEDLEY_IBM_VERSION
312 #endif
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)
319 #endif
320 
321 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
322  #undef JSON_HEDLEY_IBM_VERSION_CHECK
323 #endif
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))
326 #else
327  #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
328 #endif
329 
330 #if defined(JSON_HEDLEY_TI_VERSION)
331  #undef JSON_HEDLEY_TI_VERSION
332 #endif
333 #if \
334  defined(__TI_COMPILER_VERSION__) && \
335  ( \
336  defined(__TMS470__) || defined(__TI_ARM__) || \
337  defined(__MSP430__) || \
338  defined(__TMS320C2000__) \
339  )
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))
342 #endif
343 #endif
344 
345 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
346  #undef JSON_HEDLEY_TI_VERSION_CHECK
347 #endif
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))
350 #else
351  #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
352 #endif
353 
354 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
355  #undef JSON_HEDLEY_TI_CL2000_VERSION
356 #endif
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))
359 #endif
360 
361 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
362  #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
363 #endif
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))
366 #else
367  #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
368 #endif
369 
370 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
371  #undef JSON_HEDLEY_TI_CL430_VERSION
372 #endif
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))
375 #endif
376 
377 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
378  #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
379 #endif
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))
382 #else
383  #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
384 #endif
385 
386 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
387  #undef JSON_HEDLEY_TI_ARMCL_VERSION
388 #endif
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))
391 #endif
392 
393 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
394  #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
395 #endif
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))
398 #else
399  #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
400 #endif
401 
402 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
403  #undef JSON_HEDLEY_TI_CL6X_VERSION
404 #endif
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))
407 #endif
408 
409 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
410  #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
411 #endif
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))
414 #else
415  #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
416 #endif
417 
418 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
419  #undef JSON_HEDLEY_TI_CL7X_VERSION
420 #endif
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))
423 #endif
424 
425 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
426  #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
427 #endif
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))
430 #else
431  #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
432 #endif
433 
434 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
435  #undef JSON_HEDLEY_TI_CLPRU_VERSION
436 #endif
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))
439 #endif
440 
441 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
442  #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
443 #endif
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))
446 #else
447  #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
448 #endif
449 
450 #if defined(JSON_HEDLEY_CRAY_VERSION)
451  #undef JSON_HEDLEY_CRAY_VERSION
452 #endif
453 #if defined(_CRAYC)
454  #if defined(_RELEASE_PATCHLEVEL)
455  #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
456  #else
457  #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
458  #endif
459 #endif
460 
461 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
462  #undef JSON_HEDLEY_CRAY_VERSION_CHECK
463 #endif
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))
466 #else
467  #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
468 #endif
469 
470 #if defined(JSON_HEDLEY_IAR_VERSION)
471  #undef JSON_HEDLEY_IAR_VERSION
472 #endif
473 #if defined(__IAR_SYSTEMS_ICC__)
474  #if __VER__ > 1000
475  #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
476  #else
477  #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
478  #endif
479 #endif
480 
481 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
482  #undef JSON_HEDLEY_IAR_VERSION_CHECK
483 #endif
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))
486 #else
487  #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
488 #endif
489 
490 #if defined(JSON_HEDLEY_TINYC_VERSION)
491  #undef JSON_HEDLEY_TINYC_VERSION
492 #endif
493 #if defined(__TINYC__)
494  #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
495 #endif
496 
497 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
498  #undef JSON_HEDLEY_TINYC_VERSION_CHECK
499 #endif
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))
502 #else
503  #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
504 #endif
505 
506 #if defined(JSON_HEDLEY_DMC_VERSION)
507  #undef JSON_HEDLEY_DMC_VERSION
508 #endif
509 #if defined(__DMC__)
510  #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
511 #endif
512 
513 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
514  #undef JSON_HEDLEY_DMC_VERSION_CHECK
515 #endif
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))
518 #else
519  #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
520 #endif
521 
522 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
523  #undef JSON_HEDLEY_COMPCERT_VERSION
524 #endif
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)
527 #endif
528 
529 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
530  #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
531 #endif
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))
534 #else
535  #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
536 #endif
537 
538 #if defined(JSON_HEDLEY_PELLES_VERSION)
539  #undef JSON_HEDLEY_PELLES_VERSION
540 #endif
541 #if defined(__POCC__)
542  #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
543 #endif
544 
545 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
546  #undef JSON_HEDLEY_PELLES_VERSION_CHECK
547 #endif
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))
550 #else
551  #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
552 #endif
553 
554 #if defined(JSON_HEDLEY_GCC_VERSION)
555  #undef JSON_HEDLEY_GCC_VERSION
556 #endif
557 #if \
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
572 #endif
573 
574 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
575  #undef JSON_HEDLEY_GCC_VERSION_CHECK
576 #endif
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))
579 #else
580  #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
581 #endif
582 
583 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
584  #undef JSON_HEDLEY_HAS_ATTRIBUTE
585 #endif
586 #if defined(__has_attribute)
587  #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
588 #else
589  #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
590 #endif
591 
592 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
593  #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
594 #endif
595 #if defined(__has_attribute)
596  #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
597 #else
598  #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
599 #endif
600 
601 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
602  #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
603 #endif
604 #if defined(__has_attribute)
605  #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
606 #else
607  #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
608 #endif
609 
610 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
611  #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
612 #endif
613 #if \
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)
618 #else
619  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
620 #endif
621 
622 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
623  #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
624 #endif
625 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
626  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
627 #elif \
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)
633 #else
634  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
635 #endif
636 
637 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
638  #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
639 #endif
640 #if defined(__has_cpp_attribute) && defined(__cplusplus)
641  #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
642 #else
643  #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
644 #endif
645 
646 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
647  #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
648 #endif
649 #if defined(__has_cpp_attribute) && defined(__cplusplus)
650  #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
651 #else
652  #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
653 #endif
654 
655 #if defined(JSON_HEDLEY_HAS_BUILTIN)
656  #undef JSON_HEDLEY_HAS_BUILTIN
657 #endif
658 #if defined(__has_builtin)
659  #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
660 #else
661  #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
662 #endif
663 
664 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
665  #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
666 #endif
667 #if defined(__has_builtin)
668  #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
669 #else
670  #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
671 #endif
672 
673 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
674  #undef JSON_HEDLEY_GCC_HAS_BUILTIN
675 #endif
676 #if defined(__has_builtin)
677  #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
678 #else
679  #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
680 #endif
681 
682 #if defined(JSON_HEDLEY_HAS_FEATURE)
683  #undef JSON_HEDLEY_HAS_FEATURE
684 #endif
685 #if defined(__has_feature)
686  #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
687 #else
688  #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
689 #endif
690 
691 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
692  #undef JSON_HEDLEY_GNUC_HAS_FEATURE
693 #endif
694 #if defined(__has_feature)
695  #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
696 #else
697  #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
698 #endif
699 
700 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
701  #undef JSON_HEDLEY_GCC_HAS_FEATURE
702 #endif
703 #if defined(__has_feature)
704  #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
705 #else
706  #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
707 #endif
708 
709 #if defined(JSON_HEDLEY_HAS_EXTENSION)
710  #undef JSON_HEDLEY_HAS_EXTENSION
711 #endif
712 #if defined(__has_extension)
713  #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
714 #else
715  #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
716 #endif
717 
718 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
719  #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
720 #endif
721 #if defined(__has_extension)
722  #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
723 #else
724  #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
725 #endif
726 
727 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
728  #undef JSON_HEDLEY_GCC_HAS_EXTENSION
729 #endif
730 #if defined(__has_extension)
731  #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
732 #else
733  #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
734 #endif
735 
736 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
737  #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
738 #endif
739 #if defined(__has_declspec_attribute)
740  #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
741 #else
742  #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
743 #endif
744 
745 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
746  #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
747 #endif
748 #if defined(__has_declspec_attribute)
749  #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
750 #else
751  #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
752 #endif
753 
754 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
755  #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
756 #endif
757 #if defined(__has_declspec_attribute)
758  #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
759 #else
760  #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
761 #endif
762 
763 #if defined(JSON_HEDLEY_HAS_WARNING)
764  #undef JSON_HEDLEY_HAS_WARNING
765 #endif
766 #if defined(__has_warning)
767  #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
768 #else
769  #define JSON_HEDLEY_HAS_WARNING(warning) (0)
770 #endif
771 
772 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
773  #undef JSON_HEDLEY_GNUC_HAS_WARNING
774 #endif
775 #if defined(__has_warning)
776  #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
777 #else
778  #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
779 #endif
780 
781 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
782  #undef JSON_HEDLEY_GCC_HAS_WARNING
783 #endif
784 #if defined(__has_warning)
785  #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
786 #else
787  #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
788 #endif
789 
790 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
791  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
792 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
793  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
794 #endif
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\"") \
802  xpr \
803  JSON_HEDLEY_DIAGNOSTIC_POP
804 # else
805 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
806  JSON_HEDLEY_DIAGNOSTIC_PUSH \
807  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
808  xpr \
809  JSON_HEDLEY_DIAGNOSTIC_POP
810 # endif
811 # endif
812 #endif
813 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
814  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
815 #endif
816 
817 #if defined(JSON_HEDLEY_CONST_CAST)
818  #undef JSON_HEDLEY_CONST_CAST
819 #endif
820 #if defined(__cplusplus)
821 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
822 #elif \
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 \
829  ((T) (expr)); \
830  JSON_HEDLEY_DIAGNOSTIC_POP \
831  }))
832 #else
833 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
834 #endif
835 
836 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
837  #undef JSON_HEDLEY_REINTERPRET_CAST
838 #endif
839 #if defined(__cplusplus)
840  #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
841 #else
842  #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
843 #endif
844 
845 #if defined(JSON_HEDLEY_STATIC_CAST)
846  #undef JSON_HEDLEY_STATIC_CAST
847 #endif
848 #if defined(__cplusplus)
849  #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
850 #else
851  #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
852 #endif
853 
854 #if defined(JSON_HEDLEY_CPP_CAST)
855  #undef JSON_HEDLEY_CPP_CAST
856 #endif
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\"") \
862  ((T) (expr)) \
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 \
869 # else
870 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
871 # endif
872 #else
873 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
874 #endif
875 
876 #if \
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)
898 #else
899  #define JSON_HEDLEY_PRAGMA(value)
900 #endif
901 
902 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
903  #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
904 #endif
905 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
906  #undef JSON_HEDLEY_DIAGNOSTIC_POP
907 #endif
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")
923 #elif \
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)")
935 #else
936  #define JSON_HEDLEY_DIAGNOSTIC_PUSH
937  #define JSON_HEDLEY_DIAGNOSTIC_POP
938 #endif
939 
940 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
941  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
942 #endif
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))
953 #elif \
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)")
974 #else
975  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
976 #endif
977 
978 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
979  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
980 #endif
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))
991 #elif \
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")
1001 #else
1002  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1003 #endif
1004 
1005 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1006  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1007 #endif
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)")
1020 #elif \
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")
1027 #else
1028  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1029 #endif
1030 
1031 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1032  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1033 #endif
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\"")
1040 #else
1041  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1042 #endif
1043 
1044 #if defined(JSON_HEDLEY_DEPRECATED)
1045  #undef JSON_HEDLEY_DEPRECATED
1046 #endif
1047 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1048  #undef JSON_HEDLEY_DEPRECATED_FOR
1049 #endif
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)]])
1056 #elif \
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)))
1070 #elif \
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__))
1087 #elif \
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")
1095 #else
1096  #define JSON_HEDLEY_DEPRECATED(since)
1097  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1098 #endif
1099 
1100 #if defined(JSON_HEDLEY_UNAVAILABLE)
1101  #undef JSON_HEDLEY_UNAVAILABLE
1102 #endif
1103 #if \
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)))
1108 #else
1109  #define JSON_HEDLEY_UNAVAILABLE(available_since)
1110 #endif
1111 
1112 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1113  #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1114 #endif
1115 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1116  #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1117 #endif
1118 #if (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1119  #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1120  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1121 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1122  #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1123  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1124 #elif \
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 JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1142  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1143 #elif defined(_Check_return_) /* SAL */
1144  #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1145  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1146 #else
1147  #define JSON_HEDLEY_WARN_UNUSED_RESULT
1148  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1149 #endif
1150 
1151 #if defined(JSON_HEDLEY_SENTINEL)
1152  #undef JSON_HEDLEY_SENTINEL
1153 #endif
1154 #if \
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)))
1160 #else
1161  #define JSON_HEDLEY_SENTINEL(position)
1162 #endif
1163 
1164 #if defined(JSON_HEDLEY_NO_RETURN)
1165  #undef JSON_HEDLEY_NO_RETURN
1166 #endif
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]])
1175 #elif \
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)
1203 #else
1204  #define JSON_HEDLEY_NO_RETURN
1205 #endif
1206 
1207 #if defined(JSON_HEDLEY_NO_ESCAPE)
1208  #undef JSON_HEDLEY_NO_ESCAPE
1209 #endif
1210 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1211  #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1212 #else
1213  #define JSON_HEDLEY_NO_ESCAPE
1214 #endif
1215 
1216 #if defined(JSON_HEDLEY_UNREACHABLE)
1217  #undef JSON_HEDLEY_UNREACHABLE
1218 #endif
1219 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1220  #undef JSON_HEDLEY_UNREACHABLE_RETURN
1221 #endif
1222 #if defined(JSON_HEDLEY_ASSUME)
1223  #undef JSON_HEDLEY_ASSUME
1224 #endif
1225 #if \
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)
1231 #elif \
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)
1236  #else
1237  #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1238  #endif
1239 #endif
1240 #if \
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)
1249 #endif
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)))
1253  #else
1254  #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1255  #endif
1256 #endif
1257 #if defined(JSON_HEDLEY_UNREACHABLE)
1258  #if \
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))
1262  #else
1263  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1264  #endif
1265 #else
1266  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1267 #endif
1268 #if !defined(JSON_HEDLEY_UNREACHABLE)
1269  #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1270 #endif
1271 
1272 JSON_HEDLEY_DIAGNOSTIC_PUSH
1273 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1274  #pragma clang diagnostic ignored "-Wpedantic"
1275 #endif
1276 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1277  #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1278 #endif
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"
1284  #endif
1285 #endif
1286 #if defined(JSON_HEDLEY_NON_NULL)
1287  #undef JSON_HEDLEY_NON_NULL
1288 #endif
1289 #if \
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__)))
1295 #else
1296  #define JSON_HEDLEY_NON_NULL(...)
1297 #endif
1298 JSON_HEDLEY_DIAGNOSTIC_POP
1299 
1300 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1301  #undef JSON_HEDLEY_PRINTF_FORMAT
1302 #endif
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)))
1307 #elif \
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))
1327 #else
1328  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1329 #endif
1330 
1331 #if defined(JSON_HEDLEY_CONSTEXPR)
1332  #undef JSON_HEDLEY_CONSTEXPR
1333 #endif
1334 #if defined(__cplusplus)
1335  #if __cplusplus >= 201103L
1336  #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1337  #endif
1338 #endif
1339 #if !defined(JSON_HEDLEY_CONSTEXPR)
1340  #define JSON_HEDLEY_CONSTEXPR
1341 #endif
1342 
1343 #if defined(JSON_HEDLEY_PREDICT)
1344  #undef JSON_HEDLEY_PREDICT
1345 #endif
1346 #if defined(JSON_HEDLEY_LIKELY)
1347  #undef JSON_HEDLEY_LIKELY
1348 #endif
1349 #if defined(JSON_HEDLEY_UNLIKELY)
1350  #undef JSON_HEDLEY_UNLIKELY
1351 #endif
1352 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1353  #undef JSON_HEDLEY_UNPREDICTABLE
1354 #endif
1355 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1356  #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1357 #endif
1358 #if \
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 )
1366 #elif \
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) \
1385  (__extension__ ({ \
1386  double hedley_probability_ = (probability); \
1387  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1388  }))
1389 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1390  (__extension__ ({ \
1391  double hedley_probability_ = (probability); \
1392  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1393  }))
1394 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1395 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1396 #else
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))
1402 #endif
1403 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1404  #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1405 #endif
1406 
1407 #if defined(JSON_HEDLEY_MALLOC)
1408  #undef JSON_HEDLEY_MALLOC
1409 #endif
1410 #if \
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)
1433 #else
1434  #define JSON_HEDLEY_MALLOC
1435 #endif
1436 
1437 #if defined(JSON_HEDLEY_PURE)
1438  #undef JSON_HEDLEY_PURE
1439 #endif
1440 #if \
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) && \
1463  ( \
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) \
1467  )
1468 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1469 #else
1470 # define JSON_HEDLEY_PURE
1471 #endif
1472 
1473 #if defined(JSON_HEDLEY_CONST)
1474  #undef JSON_HEDLEY_CONST
1475 #endif
1476 #if \
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__))
1496 #elif \
1497  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1498  #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1499 #else
1500  #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1501 #endif
1502 
1503 #if defined(JSON_HEDLEY_RESTRICT)
1504  #undef JSON_HEDLEY_RESTRICT
1505 #endif
1506 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1507  #define JSON_HEDLEY_RESTRICT restrict
1508 #elif \
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) || \
1521  defined(__clang__)
1522  #define JSON_HEDLEY_RESTRICT __restrict
1523 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1524  #define JSON_HEDLEY_RESTRICT _Restrict
1525 #else
1526  #define JSON_HEDLEY_RESTRICT
1527 #endif
1528 
1529 #if defined(JSON_HEDLEY_INLINE)
1530  #undef JSON_HEDLEY_INLINE
1531 #endif
1532 #if \
1533  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1534  (defined(__cplusplus) && (__cplusplus >= 199711L))
1535  #define JSON_HEDLEY_INLINE inline
1536 #elif \
1537  defined(JSON_HEDLEY_GCC_VERSION) || \
1538  JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1539  #define JSON_HEDLEY_INLINE __inline__
1540 #elif \
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
1550 #else
1551  #define JSON_HEDLEY_INLINE
1552 #endif
1553 
1554 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1555  #undef JSON_HEDLEY_ALWAYS_INLINE
1556 #endif
1557 #if \
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) && \
1579  ( \
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) \
1586  )
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")
1590 #else
1591 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1592 #endif
1593 
1594 #if defined(JSON_HEDLEY_NEVER_INLINE)
1595  #undef JSON_HEDLEY_NEVER_INLINE
1596 #endif
1597 #if \
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)
1628 #else
1629  #define JSON_HEDLEY_NEVER_INLINE
1630 #endif
1631 
1632 #if defined(JSON_HEDLEY_PRIVATE)
1633  #undef JSON_HEDLEY_PRIVATE
1634 #endif
1635 #if defined(JSON_HEDLEY_PUBLIC)
1636  #undef JSON_HEDLEY_PUBLIC
1637 #endif
1638 #if defined(JSON_HEDLEY_IMPORT)
1639  #undef JSON_HEDLEY_IMPORT
1640 #endif
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)
1645 #else
1646 # if \
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) || \
1653  ( \
1654  defined(__TI_EABI__) && \
1655  ( \
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) \
1658  ) \
1659  )
1660 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1661 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1662 # else
1663 # define JSON_HEDLEY_PRIVATE
1664 # define JSON_HEDLEY_PUBLIC
1665 # endif
1666 # define JSON_HEDLEY_IMPORT extern
1667 #endif
1668 
1669 #if defined(JSON_HEDLEY_NO_THROW)
1670  #undef JSON_HEDLEY_NO_THROW
1671 #endif
1672 #if \
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__))
1677 #elif \
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)
1681 #else
1682  #define JSON_HEDLEY_NO_THROW
1683 #endif
1684 
1685 #if defined(JSON_HEDLEY_FALL_THROUGH)
1686  #undef JSON_HEDLEY_FALL_THROUGH
1687 #endif
1688 #if \
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) /* SAL */
1697  #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1698 #else
1699  #define JSON_HEDLEY_FALL_THROUGH
1700 #endif
1701 
1702 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1703  #undef JSON_HEDLEY_RETURNS_NON_NULL
1704 #endif
1705 #if \
1706  JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1707  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
1708  #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1709 #elif defined(_Ret_notnull_) /* SAL */
1710  #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1711 #else
1712  #define JSON_HEDLEY_RETURNS_NON_NULL
1713 #endif
1714 
1715 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1716  #undef JSON_HEDLEY_ARRAY_PARAM
1717 #endif
1718 #if \
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)
1725 #else
1726  #define JSON_HEDLEY_ARRAY_PARAM(name)
1727 #endif
1728 
1729 #if defined(JSON_HEDLEY_IS_CONSTANT)
1730  #undef JSON_HEDLEY_IS_CONSTANT
1731 #endif
1732 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1733  #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1734 #endif
1735 /* JSON_HEDLEY_IS_CONSTEXPR_ is for
1736  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
1737 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1738  #undef JSON_HEDLEY_IS_CONSTEXPR_
1739 #endif
1740 #if \
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)
1751 #endif
1752 #if !defined(__cplusplus)
1753 # if \
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*)
1763 #else
1764  #include <stdint.h>
1765  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1766 #endif
1767 # elif \
1768  ( \
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)
1780 #else
1781  #include <stdint.h>
1782  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1783 #endif
1784 # elif \
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) || \
1794  defined(__clang__)
1795 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1796  sizeof(void) != \
1797  sizeof(*( \
1798  1 ? \
1799  ((void*) ((expr) * 0L) ) : \
1800 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1801  ) \
1802  ) \
1803  )
1804 # endif
1805 #endif
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)
1809  #endif
1810  #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1811 #else
1812  #if !defined(JSON_HEDLEY_IS_CONSTANT)
1813  #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1814  #endif
1815  #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1816 #endif
1817 
1818 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1819  #undef JSON_HEDLEY_BEGIN_C_DECLS
1820 #endif
1821 #if defined(JSON_HEDLEY_END_C_DECLS)
1822  #undef JSON_HEDLEY_END_C_DECLS
1823 #endif
1824 #if defined(JSON_HEDLEY_C_DECL)
1825  #undef JSON_HEDLEY_C_DECL
1826 #endif
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"
1831 #else
1832  #define JSON_HEDLEY_BEGIN_C_DECLS
1833  #define JSON_HEDLEY_END_C_DECLS
1834  #define JSON_HEDLEY_C_DECL
1835 #endif
1836 
1837 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1838  #undef JSON_HEDLEY_STATIC_ASSERT
1839 #endif
1840 #if \
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) \
1847  )
1848 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1849 #elif \
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))
1853 #else
1854 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1855 #endif
1856 
1857 #if defined(JSON_HEDLEY_NULL)
1858  #undef JSON_HEDLEY_NULL
1859 #endif
1860 #if defined(__cplusplus)
1861  #if __cplusplus >= 201103L
1862  #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1863  #elif defined(NULL)
1864  #define JSON_HEDLEY_NULL NULL
1865  #else
1866  #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1867  #endif
1868 #elif defined(NULL)
1869  #define JSON_HEDLEY_NULL NULL
1870 #else
1871  #define JSON_HEDLEY_NULL ((void*) 0)
1872 #endif
1873 
1874 #if defined(JSON_HEDLEY_MESSAGE)
1875  #undef JSON_HEDLEY_MESSAGE
1876 #endif
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
1883 #elif \
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))
1893 #else
1894 # define JSON_HEDLEY_MESSAGE(msg)
1895 #endif
1896 
1897 #if defined(JSON_HEDLEY_WARNING)
1898  #undef JSON_HEDLEY_WARNING
1899 #endif
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
1906 #elif \
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))
1913 #else
1914 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1915 #endif
1916 
1917 #if defined(JSON_HEDLEY_REQUIRE)
1918  #undef JSON_HEDLEY_REQUIRE
1919 #endif
1920 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1921  #undef JSON_HEDLEY_REQUIRE_MSG
1922 #endif
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
1935 # else
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")))
1938 # endif
1939 #else
1940 # define JSON_HEDLEY_REQUIRE(expr)
1941 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1942 #endif
1943 
1944 #if defined(JSON_HEDLEY_FLAGS)
1945  #undef JSON_HEDLEY_FLAGS
1946 #endif
1947 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1948  #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1949 #endif
1950 
1951 #if defined(JSON_HEDLEY_FLAGS_CAST)
1952  #undef JSON_HEDLEY_FLAGS_CAST
1953 #endif
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)") \
1958  ((T) (expr)); \
1959  JSON_HEDLEY_DIAGNOSTIC_POP \
1960  }))
1961 #else
1962 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1963 #endif
1964 
1965 #if defined(JSON_HEDLEY_EMPTY_BASES)
1966  #undef JSON_HEDLEY_EMPTY_BASES
1967 #endif
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)
1970 #else
1971  #define JSON_HEDLEY_EMPTY_BASES
1972 #endif
1973 
1974 /* Remaining macros are deprecated. */
1975 
1976 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1977  #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1978 #endif
1979 #if defined(__clang__)
1980  #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1981 #else
1982  #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1983 #endif
1984 
1985 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1986  #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1987 #endif
1988 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1989 
1990 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1991  #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1992 #endif
1993 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1994 
1995 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1996  #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1997 #endif
1998 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
1999 
2000 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2001  #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2002 #endif
2003 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2004 
2005 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2006  #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2007 #endif
2008 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2009 
2010 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2011  #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2012 #endif
2013 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2014 
2015 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2016  #undef JSON_HEDLEY_CLANG_HAS_WARNING
2017 #endif
2018 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2019 
2020 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2021 
2022 
2023 // This file contains all internal macro definitions
2024 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2025 
2026 // exclude unsupported compilers
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"
2031  #endif
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"
2035  #endif
2036  #endif
2037 #endif
2038 
2039 // C++ language standard detection
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
2049 #endif
2050 
2051 // disable float-equal warnings on GCC/clang
2052 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
2053  #pragma GCC diagnostic push
2054  #pragma GCC diagnostic ignored "-Wfloat-equal"
2055 #endif
2056 
2057 // disable documentation warnings on clang
2058 #if defined(__clang__)
2059  #pragma GCC diagnostic push
2060  #pragma GCC diagnostic ignored "-Wdocumentation"
2061 #endif
2062 
2063 // allow to disable exceptions
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)
2069 #else
2070  #include <cstdlib>
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)
2075 #endif
2076 
2077 // override exception macros
2078 #if defined(JSON_THROW_USER)
2079  #undef JSON_THROW
2080  #define JSON_THROW JSON_THROW_USER
2081 #endif
2082 #if defined(JSON_TRY_USER)
2083  #undef JSON_TRY
2084  #define JSON_TRY JSON_TRY_USER
2085 #endif
2086 #if defined(JSON_CATCH_USER)
2087  #undef JSON_CATCH
2088  #define JSON_CATCH JSON_CATCH_USER
2089  #undef JSON_INTERNAL_CATCH
2090  #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2091 #endif
2092 #if defined(JSON_INTERNAL_CATCH_USER)
2093  #undef JSON_INTERNAL_CATCH
2094  #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2095 #endif
2096 
2097 // allow to override assert
2098 #if !defined(JSON_ASSERT)
2099  #include <cassert> // assert
2100  #define JSON_ASSERT(x) assert(x)
2101 #endif
2102 
2108 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2109  template<typename BasicJsonType> \
2110  inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2111  { \
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 \
2116  { \
2117  return ej_pair.first == e; \
2118  }); \
2119  j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2120  } \
2121  template<typename BasicJsonType> \
2122  inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2123  { \
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 \
2128  { \
2129  return ej_pair.second == j; \
2130  }); \
2131  e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2132  }
2133 
2134 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2135 // may be removed in the future once the class is split.
2136 
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, \
2144  class BinaryType>
2145 
2146 #define NLOHMANN_BASIC_JSON_TPL \
2147  basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2148  NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2149  AllocatorType, JSONSerializer, BinaryType>
2150 
2151 // Macros to simplify conversion from/to types
2152 
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)
2283 
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);
2286 
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__)) }
2295 
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__)) }
2304 
2305 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2306  #define JSON_USE_IMPLICIT_CONVERSIONS 1
2307 #endif
2308 
2309 #if JSON_USE_IMPLICIT_CONVERSIONS
2310  #define JSON_EXPLICIT
2311 #else
2312  #define JSON_EXPLICIT explicit
2313 #endif
2314 
2315 
2316 namespace nlohmann
2317 {
2318 namespace detail
2319 {
2321 // exceptions //
2323 
2352 class exception : public std::exception
2353 {
2354  public:
2356  JSON_HEDLEY_RETURNS_NON_NULL
2357  const char* what() const noexcept override
2358  {
2359  return m.what();
2360  }
2361 
2363  const int id;
2364 
2365  protected:
2367  exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
2368 
2369  static std::string name(const std::string& ename, int id_)
2370  {
2371  return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
2372  }
2373 
2374  private:
2376  std::runtime_error m;
2377 };
2378 
2424 class parse_error : public exception
2425 {
2426  public:
2436  static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
2437  {
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());
2441  }
2442 
2443  static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
2444  {
2445  std::string w = exception::name("parse_error", id_) + "parse error" +
2446  (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
2447  ": " + what_arg;
2448  return parse_error(id_, byte_, w.c_str());
2449  }
2450 
2460  const std::size_t byte;
2461 
2462  private:
2463  parse_error(int id_, std::size_t byte_, const char* what_arg)
2464  : exception(id_, what_arg), byte(byte_) {}
2465 
2466  static std::string position_string(const position_t& pos)
2467  {
2468  return " at line " + std::to_string(pos.lines_read + 1) +
2469  ", column " + std::to_string(pos.chars_read_current_line);
2470  }
2471 };
2472 
2511 {
2512  public:
2513  static invalid_iterator create(int id_, const std::string& what_arg)
2514  {
2515  std::string w = exception::name("invalid_iterator", id_) + what_arg;
2516  return invalid_iterator(id_, w.c_str());
2517  }
2518 
2519  private:
2521  invalid_iterator(int id_, const char* what_arg)
2522  : exception(id_, what_arg) {}
2523 };
2524 
2564 class type_error : public exception
2565 {
2566  public:
2567  static type_error create(int id_, const std::string& what_arg)
2568  {
2569  std::string w = exception::name("type_error", id_) + what_arg;
2570  return type_error(id_, w.c_str());
2571  }
2572 
2573  private:
2575  type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2576 };
2577 
2611 class out_of_range : public exception
2612 {
2613  public:
2614  static out_of_range create(int id_, const std::string& what_arg)
2615  {
2616  std::string w = exception::name("out_of_range", id_) + what_arg;
2617  return out_of_range(id_, w.c_str());
2618  }
2619 
2620  private:
2622  out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
2623 };
2624 
2649 class other_error : public exception
2650 {
2651  public:
2652  static other_error create(int id_, const std::string& what_arg)
2653  {
2654  std::string w = exception::name("other_error", id_) + what_arg;
2655  return other_error(id_, w.c_str());
2656  }
2657 
2658  private:
2660  other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2661 };
2662 } // namespace detail
2663 } // namespace nlohmann
2664 
2665 // #include <nlohmann/detail/macro_scope.hpp>
2666 
2667 // #include <nlohmann/detail/meta/cpp_future.hpp>
2668 
2669 
2670 #include <cstddef> // size_t
2671 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
2672 
2673 namespace nlohmann
2674 {
2675 namespace detail
2676 {
2677 // alias templates to reduce boilerplate
2678 template<bool B, typename T = void>
2679 using enable_if_t = typename std::enable_if<B, T>::type;
2680 
2681 template<typename T>
2682 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
2683 
2684 // implementation of C++14 index_sequence and affiliates
2685 // source: https://stackoverflow.com/a/32223343
2686 template<std::size_t... Ints>
2688 {
2690  using value_type = std::size_t;
2691  static constexpr std::size_t size() noexcept
2692  {
2693  return sizeof...(Ints);
2694  }
2695 };
2696 
2697 template<class Sequence1, class Sequence2>
2699 
2700 template<std::size_t... I1, std::size_t... I2>
2702  : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
2703 
2704 template<std::size_t N>
2706  : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
2707  typename make_index_sequence < N - N / 2 >::type > {};
2708 
2709 template<> struct make_index_sequence<0> : index_sequence<> {};
2710 template<> struct make_index_sequence<1> : index_sequence<0> {};
2711 
2712 template<typename... Ts>
2714 
2715 // dispatch utility (taken from ranges-v3)
2716 template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
2717 template<> struct priority_tag<0> {};
2718 
2719 // taken from ranges-v3
2720 template<typename T>
2722 {
2723  static constexpr T value{};
2724 };
2725 
2726 template<typename T>
2727 constexpr T static_const<T>::value;
2728 } // namespace detail
2729 } // namespace nlohmann
2730 
2731 // #include <nlohmann/detail/meta/type_traits.hpp>
2732 
2733 
2734 #include <limits> // numeric_limits
2735 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
2736 #include <utility> // declval
2737 
2738 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
2739 
2740 
2741 #include <iterator> // random_access_iterator_tag
2742 
2743 // #include <nlohmann/detail/meta/void_t.hpp>
2744 
2745 
2746 namespace nlohmann
2747 {
2748 namespace detail
2749 {
2750 template<typename ...Ts> struct make_void
2751 {
2752  using type = void;
2753 };
2754 template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
2755 } // namespace detail
2756 } // namespace nlohmann
2757 
2758 // #include <nlohmann/detail/meta/cpp_future.hpp>
2759 
2760 
2761 namespace nlohmann
2762 {
2763 namespace detail
2764 {
2765 template<typename It, typename = void>
2766 struct iterator_types {};
2767 
2768 template<typename It>
2770  It,
2771  void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
2772  typename It::reference, typename It::iterator_category >>
2773 {
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;
2779 };
2780 
2781 // This is required as some compilers implement std::iterator_traits in a way that
2782 // doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
2783 template<typename T, typename = void>
2785 {
2786 };
2787 
2788 template<typename T>
2789 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
2790  : iterator_types<T>
2791 {
2792 };
2793 
2794 template<typename T>
2796 {
2797  using iterator_category = std::random_access_iterator_tag;
2798  using value_type = T;
2799  using difference_type = ptrdiff_t;
2800  using pointer = T*;
2801  using reference = T&;
2802 };
2803 } // namespace detail
2804 } // namespace nlohmann
2805 
2806 // #include <nlohmann/detail/macro_scope.hpp>
2807 
2808 // #include <nlohmann/detail/meta/cpp_future.hpp>
2809 
2810 // #include <nlohmann/detail/meta/detected.hpp>
2811 
2812 
2813 #include <type_traits>
2814 
2815 // #include <nlohmann/detail/meta/void_t.hpp>
2816 
2817 
2818 // https://en.cppreference.com/w/cpp/experimental/is_detected
2819 namespace nlohmann
2820 {
2821 namespace detail
2822 {
2823 struct nonesuch
2824 {
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;
2831 };
2832 
2833 template<class Default,
2834  class AlwaysVoid,
2835  template<class...> class Op,
2836  class... Args>
2837 struct detector
2838 {
2839  using value_t = std::false_type;
2840  using type = Default;
2841 };
2842 
2843 template<class Default, template<class...> class Op, class... Args>
2844 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2845 {
2846  using value_t = std::true_type;
2847  using type = Op<Args...>;
2848 };
2849 
2850 template<template<class...> class Op, class... Args>
2851 using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
2852 
2853 template<template<class...> class Op, class... Args>
2854 using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
2855 
2856 template<class Default, template<class...> class Op, class... Args>
2857 using detected_or = detector<Default, void, Op, Args...>;
2858 
2859 template<class Default, template<class...> class Op, class... Args>
2860 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
2861 
2862 template<class Expected, template<class...> class Op, class... Args>
2863 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2864 
2865 template<class To, template<class...> class Op, class... Args>
2867  std::is_convertible<detected_t<Op, Args...>, To>;
2868 } // namespace detail
2869 } // namespace nlohmann
2870 
2871 // #include <nlohmann/json_fwd.hpp>
2872 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
2873 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
2874 
2875 #include <cstdint> // int64_t, uint64_t
2876 #include <map> // map
2877 #include <memory> // allocator
2878 #include <string> // string
2879 #include <vector> // vector
2880 
2886 namespace nlohmann
2887 {
2895 template<typename T = void, typename SFINAE = void>
2896 struct adl_serializer;
2897 
2898 template<template<typename U, typename V, typename... Args> class ObjectType =
2899  std::map,
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 =
2907  adl_serializer,
2908  class BinaryType = std::vector<std::uint8_t>>
2909 class basic_json;
2910 
2922 template<typename BasicJsonType>
2923 class json_pointer;
2924 
2934 
2935 template<class Key, class T, class IgnoredLess, class Allocator>
2936 struct ordered_map;
2937 
2946 
2947 } // namespace nlohmann
2948 
2949 #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
2950 
2951 
2952 namespace nlohmann
2953 {
2962 namespace detail
2963 {
2965 // helpers //
2967 
2968 // Note to maintainers:
2969 //
2970 // Every trait in this file expects a non CV-qualified type.
2971 // The only exceptions are in the 'aliases for detected' section
2972 // (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
2973 //
2974 // In this case, T has to be properly CV-qualified to constraint the function arguments
2975 // (e.g. to_json(BasicJsonType&, const T&))
2976 
2977 template<typename> struct is_basic_json : std::false_type {};
2978 
2979 NLOHMANN_BASIC_JSON_TPL_DECLARATION
2980 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
2981 
2983 // json_ref helpers //
2985 
2986 template<typename>
2987 class json_ref;
2988 
2989 template<typename>
2990 struct is_json_ref : std::false_type {};
2991 
2992 template<typename T>
2993 struct is_json_ref<json_ref<T>> : std::true_type {};
2994 
2996 // aliases for detected //
2998 
2999 template<typename T>
3000 using mapped_type_t = typename T::mapped_type;
3001 
3002 template<typename T>
3003 using key_type_t = typename T::key_type;
3004 
3005 template<typename T>
3006 using value_type_t = typename T::value_type;
3007 
3008 template<typename T>
3009 using difference_type_t = typename T::difference_type;
3010 
3011 template<typename T>
3012 using pointer_t = typename T::pointer;
3013 
3014 template<typename T>
3015 using reference_t = typename T::reference;
3016 
3017 template<typename T>
3018 using iterator_category_t = typename T::iterator_category;
3019 
3020 template<typename T>
3021 using iterator_t = typename T::iterator;
3022 
3023 template<typename T, typename... Args>
3024 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3025 
3026 template<typename T, typename... Args>
3027 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3028 
3029 template<typename T, typename U>
3030 using get_template_function = decltype(std::declval<T>().template get<U>());
3031 
3032 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3033 template<typename BasicJsonType, typename T, typename = void>
3034 struct has_from_json : std::false_type {};
3035 
3036 // trait checking if j.get<T> is valid
3037 // use this trait instead of std::is_constructible or std::is_convertible,
3038 // both rely on, or make use of implicit conversions, and thus fail when T
3039 // has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3040 template <typename BasicJsonType, typename T>
3042 {
3044 };
3045 
3046 template<typename BasicJsonType, typename T>
3047 struct has_from_json < BasicJsonType, T,
3048  enable_if_t < !is_basic_json<T>::value >>
3049 {
3050  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3051 
3052  static constexpr bool value =
3054  const BasicJsonType&, T&>::value;
3055 };
3056 
3057 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
3058 // this overload is used for non-default-constructible user-defined-types
3059 template<typename BasicJsonType, typename T, typename = void>
3060 struct has_non_default_from_json : std::false_type {};
3061 
3062 template<typename BasicJsonType, typename T>
3063 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3064 {
3065  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3066 
3067  static constexpr bool value =
3069  const BasicJsonType&>::value;
3070 };
3071 
3072 // This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3073 // Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3074 template<typename BasicJsonType, typename T, typename = void>
3075 struct has_to_json : std::false_type {};
3076 
3077 template<typename BasicJsonType, typename T>
3078 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3079 {
3080  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3081 
3082  static constexpr bool value =
3083  is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3084  T>::value;
3085 };
3086 
3087 
3089 // is_ functions //
3091 
3092 template<typename T, typename = void>
3093 struct is_iterator_traits : std::false_type {};
3094 
3095 template<typename T>
3097 {
3098  private:
3100 
3101  public:
3102  static constexpr auto value =
3108 };
3109 
3110 // source: https://stackoverflow.com/a/37193089/4116453
3111 
3112 template<typename T, typename = void>
3113 struct is_complete_type : std::false_type {};
3114 
3115 template<typename T>
3116 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3117 
3118 template<typename BasicJsonType, typename CompatibleObjectType,
3119  typename = void>
3120 struct is_compatible_object_type_impl : std::false_type {};
3121 
3122 template<typename BasicJsonType, typename CompatibleObjectType>
3124  BasicJsonType, CompatibleObjectType,
3125  enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3126  is_detected<key_type_t, CompatibleObjectType>::value >>
3127 {
3128 
3129  using object_t = typename BasicJsonType::object_t;
3130 
3131  // macOS's is_constructible does not play well with nonesuch...
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;
3137 };
3138 
3139 template<typename BasicJsonType, typename CompatibleObjectType>
3141  : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3142 
3143 template<typename BasicJsonType, typename ConstructibleObjectType,
3144  typename = void>
3145 struct is_constructible_object_type_impl : std::false_type {};
3146 
3147 template<typename BasicJsonType, typename ConstructibleObjectType>
3149  BasicJsonType, ConstructibleObjectType,
3150  enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3151  is_detected<key_type_t, ConstructibleObjectType>::value >>
3152 {
3153  using object_t = typename BasicJsonType::object_t;
3154 
3155  static constexpr bool value =
3159  (std::is_constructible<typename ConstructibleObjectType::key_type,
3160  typename object_t::key_type>::value &&
3161  std::is_same <
3162  typename object_t::mapped_type,
3163  typename ConstructibleObjectType::mapped_type >::value)) ||
3164  (has_from_json<BasicJsonType,
3165  typename ConstructibleObjectType::mapped_type>::value ||
3167  BasicJsonType,
3168  typename ConstructibleObjectType::mapped_type >::value);
3169 };
3170 
3171 template<typename BasicJsonType, typename ConstructibleObjectType>
3173  : is_constructible_object_type_impl<BasicJsonType,
3174  ConstructibleObjectType> {};
3175 
3176 template<typename BasicJsonType, typename CompatibleStringType,
3177  typename = void>
3178 struct is_compatible_string_type_impl : std::false_type {};
3179 
3180 template<typename BasicJsonType, typename CompatibleStringType>
3182  BasicJsonType, CompatibleStringType,
3183  enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3184  value_type_t, CompatibleStringType>::value >>
3185 {
3186  static constexpr auto value =
3188 };
3189 
3190 template<typename BasicJsonType, typename ConstructibleStringType>
3192  : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3193 
3194 template<typename BasicJsonType, typename ConstructibleStringType,
3195  typename = void>
3196 struct is_constructible_string_type_impl : std::false_type {};
3197 
3198 template<typename BasicJsonType, typename ConstructibleStringType>
3200  BasicJsonType, ConstructibleStringType,
3201  enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3202  value_type_t, ConstructibleStringType>::value >>
3203 {
3204  static constexpr auto value =
3205  std::is_constructible<ConstructibleStringType,
3206  typename BasicJsonType::string_t>::value;
3207 };
3208 
3209 template<typename BasicJsonType, typename ConstructibleStringType>
3211  : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3212 
3213 template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3214 struct is_compatible_array_type_impl : std::false_type {};
3215 
3216 template<typename BasicJsonType, typename CompatibleArrayType>
3218  BasicJsonType, CompatibleArrayType,
3219  enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
3220  is_detected<iterator_t, CompatibleArrayType>::value&&
3221 // This is needed because json_reverse_iterator has a ::iterator type...
3222 // Therefore it is detected as a CompatibleArrayType.
3223 // The real fix would be to have an Iterable concept.
3225  iterator_traits<CompatibleArrayType >>::value >>
3226 {
3227  static constexpr bool value =
3228  std::is_constructible<BasicJsonType,
3229  typename CompatibleArrayType::value_type>::value;
3230 };
3231 
3232 template<typename BasicJsonType, typename CompatibleArrayType>
3234  : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3235 
3236 template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3237 struct is_constructible_array_type_impl : std::false_type {};
3238 
3239 template<typename BasicJsonType, typename ConstructibleArrayType>
3241  BasicJsonType, ConstructibleArrayType,
3242  enable_if_t<std::is_same<ConstructibleArrayType,
3243  typename BasicJsonType::value_type>::value >>
3244  : std::true_type {};
3245 
3246 template<typename BasicJsonType, typename ConstructibleArrayType>
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 >>
3258 {
3259  static constexpr bool value =
3260  // This is needed because json_reverse_iterator has a ::iterator type,
3261  // furthermore, std::back_insert_iterator (and other iterators) have a
3262  // base class `iterator`... Therefore it is detected as a
3263  // ConstructibleArrayType. The real fix would be to have an Iterable
3264  // concept.
3266 
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 ||
3272  BasicJsonType, typename ConstructibleArrayType::value_type >::value);
3273 };
3274 
3275 template<typename BasicJsonType, typename ConstructibleArrayType>
3277  : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3278 
3279 template<typename RealIntegerType, typename CompatibleNumberIntegerType,
3280  typename = void>
3281 struct is_compatible_integer_type_impl : std::false_type {};
3282 
3283 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
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 >>
3289 {
3290  // is there an assert somewhere on overflows?
3291  using RealLimits = std::numeric_limits<RealIntegerType>;
3292  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3293 
3294  static constexpr auto value =
3295  std::is_constructible<RealIntegerType,
3296  CompatibleNumberIntegerType>::value &&
3297  CompatibleLimits::is_integer &&
3298  RealLimits::is_signed == CompatibleLimits::is_signed;
3299 };
3300 
3301 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3303  : is_compatible_integer_type_impl<RealIntegerType,
3304  CompatibleNumberIntegerType> {};
3305 
3306 template<typename BasicJsonType, typename CompatibleType, typename = void>
3307 struct is_compatible_type_impl: std::false_type {};
3308 
3309 template<typename BasicJsonType, typename CompatibleType>
3311  BasicJsonType, CompatibleType,
3312  enable_if_t<is_complete_type<CompatibleType>::value >>
3313 {
3314  static constexpr bool value =
3316 };
3317 
3318 template<typename BasicJsonType, typename CompatibleType>
3320  : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3321 
3322 // https://en.cppreference.com/w/cpp/types/conjunction
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 {};
3328 
3329 template<typename T1, typename T2>
3330 struct is_constructible_tuple : std::false_type {};
3331 
3332 template<typename T1, typename... Args>
3333 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
3334 } // namespace detail
3335 } // namespace nlohmann
3336 
3337 // #include <nlohmann/detail/value_t.hpp>
3338 
3339 
3340 #include <array> // array
3341 #include <cstddef> // size_t
3342 #include <cstdint> // uint8_t
3343 #include <string> // string
3344 
3345 namespace nlohmann
3346 {
3347 namespace detail
3348 {
3350 // JSON type enumeration //
3352 
3377 enum class value_t : std::uint8_t
3378 {
3379  null,
3380  object,
3381  array,
3382  string,
3383  boolean,
3384  number_integer,
3385  number_unsigned,
3386  number_float,
3387  binary,
3388  discarded
3389 };
3390 
3404 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
3405 {
3406  static constexpr std::array<std::uint8_t, 9> order = {{
3407  0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
3408  1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
3409  6 /* binary */
3410  }
3411  };
3412 
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];
3416 }
3417 } // namespace detail
3418 } // namespace nlohmann
3419 
3420 
3421 namespace nlohmann
3422 {
3423 namespace detail
3424 {
3425 template<typename BasicJsonType>
3426 void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
3427 {
3428  if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3429  {
3430  JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
3431  }
3432  n = nullptr;
3433 }
3434 
3435 // overloads for basic_json template parameters
3436 template < typename BasicJsonType, typename ArithmeticType,
3439  int > = 0 >
3440 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
3441 {
3442  switch (static_cast<value_t>(j))
3443  {
3445  {
3446  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3447  break;
3448  }
3450  {
3451  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3452  break;
3453  }
3454  case value_t::number_float:
3455  {
3456  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3457  break;
3458  }
3459 
3460  default:
3461  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
3462  }
3463 }
3464 
3465 template<typename BasicJsonType>
3466 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
3467 {
3468  if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3469  {
3470  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
3471  }
3472  b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3473 }
3474 
3475 template<typename BasicJsonType>
3476 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
3477 {
3478  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3479  {
3480  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
3481  }
3482  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3483 }
3484 
3485 template <
3486  typename BasicJsonType, typename ConstructibleStringType,
3487  enable_if_t <
3489  !std::is_same<typename BasicJsonType::string_t,
3490  ConstructibleStringType>::value,
3491  int > = 0 >
3492 void from_json(const BasicJsonType& j, ConstructibleStringType& s)
3493 {
3494  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3495  {
3496  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
3497  }
3498 
3499  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3500 }
3501 
3502 template<typename BasicJsonType>
3503 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
3504 {
3505  get_arithmetic_value(j, val);
3506 }
3507 
3508 template<typename BasicJsonType>
3509 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
3510 {
3511  get_arithmetic_value(j, val);
3512 }
3513 
3514 template<typename BasicJsonType>
3515 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
3516 {
3517  get_arithmetic_value(j, val);
3518 }
3519 
3520 template<typename BasicJsonType, typename EnumType,
3522 void from_json(const BasicJsonType& j, EnumType& e)
3523 {
3524  typename std::underlying_type<EnumType>::type val;
3525  get_arithmetic_value(j, val);
3526  e = static_cast<EnumType>(val);
3527 }
3528 
3529 // forward_list doesn't have an insert method
3530 template<typename BasicJsonType, typename T, typename Allocator,
3532 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3533 {
3534  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3535  {
3536  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3537  }
3538  l.clear();
3539  std::transform(j.rbegin(), j.rend(),
3540  std::front_inserter(l), [](const BasicJsonType & i)
3541  {
3542  return i.template get<T>();
3543  });
3544 }
3545 
3546 // valarray doesn't have an insert method
3547 template<typename BasicJsonType, typename T,
3549 void from_json(const BasicJsonType& j, std::valarray<T>& l)
3550 {
3551  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3552  {
3553  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3554  }
3555  l.resize(j.size());
3556  std::transform(j.begin(), j.end(), std::begin(l),
3557  [](const BasicJsonType & elem)
3558  {
3559  return elem.template get<T>();
3560  });
3561 }
3562 
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())
3566 {
3567  for (std::size_t i = 0; i < N; ++i)
3568  {
3569  arr[i] = j.at(i).template get<T>();
3570  }
3571 }
3572 
3573 template<typename BasicJsonType>
3574 void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
3575 {
3576  arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3577 }
3578 
3579 template<typename BasicJsonType, typename T, std::size_t N>
3580 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
3581  priority_tag<2> /*unused*/)
3582 -> decltype(j.template get<T>(), void())
3583 {
3584  for (std::size_t i = 0; i < N; ++i)
3585  {
3586  arr[i] = j.at(i).template get<T>();
3587  }
3588 }
3589 
3590 template<typename BasicJsonType, typename ConstructibleArrayType>
3591 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
3592 -> decltype(
3593  arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
3594  j.template get<typename ConstructibleArrayType::value_type>(),
3595  void())
3596 {
3597  using std::end;
3598 
3599  ConstructibleArrayType ret;
3600  ret.reserve(j.size());
3601  std::transform(j.begin(), j.end(),
3602  std::inserter(ret, end(ret)), [](const BasicJsonType & i)
3603  {
3604  // get<BasicJsonType>() returns *this, this won't call a from_json
3605  // method when value_type is BasicJsonType
3606  return i.template get<typename ConstructibleArrayType::value_type>();
3607  });
3608  arr = std::move(ret);
3609 }
3610 
3611 template<typename BasicJsonType, typename ConstructibleArrayType>
3612 void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
3613  priority_tag<0> /*unused*/)
3614 {
3615  using std::end;
3616 
3617  ConstructibleArrayType ret;
3618  std::transform(
3619  j.begin(), j.end(), std::inserter(ret, end(ret)),
3620  [](const BasicJsonType & i)
3621  {
3622  // get<BasicJsonType>() returns *this, this won't call a from_json
3623  // method when value_type is BasicJsonType
3624  return i.template get<typename ConstructibleArrayType::value_type>();
3625  });
3626  arr = std::move(ret);
3627 }
3628 
3629 template < typename BasicJsonType, typename ConstructibleArrayType,
3630  enable_if_t <
3636  int > = 0 >
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>(),
3640 void())
3641 {
3642  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3643  {
3644  JSON_THROW(type_error::create(302, "type must be array, but is " +
3645  std::string(j.type_name())));
3646  }
3647 
3648  from_json_array_impl(j, arr, priority_tag<3> {});
3649 }
3650 
3651 template<typename BasicJsonType>
3652 void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
3653 {
3654  if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
3655  {
3656  JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
3657  }
3658 
3659  bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
3660 }
3661 
3662 template<typename BasicJsonType, typename ConstructibleObjectType,
3664 void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
3665 {
3666  if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
3667  {
3668  JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
3669  }
3670 
3671  ConstructibleObjectType ret;
3672  auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
3673  using value_type = typename ConstructibleObjectType::value_type;
3674  std::transform(
3675  inner_object->begin(), inner_object->end(),
3676  std::inserter(ret, ret.begin()),
3677  [](typename BasicJsonType::object_t::value_type const & p)
3678  {
3679  return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
3680  });
3681  obj = std::move(ret);
3682 }
3683 
3684 // overload for arithmetic types, not chosen for basic_json template arguments
3685 // (BooleanType, etc..); note: Is it really necessary to provide explicit
3686 // overloads for boolean_t etc. in case of a custom BooleanType which is not
3687 // an arithmetic type?
3688 template < typename BasicJsonType, typename ArithmeticType,
3689  enable_if_t <
3695  int > = 0 >
3696 void from_json(const BasicJsonType& j, ArithmeticType& val)
3697 {
3698  switch (static_cast<value_t>(j))
3699  {
3701  {
3702  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3703  break;
3704  }
3706  {
3707  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3708  break;
3709  }
3710  case value_t::number_float:
3711  {
3712  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3713  break;
3714  }
3715  case value_t::boolean:
3716  {
3717  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
3718  break;
3719  }
3720 
3721  default:
3722  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
3723  }
3724 }
3725 
3726 template<typename BasicJsonType, typename A1, typename A2>
3727 void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
3728 {
3729  p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
3730 }
3731 
3732 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
3733 void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
3734 {
3735  t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
3736 }
3737 
3738 template<typename BasicJsonType, typename... Args>
3739 void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
3740 {
3742 }
3743 
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)
3748 {
3749  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3750  {
3751  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3752  }
3753  m.clear();
3754  for (const auto& p : j)
3755  {
3756  if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
3757  {
3758  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
3759  }
3760  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3761  }
3762 }
3763 
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)
3768 {
3769  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3770  {
3771  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3772  }
3773  m.clear();
3774  for (const auto& p : j)
3775  {
3776  if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
3777  {
3778  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
3779  }
3780  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3781  }
3782 }
3783 
3785 {
3786  template<typename BasicJsonType, typename T>
3787  auto operator()(const BasicJsonType& j, T& val) const
3788  noexcept(noexcept(from_json(j, val)))
3789  -> decltype(from_json(j, val), void())
3790  {
3791  return from_json(j, val);
3792  }
3793 };
3794 } // namespace detail
3795 
3799 namespace
3800 {
3802 } // namespace
3803 } // namespace nlohmann
3804 
3805 // #include <nlohmann/detail/conversions/to_json.hpp>
3806 
3807 
3808 #include <algorithm> // copy
3809 #include <iterator> // begin, end
3810 #include <string> // string
3811 #include <tuple> // tuple, get
3812 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
3813 #include <utility> // move, forward, declval, pair
3814 #include <valarray> // valarray
3815 #include <vector> // vector
3816 
3817 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
3818 
3819 
3820 #include <cstddef> // size_t
3821 #include <iterator> // input_iterator_tag
3822 #include <string> // string, to_string
3823 #include <tuple> // tuple_size, get, tuple_element
3824 
3825 // #include <nlohmann/detail/meta/type_traits.hpp>
3826 
3827 // #include <nlohmann/detail/value_t.hpp>
3828 
3829 
3830 namespace nlohmann
3831 {
3832 namespace detail
3833 {
3834 template<typename string_type>
3835 void int_to_string( string_type& target, std::size_t value )
3836 {
3837  // For ADL
3838  using std::to_string;
3839  target = to_string(value);
3840 }
3841 template<typename IteratorType> class iteration_proxy_value
3842 {
3843  public:
3844  using difference_type = std::ptrdiff_t;
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;
3850 
3851  private:
3853  IteratorType anchor;
3855  std::size_t array_index = 0;
3857  mutable std::size_t array_index_last = 0;
3862 
3863  public:
3864  explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
3865 
3868  {
3869  return *this;
3870  }
3871 
3874  {
3875  ++anchor;
3876  ++array_index;
3877 
3878  return *this;
3879  }
3880 
3882  bool operator==(const iteration_proxy_value& o) const
3883  {
3884  return anchor == o.anchor;
3885  }
3886 
3888  bool operator!=(const iteration_proxy_value& o) const
3889  {
3890  return anchor != o.anchor;
3891  }
3892 
3894  const string_type& key() const
3895  {
3896  JSON_ASSERT(anchor.m_object != nullptr);
3897 
3898  switch (anchor.m_object->type())
3899  {
3900  // use integer array index as key
3901  case value_t::array:
3902  {
3904  {
3907  }
3908  return array_index_str;
3909  }
3910 
3911  // use key from the object
3912  case value_t::object:
3913  return anchor.key();
3914 
3915  // use an empty key for all primitive types
3916  default:
3917  return empty_str;
3918  }
3919  }
3920 
3922  typename IteratorType::reference value() const
3923  {
3924  return anchor.value();
3925  }
3926 };
3927 
3929 template<typename IteratorType> class iteration_proxy
3930 {
3931  private:
3933  typename IteratorType::reference container;
3934 
3935  public:
3937  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
3938  : container(cont) {}
3939 
3942  {
3944  }
3945 
3948  {
3950  }
3951 };
3952 // Structured Bindings Support
3953 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3954 // And see https://github.com/nlohmann/json/pull/1391
3955 template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
3957 {
3958  return i.key();
3959 }
3960 // Structured Bindings Support
3961 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3962 // And see https://github.com/nlohmann/json/pull/1391
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())
3965 {
3966  return i.value();
3967 }
3968 } // namespace detail
3969 } // namespace nlohmann
3970 
3971 // The Addition to the STD Namespace is required to add
3972 // Structured Bindings Support to the iteration_proxy_value class
3973 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3974 // And see https://github.com/nlohmann/json/pull/1391
3975 namespace std
3976 {
3977 #if defined(__clang__)
3978  // Fix: https://github.com/nlohmann/json/issues/1401
3979  #pragma clang diagnostic push
3980  #pragma clang diagnostic ignored "-Wmismatched-tags"
3981 #endif
3982 template<typename IteratorType>
3983 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
3984  : public std::integral_constant<std::size_t, 2> {};
3985 
3986 template<std::size_t N, typename IteratorType>
3987 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
3988 {
3989  public:
3990  using type = decltype(
3991  get<N>(std::declval <
3993 };
3994 #if defined(__clang__)
3995  #pragma clang diagnostic pop
3996 #endif
3997 } // namespace std
3998 
3999 // #include <nlohmann/detail/meta/cpp_future.hpp>
4000 
4001 // #include <nlohmann/detail/meta/type_traits.hpp>
4002 
4003 // #include <nlohmann/detail/value_t.hpp>
4004 
4005 
4006 namespace nlohmann
4007 {
4008 namespace detail
4009 {
4011 // constructors //
4013 
4014 template<value_t> struct external_constructor;
4015 
4016 template<>
4018 {
4019  template<typename BasicJsonType>
4020  static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
4021  {
4022  j.m_type = value_t::boolean;
4023  j.m_value = b;
4024  j.assert_invariant();
4025  }
4026 };
4027 
4028 template<>
4030 {
4031  template<typename BasicJsonType>
4032  static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
4033  {
4034  j.m_type = value_t::string;
4035  j.m_value = s;
4036  j.assert_invariant();
4037  }
4038 
4039  template<typename BasicJsonType>
4040  static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4041  {
4042  j.m_type = value_t::string;
4043  j.m_value = std::move(s);
4044  j.assert_invariant();
4045  }
4046 
4047  template < typename BasicJsonType, typename CompatibleStringType,
4049  int > = 0 >
4050  static void construct(BasicJsonType& j, const CompatibleStringType& str)
4051  {
4052  j.m_type = value_t::string;
4053  j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4054  j.assert_invariant();
4055  }
4056 };
4057 
4058 template<>
4060 {
4061  template<typename BasicJsonType>
4062  static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
4063  {
4064  j.m_type = value_t::binary;
4065  typename BasicJsonType::binary_t value{b};
4066  j.m_value = value;
4067  j.assert_invariant();
4068  }
4069 
4070  template<typename BasicJsonType>
4071  static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
4072  {
4073  j.m_type = value_t::binary;
4074  typename BasicJsonType::binary_t value{std::move(b)};
4075  j.m_value = value;
4076  j.assert_invariant();
4077  }
4078 };
4079 
4080 template<>
4082 {
4083  template<typename BasicJsonType>
4084  static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
4085  {
4086  j.m_type = value_t::number_float;
4087  j.m_value = val;
4088  j.assert_invariant();
4089  }
4090 };
4091 
4092 template<>
4094 {
4095  template<typename BasicJsonType>
4096  static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
4097  {
4098  j.m_type = value_t::number_unsigned;
4099  j.m_value = val;
4100  j.assert_invariant();
4101  }
4102 };
4103 
4104 template<>
4106 {
4107  template<typename BasicJsonType>
4108  static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
4109  {
4110  j.m_type = value_t::number_integer;
4111  j.m_value = val;
4112  j.assert_invariant();
4113  }
4114 };
4115 
4116 template<>
4118 {
4119  template<typename BasicJsonType>
4120  static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
4121  {
4122  j.m_type = value_t::array;
4123  j.m_value = arr;
4124  j.assert_invariant();
4125  }
4126 
4127  template<typename BasicJsonType>
4128  static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4129  {
4130  j.m_type = value_t::array;
4131  j.m_value = std::move(arr);
4132  j.assert_invariant();
4133  }
4134 
4135  template < typename BasicJsonType, typename CompatibleArrayType,
4137  int > = 0 >
4138  static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
4139  {
4140  using std::begin;
4141  using std::end;
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();
4145  }
4146 
4147  template<typename BasicJsonType>
4148  static void construct(BasicJsonType& j, const std::vector<bool>& arr)
4149  {
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)
4154  {
4155  j.m_value.array->push_back(x);
4156  }
4157  j.assert_invariant();
4158  }
4159 
4160  template<typename BasicJsonType, typename T,
4162  static void construct(BasicJsonType& j, const std::valarray<T>& arr)
4163  {
4164  j.m_type = value_t::array;
4165  j.m_value = value_t::array;
4166  j.m_value.array->resize(arr.size());
4167  if (arr.size() > 0)
4168  {
4169  std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4170  }
4171  j.assert_invariant();
4172  }
4173 };
4174 
4175 template<>
4177 {
4178  template<typename BasicJsonType>
4179  static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
4180  {
4181  j.m_type = value_t::object;
4182  j.m_value = obj;
4183  j.assert_invariant();
4184  }
4185 
4186  template<typename BasicJsonType>
4187  static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4188  {
4189  j.m_type = value_t::object;
4190  j.m_value = std::move(obj);
4191  j.assert_invariant();
4192  }
4193 
4194  template < typename BasicJsonType, typename CompatibleObjectType,
4196  static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
4197  {
4198  using std::begin;
4199  using std::end;
4200 
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();
4204  }
4205 };
4206 
4208 // to_json //
4210 
4211 template<typename BasicJsonType, typename T,
4213 void to_json(BasicJsonType& j, T b) noexcept
4214 {
4216 }
4217 
4218 template<typename BasicJsonType, typename CompatibleString,
4220 void to_json(BasicJsonType& j, const CompatibleString& s)
4221 {
4223 }
4224 
4225 template<typename BasicJsonType>
4226 void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4227 {
4229 }
4230 
4231 template<typename BasicJsonType, typename FloatType,
4233 void to_json(BasicJsonType& j, FloatType val) noexcept
4234 {
4235  external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
4236 }
4237 
4238 template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
4240 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4241 {
4242  external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
4243 }
4244 
4245 template<typename BasicJsonType, typename CompatibleNumberIntegerType,
4247 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4248 {
4249  external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
4250 }
4251 
4252 template<typename BasicJsonType, typename EnumType,
4254 void to_json(BasicJsonType& j, EnumType e) noexcept
4255 {
4256  using underlying_type = typename std::underlying_type<EnumType>::type;
4257  external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
4258 }
4259 
4260 template<typename BasicJsonType>
4261 void to_json(BasicJsonType& j, const std::vector<bool>& e)
4262 {
4264 }
4265 
4266 template < typename BasicJsonType, typename CompatibleArrayType,
4267  enable_if_t < is_compatible_array_type<BasicJsonType,
4268  CompatibleArrayType>::value&&
4273  int > = 0 >
4274 void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
4275 {
4277 }
4278 
4279 template<typename BasicJsonType>
4280 void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
4281 {
4283 }
4284 
4285 template<typename BasicJsonType, typename T,
4287 void to_json(BasicJsonType& j, const std::valarray<T>& arr)
4288 {
4290 }
4291 
4292 template<typename BasicJsonType>
4293 void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4294 {
4296 }
4297 
4298 template < typename BasicJsonType, typename CompatibleObjectType,
4300 void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
4301 {
4303 }
4304 
4305 template<typename BasicJsonType>
4306 void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4307 {
4309 }
4310 
4311 template <
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,
4315  int > = 0 >
4316 void to_json(BasicJsonType& j, const T(&arr)[N])
4317 {
4319 }
4320 
4322 void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
4323 {
4324  j = { p.first, p.second };
4325 }
4326 
4327 // for https://github.com/nlohmann/json/pull/1134
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)
4331 {
4332  j = { {b.key(), b.value()} };
4333 }
4334 
4335 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
4336 void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
4337 {
4338  j = { std::get<Idx>(t)... };
4339 }
4340 
4342 void to_json(BasicJsonType& j, const T& t)
4343 {
4344  to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4345 }
4346 
4348 {
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())
4352  {
4353  return to_json(j, std::forward<T>(val));
4354  }
4355 };
4356 } // namespace detail
4357 
4359 namespace
4360 {
4362 } // namespace
4363 } // namespace nlohmann
4364 
4365 
4366 namespace nlohmann
4367 {
4368 
4369 template<typename, typename>
4371 {
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())
4385  {
4386  ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4387  }
4388 
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())
4402  {
4403  ::nlohmann::to_json(j, std::forward<ValueType>(val));
4404  }
4405 };
4406 
4407 } // namespace nlohmann
4408 
4409 // #include <nlohmann/byte_container_with_subtype.hpp>
4410 
4411 
4412 #include <cstdint> // uint8_t
4413 #include <tuple> // tie
4414 #include <utility> // move
4415 
4416 namespace nlohmann
4417 {
4418 
4432 template<typename BinaryType>
4433 class byte_container_with_subtype : public BinaryType
4434 {
4435  public:
4437  using container_type = BinaryType;
4438 
4440  : container_type()
4441  {}
4442 
4444  : container_type(b)
4445  {}
4446 
4447  byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
4448  : container_type(std::move(b))
4449  {}
4450 
4451  byte_container_with_subtype(const container_type& b, std::uint8_t subtype) noexcept(noexcept(container_type(b)))
4452  : container_type(b)
4453  , m_subtype(subtype)
4454  , m_has_subtype(true)
4455  {}
4456 
4457  byte_container_with_subtype(container_type&& b, std::uint8_t subtype) noexcept(noexcept(container_type(std::move(b))))
4458  : container_type(std::move(b))
4459  , m_subtype(subtype)
4460  , m_has_subtype(true)
4461  {}
4462 
4464  {
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);
4467  }
4468 
4470  {
4471  return !(rhs == *this);
4472  }
4473 
4492  void set_subtype(std::uint8_t subtype) noexcept
4493  {
4494  m_subtype = subtype;
4495  m_has_subtype = true;
4496  }
4497 
4519  constexpr std::uint8_t subtype() const noexcept
4520  {
4521  return m_subtype;
4522  }
4523 
4540  constexpr bool has_subtype() const noexcept
4541  {
4542  return m_has_subtype;
4543  }
4544 
4564  void clear_subtype() noexcept
4565  {
4566  m_subtype = 0;
4567  m_has_subtype = false;
4568  }
4569 
4570  private:
4571  std::uint8_t m_subtype = 0;
4572  bool m_has_subtype = false;
4573 };
4574 
4575 } // namespace nlohmann
4576 
4577 // #include <nlohmann/detail/conversions/from_json.hpp>
4578 
4579 // #include <nlohmann/detail/conversions/to_json.hpp>
4580 
4581 // #include <nlohmann/detail/exceptions.hpp>
4582 
4583 // #include <nlohmann/detail/hash.hpp>
4584 
4585 
4586 #include <cstddef> // size_t, uint8_t
4587 #include <functional> // hash
4588 
4589 namespace nlohmann
4590 {
4591 namespace detail
4592 {
4593 
4594 // boost::hash_combine
4595 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
4596 {
4597  seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
4598  return seed;
4599 }
4600 
4612 template<typename BasicJsonType>
4613 std::size_t hash(const BasicJsonType& j)
4614 {
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;
4619 
4620  const auto type = static_cast<std::size_t>(j.type());
4621  switch (j.type())
4622  {
4623  case BasicJsonType::value_t::null:
4624  case BasicJsonType::value_t::discarded:
4625  {
4626  return combine(type, 0);
4627  }
4628 
4629  case BasicJsonType::value_t::object:
4630  {
4631  auto seed = combine(type, j.size());
4632  for (const auto& element : j.items())
4633  {
4634  const auto h = std::hash<string_t> {}(element.key());
4635  seed = combine(seed, h);
4636  seed = combine(seed, hash(element.value()));
4637  }
4638  return seed;
4639  }
4640 
4641  case BasicJsonType::value_t::array:
4642  {
4643  auto seed = combine(type, j.size());
4644  for (const auto& element : j)
4645  {
4646  seed = combine(seed, hash(element));
4647  }
4648  return seed;
4649  }
4650 
4651  case BasicJsonType::value_t::string:
4652  {
4653  const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
4654  return combine(type, h);
4655  }
4656 
4657  case BasicJsonType::value_t::boolean:
4658  {
4659  const auto h = std::hash<bool> {}(j.template get<bool>());
4660  return combine(type, h);
4661  }
4662 
4663  case BasicJsonType::value_t::number_integer:
4664  {
4665  const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
4666  return combine(type, h);
4667  }
4668 
4670  {
4671  const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
4672  return combine(type, h);
4673  }
4674 
4676  {
4677  const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
4678  return combine(type, h);
4679  }
4680 
4682  {
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())
4688  {
4689  seed = combine(seed, std::hash<std::uint8_t> {}(byte));
4690  }
4691  return seed;
4692  }
4693 
4694  default: // LCOV_EXCL_LINE
4695  JSON_ASSERT(false); // LCOV_EXCL_LINE
4696  }
4697 }
4698 
4699 } // namespace detail
4700 } // namespace nlohmann
4701 
4702 // #include <nlohmann/detail/input/binary_reader.hpp>
4703 
4704 
4705 #include <algorithm> // generate_n
4706 #include <array> // array
4707 #include <cmath> // ldexp
4708 #include <cstddef> // size_t
4709 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
4710 #include <cstdio> // snprintf
4711 #include <cstring> // memcpy
4712 #include <iterator> // back_inserter
4713 #include <limits> // numeric_limits
4714 #include <string> // char_traits, string
4715 #include <utility> // make_pair, move
4716 
4717 // #include <nlohmann/detail/exceptions.hpp>
4718 
4719 // #include <nlohmann/detail/input/input_adapters.hpp>
4720 
4721 
4722 #include <array> // array
4723 #include <cstddef> // size_t
4724 #include <cstdio> //FILE *
4725 #include <cstring> // strlen
4726 #include <istream> // istream
4727 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
4728 #include <memory> // shared_ptr, make_shared, addressof
4729 #include <numeric> // accumulate
4730 #include <string> // string, char_traits
4731 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
4732 #include <utility> // pair, declval
4733 
4734 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
4735 
4736 // #include <nlohmann/detail/macro_scope.hpp>
4737 
4738 
4739 namespace nlohmann
4740 {
4741 namespace detail
4742 {
4745 
4747 // input adapters //
4749 
4755 {
4756  public:
4757  using char_type = char;
4758 
4760  explicit file_input_adapter(std::FILE* f) noexcept
4761  : m_file(f)
4762  {}
4763 
4764  // make class move-only
4769 
4770  std::char_traits<char>::int_type get_character() noexcept
4771  {
4772  return std::fgetc(m_file);
4773  }
4774 
4775  private:
4777  std::FILE* m_file;
4778 };
4779 
4780 
4791 {
4792  public:
4793  using char_type = char;
4794 
4796  {
4797  // clear stream flags; we use underlying streambuf I/O, do not
4798  // maintain ifstream flags, except eof
4799  if (is != nullptr)
4800  {
4801  is->clear(is->rdstate() & std::ios::eofbit);
4802  }
4803  }
4804 
4805  explicit input_stream_adapter(std::istream& i)
4806  : is(&i), sb(i.rdbuf())
4807  {}
4808 
4809  // delete because of pointer members
4813 
4814  input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
4815  {
4816  rhs.is = nullptr;
4817  rhs.sb = nullptr;
4818  }
4819 
4820  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
4821  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
4822  // end up as the same value, eg. 0xFFFFFFFF.
4823  std::char_traits<char>::int_type get_character()
4824  {
4825  auto res = sb->sbumpc();
4826  // set eof manually, as we don't use the istream interface.
4827  if (JSON_HEDLEY_UNLIKELY(res == EOF))
4828  {
4829  is->clear(is->rdstate() | std::ios::eofbit);
4830  }
4831  return res;
4832  }
4833 
4834  private:
4836  std::istream* is = nullptr;
4837  std::streambuf* sb = nullptr;
4838 };
4839 
4840 // General-purpose iterator-based adapter. It might not be as fast as
4841 // theoretically possible for some containers, but it is extremely versatile.
4842 template<typename IteratorType>
4844 {
4845  public:
4846  using char_type = typename std::iterator_traits<IteratorType>::value_type;
4847 
4848  iterator_input_adapter(IteratorType first, IteratorType last)
4849  : current(std::move(first)), end(std::move(last)) {}
4850 
4851  typename std::char_traits<char_type>::int_type get_character()
4852  {
4853  if (JSON_HEDLEY_LIKELY(current != end))
4854  {
4855  auto result = std::char_traits<char_type>::to_int_type(*current);
4856  std::advance(current, 1);
4857  return result;
4858  }
4859  else
4860  {
4861  return std::char_traits<char_type>::eof();
4862  }
4863  }
4864 
4865  private:
4866  IteratorType current;
4867  IteratorType end;
4868 
4869  template<typename BaseInputAdapter, size_t T>
4871 
4872  bool empty() const
4873  {
4874  return current == end;
4875  }
4876 
4877 };
4878 
4879 
4880 template<typename BaseInputAdapter, size_t T>
4882 
4883 template<typename BaseInputAdapter>
4884 struct wide_string_input_helper<BaseInputAdapter, 4>
4885 {
4886  // UTF-32
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)
4891  {
4892  utf8_bytes_index = 0;
4893 
4894  if (JSON_HEDLEY_UNLIKELY(input.empty()))
4895  {
4896  utf8_bytes[0] = std::char_traits<char>::eof();
4897  utf8_bytes_filled = 1;
4898  }
4899  else
4900  {
4901  // get the current character
4902  const auto wc = input.get_character();
4903 
4904  // UTF-32 to UTF-8 encoding
4905  if (wc < 0x80)
4906  {
4907  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4908  utf8_bytes_filled = 1;
4909  }
4910  else if (wc <= 0x7FF)
4911  {
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;
4915  }
4916  else if (wc <= 0xFFFF)
4917  {
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;
4922  }
4923  else if (wc <= 0x10FFFF)
4924  {
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;
4930  }
4931  else
4932  {
4933  // unknown character
4934  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4935  utf8_bytes_filled = 1;
4936  }
4937  }
4938  }
4939 };
4940 
4941 template<typename BaseInputAdapter>
4942 struct wide_string_input_helper<BaseInputAdapter, 2>
4943 {
4944  // UTF-16
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)
4949  {
4950  utf8_bytes_index = 0;
4951 
4952  if (JSON_HEDLEY_UNLIKELY(input.empty()))
4953  {
4954  utf8_bytes[0] = std::char_traits<char>::eof();
4955  utf8_bytes_filled = 1;
4956  }
4957  else
4958  {
4959  // get the current character
4960  const auto wc = input.get_character();
4961 
4962  // UTF-16 to UTF-8 encoding
4963  if (wc < 0x80)
4964  {
4965  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4966  utf8_bytes_filled = 1;
4967  }
4968  else if (wc <= 0x7FF)
4969  {
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;
4973  }
4974  else if (0xD800 > wc || wc >= 0xE000)
4975  {
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;
4980  }
4981  else
4982  {
4983  if (JSON_HEDLEY_UNLIKELY(!input.empty()))
4984  {
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;
4992  }
4993  else
4994  {
4995  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4996  utf8_bytes_filled = 1;
4997  }
4998  }
4999  }
5000  }
5001 };
5002 
5003 // Wraps another input apdater to convert wide character types into individual bytes.
5004 template<typename BaseInputAdapter, typename WideCharType>
5006 {
5007  public:
5008  using char_type = char;
5009 
5010  wide_string_input_adapter(BaseInputAdapter base)
5011  : base_adapter(base) {}
5012 
5013  typename std::char_traits<char>::int_type get_character() noexcept
5014  {
5015  // check if buffer needs to be filled
5017  {
5018  fill_buffer<sizeof(WideCharType)>();
5019 
5022  }
5023 
5024  // use buffer
5027  return utf8_bytes[utf8_bytes_index++];
5028  }
5029 
5030  private:
5031  BaseInputAdapter base_adapter;
5032 
5033  template<size_t T>
5035  {
5037  }
5038 
5040  std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5041 
5043  std::size_t utf8_bytes_index = 0;
5045  std::size_t utf8_bytes_filled = 0;
5046 };
5047 
5048 
5049 template<typename IteratorType, typename Enable = void>
5051 {
5052  using iterator_type = IteratorType;
5053  using char_type = typename std::iterator_traits<iterator_type>::value_type;
5055 
5056  static adapter_type create(IteratorType first, IteratorType last)
5057  {
5058  return adapter_type(std::move(first), std::move(last));
5059  }
5060 };
5061 
5062 template<typename T>
5064 {
5065  using value_type = typename std::iterator_traits<T>::value_type;
5066  enum
5067  {
5068  value = sizeof(value_type) > 1
5069  };
5070 };
5071 
5072 template<typename IteratorType>
5074 {
5075  using iterator_type = IteratorType;
5076  using char_type = typename std::iterator_traits<iterator_type>::value_type;
5079 
5080  static adapter_type create(IteratorType first, IteratorType last)
5081  {
5082  return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5083  }
5084 };
5085 
5086 // General purpose iterator-based input
5087 template<typename IteratorType>
5089 {
5090  using factory_type = iterator_input_adapter_factory<IteratorType>;
5091  return factory_type::create(first, last);
5092 }
5093 
5094 // Convenience shorthand from container to iterator
5095 template<typename ContainerType>
5096 auto input_adapter(const ContainerType& container) -> decltype(input_adapter(begin(container), end(container)))
5097 {
5098  // Enable ADL
5099  using std::begin;
5100  using std::end;
5101 
5102  return input_adapter(begin(container), end(container));
5103 }
5104 
5105 // Special cases with fast paths
5106 inline file_input_adapter input_adapter(std::FILE* file)
5107 {
5108  return file_input_adapter(file);
5109 }
5110 
5111 inline input_stream_adapter input_adapter(std::istream& stream)
5112 {
5113  return input_stream_adapter(stream);
5114 }
5115 
5116 inline input_stream_adapter input_adapter(std::istream&& stream)
5117 {
5118  return input_stream_adapter(stream);
5119 }
5120 
5121 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5122 
5123 // Null-delimited strings, and the like.
5124 template < typename CharT,
5125  typename std::enable_if <
5128  std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5129  sizeof(typename std::remove_pointer<CharT>::type) == 1,
5130  int >::type = 0 >
5132 {
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);
5136 }
5137 
5138 template<typename T, std::size_t N>
5139 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
5140 {
5141  return input_adapter(array, array + N);
5142 }
5143 
5144 // This class only handles inputs of input_buffer_adapter type.
5145 // It's required so that expressions like {ptr, len} can be implicitely casted
5146 // to the correct adapter.
5148 {
5149  public:
5150  template < typename CharT,
5151  typename std::enable_if <
5153  std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5154  sizeof(typename std::remove_pointer<CharT>::type) == 1,
5155  int >::type = 0 >
5156  span_input_adapter(CharT b, std::size_t l)
5157  : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5158 
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,
5162  int>::type = 0>
5163  span_input_adapter(IteratorType first, IteratorType last)
5164  : ia(input_adapter(first, last)) {}
5165 
5167  {
5168  return std::move(ia);
5169  }
5170 
5171  private:
5173 };
5174 } // namespace detail
5175 } // namespace nlohmann
5176 
5177 // #include <nlohmann/detail/input/json_sax.hpp>
5178 
5179 
5180 #include <cstddef>
5181 #include <string> // string
5182 #include <utility> // move
5183 #include <vector> // vector
5184 
5185 // #include <nlohmann/detail/exceptions.hpp>
5186 
5187 // #include <nlohmann/detail/macro_scope.hpp>
5188 
5189 
5190 namespace nlohmann
5191 {
5192 
5201 template<typename BasicJsonType>
5202 struct json_sax
5203 {
5204  using number_integer_t = typename BasicJsonType::number_integer_t;
5205  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5206  using number_float_t = typename BasicJsonType::number_float_t;
5207  using string_t = typename BasicJsonType::string_t;
5208  using binary_t = typename BasicJsonType::binary_t;
5209 
5214  virtual bool null() = 0;
5215 
5221  virtual bool boolean(bool val) = 0;
5222 
5228  virtual bool number_integer(number_integer_t val) = 0;
5229 
5235  virtual bool number_unsigned(number_unsigned_t val) = 0;
5236 
5243  virtual bool number_float(number_float_t val, const string_t& s) = 0;
5244 
5251  virtual bool string(string_t& val) = 0;
5252 
5259  virtual bool binary(binary_t& val) = 0;
5260 
5267  virtual bool start_object(std::size_t elements) = 0;
5268 
5275  virtual bool key(string_t& val) = 0;
5276 
5281  virtual bool end_object() = 0;
5282 
5289  virtual bool start_array(std::size_t elements) = 0;
5290 
5295  virtual bool end_array() = 0;
5296 
5304  virtual bool parse_error(std::size_t position,
5305  const std::string& last_token,
5306  const detail::exception& ex) = 0;
5307 
5308  virtual ~json_sax() = default;
5309 };
5310 
5311 
5312 namespace detail
5313 {
5327 template<typename BasicJsonType>
5329 {
5330  public:
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;
5336 
5342  explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
5343  : root(r), allow_exceptions(allow_exceptions_)
5344  {}
5345 
5346  // make class move-only
5352 
5353  bool null()
5354  {
5355  handle_value(nullptr);
5356  return true;
5357  }
5358 
5359  bool boolean(bool val)
5360  {
5361  handle_value(val);
5362  return true;
5363  }
5364 
5366  {
5367  handle_value(val);
5368  return true;
5369  }
5370 
5372  {
5373  handle_value(val);
5374  return true;
5375  }
5376 
5377  bool number_float(number_float_t val, const string_t& /*unused*/)
5378  {
5379  handle_value(val);
5380  return true;
5381  }
5382 
5383  bool string(string_t& val)
5384  {
5385  handle_value(val);
5386  return true;
5387  }
5388 
5389  bool binary(binary_t& val)
5390  {
5391  handle_value(std::move(val));
5392  return true;
5393  }
5394 
5395  bool start_object(std::size_t len)
5396  {
5397  ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
5398 
5399  if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5400  {
5401  JSON_THROW(out_of_range::create(408,
5402  "excessive object size: " + std::to_string(len)));
5403  }
5404 
5405  return true;
5406  }
5407 
5408  bool key(string_t& val)
5409  {
5410  // add null at given key and store the reference for later
5411  object_element = &(ref_stack.back()->m_value.object->operator[](val));
5412  return true;
5413  }
5414 
5415  bool end_object()
5416  {
5417  ref_stack.pop_back();
5418  return true;
5419  }
5420 
5421  bool start_array(std::size_t len)
5422  {
5423  ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
5424 
5425  if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5426  {
5427  JSON_THROW(out_of_range::create(408,
5428  "excessive array size: " + std::to_string(len)));
5429  }
5430 
5431  return true;
5432  }
5433 
5434  bool end_array()
5435  {
5436  ref_stack.pop_back();
5437  return true;
5438  }
5439 
5440  template<class Exception>
5441  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
5442  const Exception& ex)
5443  {
5444  errored = true;
5445  static_cast<void>(ex);
5446  if (allow_exceptions)
5447  {
5448  JSON_THROW(ex);
5449  }
5450  return false;
5451  }
5452 
5453  constexpr bool is_errored() const
5454  {
5455  return errored;
5456  }
5457 
5458  private:
5465  template<typename Value>
5466  JSON_HEDLEY_RETURNS_NON_NULL
5467  BasicJsonType* handle_value(Value&& v)
5468  {
5469  if (ref_stack.empty())
5470  {
5471  root = BasicJsonType(std::forward<Value>(v));
5472  return &root;
5473  }
5474 
5475  JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5476 
5477  if (ref_stack.back()->is_array())
5478  {
5479  ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
5480  return &(ref_stack.back()->m_value.array->back());
5481  }
5482 
5483  JSON_ASSERT(ref_stack.back()->is_object());
5485  *object_element = BasicJsonType(std::forward<Value>(v));
5486  return object_element;
5487  }
5488 
5490  BasicJsonType& root;
5492  std::vector<BasicJsonType*> ref_stack {};
5494  BasicJsonType* object_element = nullptr;
5496  bool errored = false;
5498  const bool allow_exceptions = true;
5499 };
5500 
5501 template<typename BasicJsonType>
5503 {
5504  public:
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;
5512 
5514  const parser_callback_t cb,
5515  const bool allow_exceptions_ = true)
5516  : root(r), callback(cb), allow_exceptions(allow_exceptions_)
5517  {
5518  keep_stack.push_back(true);
5519  }
5520 
5521  // make class move-only
5527 
5528  bool null()
5529  {
5530  handle_value(nullptr);
5531  return true;
5532  }
5533 
5534  bool boolean(bool val)
5535  {
5536  handle_value(val);
5537  return true;
5538  }
5539 
5541  {
5542  handle_value(val);
5543  return true;
5544  }
5545 
5547  {
5548  handle_value(val);
5549  return true;
5550  }
5551 
5552  bool number_float(number_float_t val, const string_t& /*unused*/)
5553  {
5554  handle_value(val);
5555  return true;
5556  }
5557 
5558  bool string(string_t& val)
5559  {
5560  handle_value(val);
5561  return true;
5562  }
5563 
5564  bool binary(binary_t& val)
5565  {
5566  handle_value(std::move(val));
5567  return true;
5568  }
5569 
5570  bool start_object(std::size_t len)
5571  {
5572  // check callback for object start
5573  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
5574  keep_stack.push_back(keep);
5575 
5576  auto val = handle_value(BasicJsonType::value_t::object, true);
5577  ref_stack.push_back(val.second);
5578 
5579  // check object limit
5580  if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5581  {
5582  JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
5583  }
5584 
5585  return true;
5586  }
5587 
5588  bool key(string_t& val)
5589  {
5590  BasicJsonType k = BasicJsonType(val);
5591 
5592  // check callback for key
5593  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
5594  key_keep_stack.push_back(keep);
5595 
5596  // add discarded value at given key and store the reference for later
5597  if (keep && ref_stack.back())
5598  {
5599  object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
5600  }
5601 
5602  return true;
5603  }
5604 
5605  bool end_object()
5606  {
5607  if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
5608  {
5609  // discard object
5610  *ref_stack.back() = discarded;
5611  }
5612 
5613  JSON_ASSERT(!ref_stack.empty());
5614  JSON_ASSERT(!keep_stack.empty());
5615  ref_stack.pop_back();
5616  keep_stack.pop_back();
5617 
5618  if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
5619  {
5620  // remove discarded value
5621  for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
5622  {
5623  if (it->is_discarded())
5624  {
5625  ref_stack.back()->erase(it);
5626  break;
5627  }
5628  }
5629  }
5630 
5631  return true;
5632  }
5633 
5634  bool start_array(std::size_t len)
5635  {
5636  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
5637  keep_stack.push_back(keep);
5638 
5639  auto val = handle_value(BasicJsonType::value_t::array, true);
5640  ref_stack.push_back(val.second);
5641 
5642  // check array limit
5643  if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5644  {
5645  JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
5646  }
5647 
5648  return true;
5649  }
5650 
5651  bool end_array()
5652  {
5653  bool keep = true;
5654 
5655  if (ref_stack.back())
5656  {
5657  keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
5658  if (!keep)
5659  {
5660  // discard array
5661  *ref_stack.back() = discarded;
5662  }
5663  }
5664 
5665  JSON_ASSERT(!ref_stack.empty());
5666  JSON_ASSERT(!keep_stack.empty());
5667  ref_stack.pop_back();
5668  keep_stack.pop_back();
5669 
5670  // remove discarded value
5671  if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
5672  {
5673  ref_stack.back()->m_value.array->pop_back();
5674  }
5675 
5676  return true;
5677  }
5678 
5679  template<class Exception>
5680  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
5681  const Exception& ex)
5682  {
5683  errored = true;
5684  static_cast<void>(ex);
5685  if (allow_exceptions)
5686  {
5687  JSON_THROW(ex);
5688  }
5689  return false;
5690  }
5691 
5692  constexpr bool is_errored() const
5693  {
5694  return errored;
5695  }
5696 
5697  private:
5713  template<typename Value>
5714  std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
5715  {
5716  JSON_ASSERT(!keep_stack.empty());
5717 
5718  // do not handle this value if we know it would be added to a discarded
5719  // container
5720  if (!keep_stack.back())
5721  {
5722  return {false, nullptr};
5723  }
5724 
5725  // create value
5726  auto value = BasicJsonType(std::forward<Value>(v));
5727 
5728  // check callback
5729  const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
5730 
5731  // do not handle this value if we just learnt it shall be discarded
5732  if (!keep)
5733  {
5734  return {false, nullptr};
5735  }
5736 
5737  if (ref_stack.empty())
5738  {
5739  root = std::move(value);
5740  return {true, &root};
5741  }
5742 
5743  // skip this value if we already decided to skip the parent
5744  // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
5745  if (!ref_stack.back())
5746  {
5747  return {false, nullptr};
5748  }
5749 
5750  // we now only expect arrays and objects
5751  JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5752 
5753  // array
5754  if (ref_stack.back()->is_array())
5755  {
5756  ref_stack.back()->m_value.array->push_back(std::move(value));
5757  return {true, &(ref_stack.back()->m_value.array->back())};
5758  }
5759 
5760  // object
5761  JSON_ASSERT(ref_stack.back()->is_object());
5762  // check if we should store an element for the current key
5763  JSON_ASSERT(!key_keep_stack.empty());
5764  const bool store_element = key_keep_stack.back();
5765  key_keep_stack.pop_back();
5766 
5767  if (!store_element)
5768  {
5769  return {false, nullptr};
5770  }
5771 
5773  *object_element = std::move(value);
5774  return {true, object_element};
5775  }
5776 
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;
5795 };
5796 
5797 template<typename BasicJsonType>
5799 {
5800  public:
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;
5806 
5807  bool null()
5808  {
5809  return true;
5810  }
5811 
5812  bool boolean(bool /*unused*/)
5813  {
5814  return true;
5815  }
5816 
5818  {
5819  return true;
5820  }
5821 
5823  {
5824  return true;
5825  }
5826 
5827  bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
5828  {
5829  return true;
5830  }
5831 
5832  bool string(string_t& /*unused*/)
5833  {
5834  return true;
5835  }
5836 
5837  bool binary(binary_t& /*unused*/)
5838  {
5839  return true;
5840  }
5841 
5842  bool start_object(std::size_t /*unused*/ = std::size_t(-1))
5843  {
5844  return true;
5845  }
5846 
5847  bool key(string_t& /*unused*/)
5848  {
5849  return true;
5850  }
5851 
5852  bool end_object()
5853  {
5854  return true;
5855  }
5856 
5857  bool start_array(std::size_t /*unused*/ = std::size_t(-1))
5858  {
5859  return true;
5860  }
5861 
5862  bool end_array()
5863  {
5864  return true;
5865  }
5866 
5867  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
5868  {
5869  return false;
5870  }
5871 };
5872 } // namespace detail
5873 
5874 } // namespace nlohmann
5875 
5876 // #include <nlohmann/detail/input/lexer.hpp>
5877 
5878 
5879 #include <array> // array
5880 #include <clocale> // localeconv
5881 #include <cstddef> // size_t
5882 #include <cstdio> // snprintf
5883 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
5884 #include <initializer_list> // initializer_list
5885 #include <string> // char_traits, string
5886 #include <utility> // move
5887 #include <vector> // vector
5888 
5889 // #include <nlohmann/detail/input/input_adapters.hpp>
5890 
5891 // #include <nlohmann/detail/input/position_t.hpp>
5892 
5893 // #include <nlohmann/detail/macro_scope.hpp>
5894 
5895 
5896 namespace nlohmann
5897 {
5898 namespace detail
5899 {
5901 // lexer //
5903 
5904 template<typename BasicJsonType>
5906 {
5907  public:
5909  enum class token_type
5910  {
5911  uninitialized,
5912  literal_true,
5913  literal_false,
5914  literal_null,
5915  value_string,
5916  value_unsigned,
5917  value_integer,
5918  value_float,
5919  begin_array,
5920  begin_object,
5921  end_array,
5922  end_object,
5923  name_separator,
5924  value_separator,
5925  parse_error,
5926  end_of_input,
5928  };
5929 
5931  JSON_HEDLEY_RETURNS_NON_NULL
5932  JSON_HEDLEY_CONST
5933  static const char* token_type_name(const token_type t) noexcept
5934  {
5935  switch (t)
5936  {
5938  return "<uninitialized>";
5940  return "true literal";
5942  return "false literal";
5944  return "null literal";
5946  return "string literal";
5950  return "number literal";
5952  return "'['";
5954  return "'{'";
5955  case token_type::end_array:
5956  return "']'";
5958  return "'}'";
5960  return "':'";
5962  return "','";
5964  return "<parse error>";
5966  return "end of input";
5968  return "'[', '{', or a literal";
5969  // LCOV_EXCL_START
5970  default: // catch non-enum values
5971  return "unknown token";
5972  // LCOV_EXCL_STOP
5973  }
5974  }
5975 };
5981 template<typename BasicJsonType, typename InputAdapterType>
5982 class lexer : public lexer_base<BasicJsonType>
5983 {
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;
5990 
5991  public:
5993 
5994  explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
5995  : ia(std::move(adapter))
5996  , ignore_comments(ignore_comments_)
5998  {}
5999 
6000  // delete because of pointer members
6001  lexer(const lexer&) = delete;
6002  lexer(lexer&&) = default;
6003  lexer& operator=(lexer&) = delete;
6004  lexer& operator=(lexer&&) = default;
6005  ~lexer() = default;
6006 
6007  private:
6009  // locales
6011 
6013  JSON_HEDLEY_PURE
6015  {
6016  const auto* loc = localeconv();
6017  JSON_ASSERT(loc != nullptr);
6018  return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
6019  }
6020 
6022  // scan functions
6024 
6041  {
6042  // this function only makes sense after reading `\u`
6043  JSON_ASSERT(current == 'u');
6044  int codepoint = 0;
6045 
6046  const auto factors = { 12u, 8u, 4u, 0u };
6047  for (const auto factor : factors)
6048  {
6049  get();
6050 
6051  if (current >= '0' && current <= '9')
6052  {
6053  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
6054  }
6055  else if (current >= 'A' && current <= 'F')
6056  {
6057  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
6058  }
6059  else if (current >= 'a' && current <= 'f')
6060  {
6061  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
6062  }
6063  else
6064  {
6065  return -1;
6066  }
6067  }
6068 
6069  JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6070  return codepoint;
6071  }
6072 
6088  bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6089  {
6090  JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6091  add(current);
6092 
6093  for (auto range = ranges.begin(); range != ranges.end(); ++range)
6094  {
6095  get();
6096  if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6097  {
6098  add(current);
6099  }
6100  else
6101  {
6102  error_message = "invalid string: ill-formed UTF-8 byte";
6103  return false;
6104  }
6105  }
6106 
6107  return true;
6108  }
6109 
6126  {
6127  // reset token_buffer (ignore opening quote)
6128  reset();
6129 
6130  // we entered the function by reading an open quote
6131  JSON_ASSERT(current == '\"');
6132 
6133  while (true)
6134  {
6135  // get next character
6136  switch (get())
6137  {
6138  // end of file while parsing string
6139  case std::char_traits<char_type>::eof():
6140  {
6141  error_message = "invalid string: missing closing quote";
6142  return token_type::parse_error;
6143  }
6144 
6145  // closing quote
6146  case '\"':
6147  {
6148  return token_type::value_string;
6149  }
6150 
6151  // escapes
6152  case '\\':
6153  {
6154  switch (get())
6155  {
6156  // quotation mark
6157  case '\"':
6158  add('\"');
6159  break;
6160  // reverse solidus
6161  case '\\':
6162  add('\\');
6163  break;
6164  // solidus
6165  case '/':
6166  add('/');
6167  break;
6168  // backspace
6169  case 'b':
6170  add('\b');
6171  break;
6172  // form feed
6173  case 'f':
6174  add('\f');
6175  break;
6176  // line feed
6177  case 'n':
6178  add('\n');
6179  break;
6180  // carriage return
6181  case 'r':
6182  add('\r');
6183  break;
6184  // tab
6185  case 't':
6186  add('\t');
6187  break;
6188 
6189  // unicode escapes
6190  case 'u':
6191  {
6192  const int codepoint1 = get_codepoint();
6193  int codepoint = codepoint1; // start with codepoint1
6194 
6195  if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6196  {
6197  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6198  return token_type::parse_error;
6199  }
6200 
6201  // check if code point is a high surrogate
6202  if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6203  {
6204  // expect next \uxxxx entry
6205  if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
6206  {
6207  const int codepoint2 = get_codepoint();
6208 
6209  if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6210  {
6211  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6212  return token_type::parse_error;
6213  }
6214 
6215  // check if codepoint2 is a low surrogate
6216  if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6217  {
6218  // overwrite codepoint
6219  codepoint = static_cast<int>(
6220  // high surrogate occupies the most significant 22 bits
6221  (static_cast<unsigned int>(codepoint1) << 10u)
6222  // low surrogate occupies the least significant 15 bits
6223  + static_cast<unsigned int>(codepoint2)
6224  // there is still the 0xD800, 0xDC00 and 0x10000 noise
6225  // in the result so we have to subtract with:
6226  // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
6227  - 0x35FDC00u);
6228  }
6229  else
6230  {
6231  error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6232  return token_type::parse_error;
6233  }
6234  }
6235  else
6236  {
6237  error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6238  return token_type::parse_error;
6239  }
6240  }
6241  else
6242  {
6243  if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6244  {
6245  error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6246  return token_type::parse_error;
6247  }
6248  }
6249 
6250  // result of the above calculation yields a proper codepoint
6251  JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6252 
6253  // translate codepoint into bytes
6254  if (codepoint < 0x80)
6255  {
6256  // 1-byte characters: 0xxxxxxx (ASCII)
6257  add(static_cast<char_int_type>(codepoint));
6258  }
6259  else if (codepoint <= 0x7FF)
6260  {
6261  // 2-byte characters: 110xxxxx 10xxxxxx
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)));
6264  }
6265  else if (codepoint <= 0xFFFF)
6266  {
6267  // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
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)));
6271  }
6272  else
6273  {
6274  // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
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)));
6279  }
6280 
6281  break;
6282  }
6283 
6284  // other characters after escape
6285  default:
6286  error_message = "invalid string: forbidden character after backslash";
6287  return token_type::parse_error;
6288  }
6289 
6290  break;
6291  }
6292 
6293  // invalid control characters
6294  case 0x00:
6295  {
6296  error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6297  return token_type::parse_error;
6298  }
6299 
6300  case 0x01:
6301  {
6302  error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6303  return token_type::parse_error;
6304  }
6305 
6306  case 0x02:
6307  {
6308  error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6309  return token_type::parse_error;
6310  }
6311 
6312  case 0x03:
6313  {
6314  error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6315  return token_type::parse_error;
6316  }
6317 
6318  case 0x04:
6319  {
6320  error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6321  return token_type::parse_error;
6322  }
6323 
6324  case 0x05:
6325  {
6326  error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6327  return token_type::parse_error;
6328  }
6329 
6330  case 0x06:
6331  {
6332  error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6333  return token_type::parse_error;
6334  }
6335 
6336  case 0x07:
6337  {
6338  error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6339  return token_type::parse_error;
6340  }
6341 
6342  case 0x08:
6343  {
6344  error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6345  return token_type::parse_error;
6346  }
6347 
6348  case 0x09:
6349  {
6350  error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6351  return token_type::parse_error;
6352  }
6353 
6354  case 0x0A:
6355  {
6356  error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6357  return token_type::parse_error;
6358  }
6359 
6360  case 0x0B:
6361  {
6362  error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
6363  return token_type::parse_error;
6364  }
6365 
6366  case 0x0C:
6367  {
6368  error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
6369  return token_type::parse_error;
6370  }
6371 
6372  case 0x0D:
6373  {
6374  error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
6375  return token_type::parse_error;
6376  }
6377 
6378  case 0x0E:
6379  {
6380  error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
6381  return token_type::parse_error;
6382  }
6383 
6384  case 0x0F:
6385  {
6386  error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
6387  return token_type::parse_error;
6388  }
6389 
6390  case 0x10:
6391  {
6392  error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
6393  return token_type::parse_error;
6394  }
6395 
6396  case 0x11:
6397  {
6398  error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
6399  return token_type::parse_error;
6400  }
6401 
6402  case 0x12:
6403  {
6404  error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
6405  return token_type::parse_error;
6406  }
6407 
6408  case 0x13:
6409  {
6410  error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
6411  return token_type::parse_error;
6412  }
6413 
6414  case 0x14:
6415  {
6416  error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
6417  return token_type::parse_error;
6418  }
6419 
6420  case 0x15:
6421  {
6422  error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
6423  return token_type::parse_error;
6424  }
6425 
6426  case 0x16:
6427  {
6428  error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
6429  return token_type::parse_error;
6430  }
6431 
6432  case 0x17:
6433  {
6434  error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
6435  return token_type::parse_error;
6436  }
6437 
6438  case 0x18:
6439  {
6440  error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
6441  return token_type::parse_error;
6442  }
6443 
6444  case 0x19:
6445  {
6446  error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
6447  return token_type::parse_error;
6448  }
6449 
6450  case 0x1A:
6451  {
6452  error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
6453  return token_type::parse_error;
6454  }
6455 
6456  case 0x1B:
6457  {
6458  error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
6459  return token_type::parse_error;
6460  }
6461 
6462  case 0x1C:
6463  {
6464  error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
6465  return token_type::parse_error;
6466  }
6467 
6468  case 0x1D:
6469  {
6470  error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
6471  return token_type::parse_error;
6472  }
6473 
6474  case 0x1E:
6475  {
6476  error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
6477  return token_type::parse_error;
6478  }
6479 
6480  case 0x1F:
6481  {
6482  error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
6483  return token_type::parse_error;
6484  }
6485 
6486  // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
6487  case 0x20:
6488  case 0x21:
6489  case 0x23:
6490  case 0x24:
6491  case 0x25:
6492  case 0x26:
6493  case 0x27:
6494  case 0x28:
6495  case 0x29:
6496  case 0x2A:
6497  case 0x2B:
6498  case 0x2C:
6499  case 0x2D:
6500  case 0x2E:
6501  case 0x2F:
6502  case 0x30:
6503  case 0x31:
6504  case 0x32:
6505  case 0x33:
6506  case 0x34:
6507  case 0x35:
6508  case 0x36:
6509  case 0x37:
6510  case 0x38:
6511  case 0x39:
6512  case 0x3A:
6513  case 0x3B:
6514  case 0x3C:
6515  case 0x3D:
6516  case 0x3E:
6517  case 0x3F:
6518  case 0x40:
6519  case 0x41:
6520  case 0x42:
6521  case 0x43:
6522  case 0x44:
6523  case 0x45:
6524  case 0x46:
6525  case 0x47:
6526  case 0x48:
6527  case 0x49:
6528  case 0x4A:
6529  case 0x4B:
6530  case 0x4C:
6531  case 0x4D:
6532  case 0x4E:
6533  case 0x4F:
6534  case 0x50:
6535  case 0x51:
6536  case 0x52:
6537  case 0x53:
6538  case 0x54:
6539  case 0x55:
6540  case 0x56:
6541  case 0x57:
6542  case 0x58:
6543  case 0x59:
6544  case 0x5A:
6545  case 0x5B:
6546  case 0x5D:
6547  case 0x5E:
6548  case 0x5F:
6549  case 0x60:
6550  case 0x61:
6551  case 0x62:
6552  case 0x63:
6553  case 0x64:
6554  case 0x65:
6555  case 0x66:
6556  case 0x67:
6557  case 0x68:
6558  case 0x69:
6559  case 0x6A:
6560  case 0x6B:
6561  case 0x6C:
6562  case 0x6D:
6563  case 0x6E:
6564  case 0x6F:
6565  case 0x70:
6566  case 0x71:
6567  case 0x72:
6568  case 0x73:
6569  case 0x74:
6570  case 0x75:
6571  case 0x76:
6572  case 0x77:
6573  case 0x78:
6574  case 0x79:
6575  case 0x7A:
6576  case 0x7B:
6577  case 0x7C:
6578  case 0x7D:
6579  case 0x7E:
6580  case 0x7F:
6581  {
6582  add(current);
6583  break;
6584  }
6585 
6586  // U+0080..U+07FF: bytes C2..DF 80..BF
6587  case 0xC2:
6588  case 0xC3:
6589  case 0xC4:
6590  case 0xC5:
6591  case 0xC6:
6592  case 0xC7:
6593  case 0xC8:
6594  case 0xC9:
6595  case 0xCA:
6596  case 0xCB:
6597  case 0xCC:
6598  case 0xCD:
6599  case 0xCE:
6600  case 0xCF:
6601  case 0xD0:
6602  case 0xD1:
6603  case 0xD2:
6604  case 0xD3:
6605  case 0xD4:
6606  case 0xD5:
6607  case 0xD6:
6608  case 0xD7:
6609  case 0xD8:
6610  case 0xD9:
6611  case 0xDA:
6612  case 0xDB:
6613  case 0xDC:
6614  case 0xDD:
6615  case 0xDE:
6616  case 0xDF:
6617  {
6618  if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
6619  {
6620  return token_type::parse_error;
6621  }
6622  break;
6623  }
6624 
6625  // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
6626  case 0xE0:
6627  {
6628  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
6629  {
6630  return token_type::parse_error;
6631  }
6632  break;
6633  }
6634 
6635  // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
6636  // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
6637  case 0xE1:
6638  case 0xE2:
6639  case 0xE3:
6640  case 0xE4:
6641  case 0xE5:
6642  case 0xE6:
6643  case 0xE7:
6644  case 0xE8:
6645  case 0xE9:
6646  case 0xEA:
6647  case 0xEB:
6648  case 0xEC:
6649  case 0xEE:
6650  case 0xEF:
6651  {
6652  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
6653  {
6654  return token_type::parse_error;
6655  }
6656  break;
6657  }
6658 
6659  // U+D000..U+D7FF: bytes ED 80..9F 80..BF
6660  case 0xED:
6661  {
6662  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
6663  {
6664  return token_type::parse_error;
6665  }
6666  break;
6667  }
6668 
6669  // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
6670  case 0xF0:
6671  {
6672  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
6673  {
6674  return token_type::parse_error;
6675  }
6676  break;
6677  }
6678 
6679  // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
6680  case 0xF1:
6681  case 0xF2:
6682  case 0xF3:
6683  {
6684  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
6685  {
6686  return token_type::parse_error;
6687  }
6688  break;
6689  }
6690 
6691  // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
6692  case 0xF4:
6693  {
6694  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
6695  {
6696  return token_type::parse_error;
6697  }
6698  break;
6699  }
6700 
6701  // remaining bytes (80..C1 and F5..FF) are ill-formed
6702  default:
6703  {
6704  error_message = "invalid string: ill-formed UTF-8 byte";
6705  return token_type::parse_error;
6706  }
6707  }
6708  }
6709  }
6710 
6716  {
6717  switch (get())
6718  {
6719  // single-line comments skip input until a newline or EOF is read
6720  case '/':
6721  {
6722  while (true)
6723  {
6724  switch (get())
6725  {
6726  case '\n':
6727  case '\r':
6728  case std::char_traits<char_type>::eof():
6729  case '\0':
6730  return true;
6731 
6732  default:
6733  break;
6734  }
6735  }
6736  }
6737 
6738  // multi-line comments skip input until */ is read
6739  case '*':
6740  {
6741  while (true)
6742  {
6743  switch (get())
6744  {
6745  case std::char_traits<char_type>::eof():
6746  case '\0':
6747  {
6748  error_message = "invalid comment; missing closing '*/'";
6749  return false;
6750  }
6751 
6752  case '*':
6753  {
6754  switch (get())
6755  {
6756  case '/':
6757  return true;
6758 
6759  default:
6760  {
6761  unget();
6762  continue;
6763  }
6764  }
6765  }
6766 
6767  default:
6768  continue;
6769  }
6770  }
6771  }
6772 
6773  // unexpected character after reading '/'
6774  default:
6775  {
6776  error_message = "invalid comment; expecting '/' or '*' after '/'";
6777  return false;
6778  }
6779  }
6780  }
6781 
6783  static void strtof(float& f, const char* str, char** endptr) noexcept
6784  {
6785  f = std::strtof(str, endptr);
6786  }
6787 
6789  static void strtof(double& f, const char* str, char** endptr) noexcept
6790  {
6791  f = std::strtod(str, endptr);
6792  }
6793 
6795  static void strtof(long double& f, const char* str, char** endptr) noexcept
6796  {
6797  f = std::strtold(str, endptr);
6798  }
6799 
6840  token_type scan_number() // lgtm [cpp/use-of-goto]
6841  {
6842  // reset token_buffer to store the number's bytes
6843  reset();
6844 
6845  // the type of the parsed number; initially set to unsigned; will be
6846  // changed if minus sign, decimal point or exponent is read
6847  token_type number_type = token_type::value_unsigned;
6848 
6849  // state (init): we just found out we need to scan a number
6850  switch (current)
6851  {
6852  case '-':
6853  {
6854  add(current);
6855  goto scan_number_minus;
6856  }
6857 
6858  case '0':
6859  {
6860  add(current);
6861  goto scan_number_zero;
6862  }
6863 
6864  case '1':
6865  case '2':
6866  case '3':
6867  case '4':
6868  case '5':
6869  case '6':
6870  case '7':
6871  case '8':
6872  case '9':
6873  {
6874  add(current);
6875  goto scan_number_any1;
6876  }
6877 
6878  // all other characters are rejected outside scan_number()
6879  default: // LCOV_EXCL_LINE
6880  JSON_ASSERT(false); // LCOV_EXCL_LINE
6881  }
6882 
6883 scan_number_minus:
6884  // state: we just parsed a leading minus sign
6885  number_type = token_type::value_integer;
6886  switch (get())
6887  {
6888  case '0':
6889  {
6890  add(current);
6891  goto scan_number_zero;
6892  }
6893 
6894  case '1':
6895  case '2':
6896  case '3':
6897  case '4':
6898  case '5':
6899  case '6':
6900  case '7':
6901  case '8':
6902  case '9':
6903  {
6904  add(current);
6905  goto scan_number_any1;
6906  }
6907 
6908  default:
6909  {
6910  error_message = "invalid number; expected digit after '-'";
6911  return token_type::parse_error;
6912  }
6913  }
6914 
6915 scan_number_zero:
6916  // state: we just parse a zero (maybe with a leading minus sign)
6917  switch (get())
6918  {
6919  case '.':
6920  {
6922  goto scan_number_decimal1;
6923  }
6924 
6925  case 'e':
6926  case 'E':
6927  {
6928  add(current);
6929  goto scan_number_exponent;
6930  }
6931 
6932  default:
6933  goto scan_number_done;
6934  }
6935 
6936 scan_number_any1:
6937  // state: we just parsed a number 0-9 (maybe with a leading minus sign)
6938  switch (get())
6939  {
6940  case '0':
6941  case '1':
6942  case '2':
6943  case '3':
6944  case '4':
6945  case '5':
6946  case '6':
6947  case '7':
6948  case '8':
6949  case '9':
6950  {
6951  add(current);
6952  goto scan_number_any1;
6953  }
6954 
6955  case '.':
6956  {
6958  goto scan_number_decimal1;
6959  }
6960 
6961  case 'e':
6962  case 'E':
6963  {
6964  add(current);
6965  goto scan_number_exponent;
6966  }
6967 
6968  default:
6969  goto scan_number_done;
6970  }
6971 
6972 scan_number_decimal1:
6973  // state: we just parsed a decimal point
6974  number_type = token_type::value_float;
6975  switch (get())
6976  {
6977  case '0':
6978  case '1':
6979  case '2':
6980  case '3':
6981  case '4':
6982  case '5':
6983  case '6':
6984  case '7':
6985  case '8':
6986  case '9':
6987  {
6988  add(current);
6989  goto scan_number_decimal2;
6990  }
6991 
6992  default:
6993  {
6994  error_message = "invalid number; expected digit after '.'";
6995  return token_type::parse_error;
6996  }
6997  }
6998 
6999 scan_number_decimal2:
7000  // we just parsed at least one number after a decimal point
7001  switch (get())
7002  {
7003  case '0':
7004  case '1':
7005  case '2':
7006  case '3':
7007  case '4':
7008  case '5':
7009  case '6':
7010  case '7':
7011  case '8':
7012  case '9':
7013  {
7014  add(current);
7015  goto scan_number_decimal2;
7016  }
7017 
7018  case 'e':
7019  case 'E':
7020  {
7021  add(current);
7022  goto scan_number_exponent;
7023  }
7024 
7025  default:
7026  goto scan_number_done;
7027  }
7028 
7029 scan_number_exponent:
7030  // we just parsed an exponent
7031  number_type = token_type::value_float;
7032  switch (get())
7033  {
7034  case '+':
7035  case '-':
7036  {
7037  add(current);
7038  goto scan_number_sign;
7039  }
7040 
7041  case '0':
7042  case '1':
7043  case '2':
7044  case '3':
7045  case '4':
7046  case '5':
7047  case '6':
7048  case '7':
7049  case '8':
7050  case '9':
7051  {
7052  add(current);
7053  goto scan_number_any2;
7054  }
7055 
7056  default:
7057  {
7058  error_message =
7059  "invalid number; expected '+', '-', or digit after exponent";
7060  return token_type::parse_error;
7061  }
7062  }
7063 
7064 scan_number_sign:
7065  // we just parsed an exponent sign
7066  switch (get())
7067  {
7068  case '0':
7069  case '1':
7070  case '2':
7071  case '3':
7072  case '4':
7073  case '5':
7074  case '6':
7075  case '7':
7076  case '8':
7077  case '9':
7078  {
7079  add(current);
7080  goto scan_number_any2;
7081  }
7082 
7083  default:
7084  {
7085  error_message = "invalid number; expected digit after exponent sign";
7086  return token_type::parse_error;
7087  }
7088  }
7089 
7090 scan_number_any2:
7091  // we just parsed a number after the exponent or exponent sign
7092  switch (get())
7093  {
7094  case '0':
7095  case '1':
7096  case '2':
7097  case '3':
7098  case '4':
7099  case '5':
7100  case '6':
7101  case '7':
7102  case '8':
7103  case '9':
7104  {
7105  add(current);
7106  goto scan_number_any2;
7107  }
7108 
7109  default:
7110  goto scan_number_done;
7111  }
7112 
7113 scan_number_done:
7114  // unget the character after the number (we only read it to know that
7115  // we are done scanning a number)
7116  unget();
7117 
7118  char* endptr = nullptr;
7119  errno = 0;
7120 
7121  // try to parse integers first and fall back to floats
7122  if (number_type == token_type::value_unsigned)
7123  {
7124  const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7125 
7126  // we checked the number format before
7127  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7128 
7129  if (errno == 0)
7130  {
7131  value_unsigned = static_cast<number_unsigned_t>(x);
7132  if (value_unsigned == x)
7133  {
7134  return token_type::value_unsigned;
7135  }
7136  }
7137  }
7138  else if (number_type == token_type::value_integer)
7139  {
7140  const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7141 
7142  // we checked the number format before
7143  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7144 
7145  if (errno == 0)
7146  {
7147  value_integer = static_cast<number_integer_t>(x);
7148  if (value_integer == x)
7149  {
7150  return token_type::value_integer;
7151  }
7152  }
7153  }
7154 
7155  // this code is reached if we parse a floating-point number or if an
7156  // integer conversion above failed
7157  strtof(value_float, token_buffer.data(), &endptr);
7158 
7159  // we checked the number format before
7160  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7161 
7162  return token_type::value_float;
7163  }
7164 
7171  token_type scan_literal(const char_type* literal_text, const std::size_t length,
7173  {
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)
7176  {
7177  if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7178  {
7179  error_message = "invalid literal";
7180  return token_type::parse_error;
7181  }
7182  }
7183  return return_type;
7184  }
7185 
7187  // input management
7189 
7192  {
7193  token_buffer.clear();
7194  token_string.clear();
7195  token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7196  }
7197 
7198  /*
7199  @brief get next character from the input
7200 
7201  This function provides the interface to the used input adapter. It does
7202  not throw in case the input reached EOF, but returns a
7203  `std::char_traits<char>::eof()` in that case. Stores the scanned characters
7204  for use in error messages.
7205 
7206  @return character read from the input
7207  */
7209  {
7212 
7213  if (next_unget)
7214  {
7215  // just reset the next_unget variable and work with current
7216  next_unget = false;
7217  }
7218  else
7219  {
7220  current = ia.get_character();
7221  }
7222 
7223  if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7224  {
7225  token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7226  }
7227 
7228  if (current == '\n')
7229  {
7230  ++position.lines_read;
7232  }
7233 
7234  return current;
7235  }
7236 
7245  void unget()
7246  {
7247  next_unget = true;
7248 
7250 
7251  // in case we "unget" a newline, we have to also decrement the lines_read
7253  {
7254  if (position.lines_read > 0)
7255  {
7256  --position.lines_read;
7257  }
7258  }
7259  else
7260  {
7262  }
7263 
7264  if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7265  {
7266  JSON_ASSERT(!token_string.empty());
7267  token_string.pop_back();
7268  }
7269  }
7270 
7273  {
7274  token_buffer.push_back(static_cast<typename string_t::value_type>(c));
7275  }
7276 
7277  public:
7279  // value getters
7281 
7284  {
7285  return value_integer;
7286  }
7287 
7290  {
7291  return value_unsigned;
7292  }
7293 
7296  {
7297  return value_float;
7298  }
7299 
7302  {
7303  return token_buffer;
7304  }
7305 
7307  // diagnostics
7309 
7312  {
7313  return position;
7314  }
7315 
7319  std::string get_token_string() const
7320  {
7321  // escape control characters
7322  std::string result;
7323  for (const auto c : token_string)
7324  {
7325  if (static_cast<unsigned char>(c) <= '\x1F')
7326  {
7327  // escape control characters
7328  std::array<char, 9> cs{{}};
7329  (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
7330  result += cs.data();
7331  }
7332  else
7333  {
7334  // add character as is
7335  result.push_back(static_cast<std::string::value_type>(c));
7336  }
7337  }
7338 
7339  return result;
7340  }
7341 
7343  JSON_HEDLEY_RETURNS_NON_NULL
7344  constexpr const char* get_error_message() const noexcept
7345  {
7346  return error_message;
7347  }
7348 
7350  // actual scanner
7352 
7357  bool skip_bom()
7358  {
7359  if (get() == 0xEF)
7360  {
7361  // check if we completely parse the BOM
7362  return get() == 0xBB && get() == 0xBF;
7363  }
7364 
7365  // the first character is not the beginning of the BOM; unget it to
7366  // process is later
7367  unget();
7368  return true;
7369  }
7370 
7372  {
7373  do
7374  {
7375  get();
7376  }
7377  while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
7378  }
7379 
7381  {
7382  // initially, skip the BOM
7383  if (position.chars_read_total == 0 && !skip_bom())
7384  {
7385  error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
7386  return token_type::parse_error;
7387  }
7388 
7389  // read next character and ignore whitespace
7390  skip_whitespace();
7391 
7392  // ignore comments
7393  while (ignore_comments && current == '/')
7394  {
7395  if (!scan_comment())
7396  {
7397  return token_type::parse_error;
7398  }
7399 
7400  // skip following whitespace
7401  skip_whitespace();
7402  }
7403 
7404  switch (current)
7405  {
7406  // structural characters
7407  case '[':
7408  return token_type::begin_array;
7409  case ']':
7410  return token_type::end_array;
7411  case '{':
7412  return token_type::begin_object;
7413  case '}':
7414  return token_type::end_object;
7415  case ':':
7416  return token_type::name_separator;
7417  case ',':
7418  return token_type::value_separator;
7419 
7420  // literals
7421  case 't':
7422  {
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);
7425  }
7426  case 'f':
7427  {
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);
7430  }
7431  case 'n':
7432  {
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);
7435  }
7436 
7437  // string
7438  case '\"':
7439  return scan_string();
7440 
7441  // number
7442  case '-':
7443  case '0':
7444  case '1':
7445  case '2':
7446  case '3':
7447  case '4':
7448  case '5':
7449  case '6':
7450  case '7':
7451  case '8':
7452  case '9':
7453  return scan_number();
7454 
7455  // end of input (the null byte is needed when parsing from
7456  // string literals)
7457  case '\0':
7458  case std::char_traits<char_type>::eof():
7459  return token_type::end_of_input;
7460 
7461  // error
7462  default:
7463  error_message = "invalid literal";
7464  return token_type::parse_error;
7465  }
7466  }
7467 
7468  private:
7470  InputAdapterType ia;
7471 
7473  const bool ignore_comments = false;
7474 
7476  char_int_type current = std::char_traits<char_type>::eof();
7477 
7479  bool next_unget = false;
7480 
7483 
7485  std::vector<char_type> token_string {};
7486 
7489 
7491  const char* error_message = "";
7492 
7493  // number values
7497 
7500 };
7501 } // namespace detail
7502 } // namespace nlohmann
7503 
7504 // #include <nlohmann/detail/macro_scope.hpp>
7505 
7506 // #include <nlohmann/detail/meta/is_sax.hpp>
7507 
7508 
7509 #include <cstdint> // size_t
7510 #include <utility> // declval
7511 #include <string> // string
7512 
7513 // #include <nlohmann/detail/meta/detected.hpp>
7514 
7515 // #include <nlohmann/detail/meta/type_traits.hpp>
7516 
7517 
7518 namespace nlohmann
7519 {
7520 namespace detail
7521 {
7522 template<typename T>
7523 using null_function_t = decltype(std::declval<T&>().null());
7524 
7525 template<typename T>
7527  decltype(std::declval<T&>().boolean(std::declval<bool>()));
7528 
7529 template<typename T, typename Integer>
7531  decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
7532 
7533 template<typename T, typename Unsigned>
7535  decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
7536 
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&>()));
7540 
7541 template<typename T, typename String>
7543  decltype(std::declval<T&>().string(std::declval<String&>()));
7544 
7545 template<typename T, typename Binary>
7547  decltype(std::declval<T&>().binary(std::declval<Binary&>()));
7548 
7549 template<typename T>
7551  decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
7552 
7553 template<typename T, typename String>
7555  decltype(std::declval<T&>().key(std::declval<String&>()));
7556 
7557 template<typename T>
7558 using end_object_function_t = decltype(std::declval<T&>().end_object());
7559 
7560 template<typename T>
7562  decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
7563 
7564 template<typename T>
7565 using end_array_function_t = decltype(std::declval<T&>().end_array());
7566 
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&>()));
7571 
7572 template<typename SAX, typename BasicJsonType>
7573 struct is_sax
7574 {
7575  private:
7577  "BasicJsonType must be of type basic_json<...>");
7578 
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;
7585 
7586  public:
7587  static constexpr bool value =
7601 };
7602 
7603 template<typename SAX, typename BasicJsonType>
7605 {
7606  private:
7608  "BasicJsonType must be of type basic_json<...>");
7609 
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;
7616 
7617  public:
7619  "Missing/invalid function: bool null()");
7621  "Missing/invalid function: bool boolean(bool)");
7623  "Missing/invalid function: bool boolean(bool)");
7624  static_assert(
7627  "Missing/invalid function: bool number_integer(number_integer_t)");
7628  static_assert(
7631  "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
7632  static_assert(is_detected_exact<bool, number_float_function_t, SAX,
7634  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
7635  static_assert(
7637  "Missing/invalid function: bool string(string_t&)");
7638  static_assert(
7640  "Missing/invalid function: bool binary(binary_t&)");
7642  "Missing/invalid function: bool start_object(std::size_t)");
7644  "Missing/invalid function: bool key(string_t&)");
7646  "Missing/invalid function: bool end_object()");
7648  "Missing/invalid function: bool start_array(std::size_t)");
7650  "Missing/invalid function: bool end_array()");
7651  static_assert(
7653  "Missing/invalid function: bool parse_error(std::size_t, const "
7654  "std::string&, const exception&)");
7655 };
7656 } // namespace detail
7657 } // namespace nlohmann
7658 
7659 // #include <nlohmann/detail/value_t.hpp>
7660 
7661 
7662 namespace nlohmann
7663 {
7664 namespace detail
7665 {
7666 
7669 {
7670  error,
7671  ignore
7672 };
7673 
7681 static inline bool little_endianess(int num = 1) noexcept
7682 {
7683  return *reinterpret_cast<char*>(&num) == 1;
7684 }
7685 
7686 
7688 // binary reader //
7690 
7694 template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
7696 {
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;
7705 
7706  public:
7712  explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
7713  {
7715  }
7716 
7717  // make class move-only
7718  binary_reader(const binary_reader&) = delete;
7722  ~binary_reader() = default;
7723 
7733  bool sax_parse(const input_format_t format,
7735  const bool strict = true,
7737  {
7738  sax = sax_;
7739  bool result = false;
7740 
7741  switch (format)
7742  {
7743  case input_format_t::bson:
7744  result = parse_bson_internal();
7745  break;
7746 
7747  case input_format_t::cbor:
7748  result = parse_cbor_internal(true, tag_handler);
7749  break;
7750 
7752  result = parse_msgpack_internal();
7753  break;
7754 
7756  result = parse_ubjson_internal();
7757  break;
7758 
7759  default: // LCOV_EXCL_LINE
7760  JSON_ASSERT(false); // LCOV_EXCL_LINE
7761  }
7762 
7763  // strict mode: next byte must be EOF
7764  if (result && strict)
7765  {
7766  if (format == input_format_t::ubjson)
7767  {
7768  get_ignore_noop();
7769  }
7770  else
7771  {
7772  get();
7773  }
7774 
7775  if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
7776  {
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")));
7779  }
7780  }
7781 
7782  return result;
7783  }
7784 
7785  private:
7787  // BSON //
7789 
7794  bool parse_bson_internal()
7795  {
7796  std::int32_t document_size{};
7797  get_number<std::int32_t, true>(input_format_t::bson, document_size);
7798 
7799  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
7800  {
7801  return false;
7802  }
7803 
7804  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
7805  {
7806  return false;
7807  }
7808 
7809  return sax->end_object();
7810  }
7811 
7819  bool get_bson_cstr(string_t& result)
7820  {
7821  auto out = std::back_inserter(result);
7822  while (true)
7823  {
7824  get();
7825  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
7826  {
7827  return false;
7828  }
7829  if (current == 0x00)
7830  {
7831  return true;
7832  }
7833  *out++ = static_cast<typename string_t::value_type>(current);
7834  }
7835  }
7836 
7848  template<typename NumberType>
7849  bool get_bson_string(const NumberType len, string_t& result)
7850  {
7851  if (JSON_HEDLEY_UNLIKELY(len < 1))
7852  {
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")));
7855  }
7856 
7857  return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
7858  }
7859 
7869  template<typename NumberType>
7870  bool get_bson_binary(const NumberType len, binary_t& result)
7871  {
7872  if (JSON_HEDLEY_UNLIKELY(len < 0))
7873  {
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")));
7876  }
7877 
7878  // All BSON binary values have a subtype
7879  std::uint8_t subtype{};
7880  get_number<std::uint8_t>(input_format_t::bson, subtype);
7881  result.set_subtype(subtype);
7882 
7883  return get_binary(input_format_t::bson, len, result);
7884  }
7885 
7896  bool parse_bson_element_internal(const char_int_type element_type,
7897  const std::size_t element_type_parse_position)
7898  {
7899  switch (element_type)
7900  {
7901  case 0x01: // double
7902  {
7903  double number{};
7904  return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
7905  }
7906 
7907  case 0x02: // string
7908  {
7909  std::int32_t len{};
7910  string_t value;
7911  return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
7912  }
7913 
7914  case 0x03: // object
7915  {
7916  return parse_bson_internal();
7917  }
7918 
7919  case 0x04: // array
7920  {
7921  return parse_bson_array();
7922  }
7923 
7924  case 0x05: // binary
7925  {
7926  std::int32_t len{};
7927  binary_t value;
7928  return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
7929  }
7930 
7931  case 0x08: // boolean
7932  {
7933  return sax->boolean(get() != 0);
7934  }
7935 
7936  case 0x0A: // null
7937  {
7938  return sax->null();
7939  }
7940 
7941  case 0x10: // int32
7942  {
7943  std::int32_t value{};
7944  return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
7945  }
7946 
7947  case 0x12: // int64
7948  {
7949  std::int64_t value{};
7950  return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
7951  }
7952 
7953  default: // anything else not supported (yet)
7954  {
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())));
7958  }
7959  }
7960  }
7961 
7974  bool parse_bson_element_list(const bool is_array)
7975  {
7976  string_t key;
7977 
7978  while (auto element_type = get())
7979  {
7980  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
7981  {
7982  return false;
7983  }
7984 
7985  const std::size_t element_type_parse_position = chars_read;
7986  if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
7987  {
7988  return false;
7989  }
7990 
7991  if (!is_array && !sax->key(key))
7992  {
7993  return false;
7994  }
7995 
7996  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
7997  {
7998  return false;
7999  }
8000 
8001  // get_bson_cstr only appends
8002  key.clear();
8003  }
8004 
8005  return true;
8006  }
8007 
8012  bool parse_bson_array()
8013  {
8014  std::int32_t document_size{};
8015  get_number<std::int32_t, true>(input_format_t::bson, document_size);
8016 
8017  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
8018  {
8019  return false;
8020  }
8021 
8022  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
8023  {
8024  return false;
8025  }
8026 
8027  return sax->end_array();
8028  }
8029 
8031  // CBOR //
8033 
8042  bool parse_cbor_internal(const bool get_char,
8044  {
8045  switch (get_char ? get() : current)
8046  {
8047  // EOF
8048  case std::char_traits<char_type>::eof():
8049  return unexpect_eof(input_format_t::cbor, "value");
8050 
8051  // Integer 0x00..0x17 (0..23)
8052  case 0x00:
8053  case 0x01:
8054  case 0x02:
8055  case 0x03:
8056  case 0x04:
8057  case 0x05:
8058  case 0x06:
8059  case 0x07:
8060  case 0x08:
8061  case 0x09:
8062  case 0x0A:
8063  case 0x0B:
8064  case 0x0C:
8065  case 0x0D:
8066  case 0x0E:
8067  case 0x0F:
8068  case 0x10:
8069  case 0x11:
8070  case 0x12:
8071  case 0x13:
8072  case 0x14:
8073  case 0x15:
8074  case 0x16:
8075  case 0x17:
8076  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
8077 
8078  case 0x18: // Unsigned integer (one-byte uint8_t follows)
8079  {
8080  std::uint8_t number{};
8081  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8082  }
8083 
8084  case 0x19: // Unsigned integer (two-byte uint16_t follows)
8085  {
8086  std::uint16_t number{};
8087  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8088  }
8089 
8090  case 0x1A: // Unsigned integer (four-byte uint32_t follows)
8091  {
8092  std::uint32_t number{};
8093  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8094  }
8095 
8096  case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
8097  {
8098  std::uint64_t number{};
8099  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8100  }
8101 
8102  // Negative integer -1-0x00..-1-0x17 (-1..-24)
8103  case 0x20:
8104  case 0x21:
8105  case 0x22:
8106  case 0x23:
8107  case 0x24:
8108  case 0x25:
8109  case 0x26:
8110  case 0x27:
8111  case 0x28:
8112  case 0x29:
8113  case 0x2A:
8114  case 0x2B:
8115  case 0x2C:
8116  case 0x2D:
8117  case 0x2E:
8118  case 0x2F:
8119  case 0x30:
8120  case 0x31:
8121  case 0x32:
8122  case 0x33:
8123  case 0x34:
8124  case 0x35:
8125  case 0x36:
8126  case 0x37:
8127  return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
8128 
8129  case 0x38: // Negative integer (one-byte uint8_t follows)
8130  {
8131  std::uint8_t number{};
8132  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8133  }
8134 
8135  case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
8136  {
8137  std::uint16_t number{};
8138  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8139  }
8140 
8141  case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
8142  {
8143  std::uint32_t number{};
8144  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8145  }
8146 
8147  case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
8148  {
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));
8152  }
8153 
8154  // Binary data (0x00..0x17 bytes follow)
8155  case 0x40:
8156  case 0x41:
8157  case 0x42:
8158  case 0x43:
8159  case 0x44:
8160  case 0x45:
8161  case 0x46:
8162  case 0x47:
8163  case 0x48:
8164  case 0x49:
8165  case 0x4A:
8166  case 0x4B:
8167  case 0x4C:
8168  case 0x4D:
8169  case 0x4E:
8170  case 0x4F:
8171  case 0x50:
8172  case 0x51:
8173  case 0x52:
8174  case 0x53:
8175  case 0x54:
8176  case 0x55:
8177  case 0x56:
8178  case 0x57:
8179  case 0x58: // Binary data (one-byte uint8_t for n follows)
8180  case 0x59: // Binary data (two-byte uint16_t for n follow)
8181  case 0x5A: // Binary data (four-byte uint32_t for n follow)
8182  case 0x5B: // Binary data (eight-byte uint64_t for n follow)
8183  case 0x5F: // Binary data (indefinite length)
8184  {
8185  binary_t b;
8186  return get_cbor_binary(b) && sax->binary(b);
8187  }
8188 
8189  // UTF-8 string (0x00..0x17 bytes follow)
8190  case 0x60:
8191  case 0x61:
8192  case 0x62:
8193  case 0x63:
8194  case 0x64:
8195  case 0x65:
8196  case 0x66:
8197  case 0x67:
8198  case 0x68:
8199  case 0x69:
8200  case 0x6A:
8201  case 0x6B:
8202  case 0x6C:
8203  case 0x6D:
8204  case 0x6E:
8205  case 0x6F:
8206  case 0x70:
8207  case 0x71:
8208  case 0x72:
8209  case 0x73:
8210  case 0x74:
8211  case 0x75:
8212  case 0x76:
8213  case 0x77:
8214  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
8215  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
8216  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
8217  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
8218  case 0x7F: // UTF-8 string (indefinite length)
8219  {
8220  string_t s;
8221  return get_cbor_string(s) && sax->string(s);
8222  }
8223 
8224  // array (0x00..0x17 data items follow)
8225  case 0x80:
8226  case 0x81:
8227  case 0x82:
8228  case 0x83:
8229  case 0x84:
8230  case 0x85:
8231  case 0x86:
8232  case 0x87:
8233  case 0x88:
8234  case 0x89:
8235  case 0x8A:
8236  case 0x8B:
8237  case 0x8C:
8238  case 0x8D:
8239  case 0x8E:
8240  case 0x8F:
8241  case 0x90:
8242  case 0x91:
8243  case 0x92:
8244  case 0x93:
8245  case 0x94:
8246  case 0x95:
8247  case 0x96:
8248  case 0x97:
8249  return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8250 
8251  case 0x98: // array (one-byte uint8_t for n follows)
8252  {
8253  std::uint8_t len{};
8254  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8255  }
8256 
8257  case 0x99: // array (two-byte uint16_t for n follow)
8258  {
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);
8261  }
8262 
8263  case 0x9A: // array (four-byte uint32_t for n follow)
8264  {
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);
8267  }
8268 
8269  case 0x9B: // array (eight-byte uint64_t for n follow)
8270  {
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);
8273  }
8274 
8275  case 0x9F: // array (indefinite length)
8276  return get_cbor_array(std::size_t(-1), tag_handler);
8277 
8278  // map (0x00..0x17 pairs of data items follow)
8279  case 0xA0:
8280  case 0xA1:
8281  case 0xA2:
8282  case 0xA3:
8283  case 0xA4:
8284  case 0xA5:
8285  case 0xA6:
8286  case 0xA7:
8287  case 0xA8:
8288  case 0xA9:
8289  case 0xAA:
8290  case 0xAB:
8291  case 0xAC:
8292  case 0xAD:
8293  case 0xAE:
8294  case 0xAF:
8295  case 0xB0:
8296  case 0xB1:
8297  case 0xB2:
8298  case 0xB3:
8299  case 0xB4:
8300  case 0xB5:
8301  case 0xB6:
8302  case 0xB7:
8303  return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8304 
8305  case 0xB8: // map (one-byte uint8_t for n follows)
8306  {
8307  std::uint8_t len{};
8308  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8309  }
8310 
8311  case 0xB9: // map (two-byte uint16_t for n follow)
8312  {
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);
8315  }
8316 
8317  case 0xBA: // map (four-byte uint32_t for n follow)
8318  {
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);
8321  }
8322 
8323  case 0xBB: // map (eight-byte uint64_t for n follow)
8324  {
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);
8327  }
8328 
8329  case 0xBF: // map (indefinite length)
8330  return get_cbor_object(std::size_t(-1), tag_handler);
8331 
8332  case 0xC6: // tagged item
8333  case 0xC7:
8334  case 0xC8:
8335  case 0xC9:
8336  case 0xCA:
8337  case 0xCB:
8338  case 0xCC:
8339  case 0xCD:
8340  case 0xCE:
8341  case 0xCF:
8342  case 0xD0:
8343  case 0xD1:
8344  case 0xD2:
8345  case 0xD3:
8346  case 0xD4:
8347  case 0xD8: // tagged item (1 bytes follow)
8348  case 0xD9: // tagged item (2 bytes follow)
8349  case 0xDA: // tagged item (4 bytes follow)
8350  case 0xDB: // tagged item (8 bytes follow)
8351  {
8352  switch (tag_handler)
8353  {
8355  {
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")));
8358  }
8359 
8361  {
8362  switch (current)
8363  {
8364  case 0xD8:
8365  {
8366  std::uint8_t len{};
8367  get_number(input_format_t::cbor, len);
8368  break;
8369  }
8370  case 0xD9:
8371  {
8372  std::uint16_t len{};
8373  get_number(input_format_t::cbor, len);
8374  break;
8375  }
8376  case 0xDA:
8377  {
8378  std::uint32_t len{};
8379  get_number(input_format_t::cbor, len);
8380  break;
8381  }
8382  case 0xDB:
8383  {
8384  std::uint64_t len{};
8385  get_number(input_format_t::cbor, len);
8386  break;
8387  }
8388  default:
8389  break;
8390  }
8391  return parse_cbor_internal(true, tag_handler);
8392  }
8393 
8394  default: // LCOV_EXCL_LINE
8395  JSON_ASSERT(false); // LCOV_EXCL_LINE
8396  }
8397  }
8398 
8399  case 0xF4: // false
8400  return sax->boolean(false);
8401 
8402  case 0xF5: // true
8403  return sax->boolean(true);
8404 
8405  case 0xF6: // null
8406  return sax->null();
8407 
8408  case 0xF9: // Half-Precision Float (two-byte IEEE 754)
8409  {
8410  const auto byte1_raw = get();
8411  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8412  {
8413  return false;
8414  }
8415  const auto byte2_raw = get();
8416  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8417  {
8418  return false;
8419  }
8420 
8421  const auto byte1 = static_cast<unsigned char>(byte1_raw);
8422  const auto byte2 = static_cast<unsigned char>(byte2_raw);
8423 
8424  // code from RFC 7049, Appendix D, Figure 3:
8425  // As half-precision floating-point numbers were only added
8426  // to IEEE 754 in 2008, today's programming platforms often
8427  // still only have limited support for them. It is very
8428  // easy to include at least decoding support for them even
8429  // without such support. An example of a small decoder for
8430  // half-precision floating-point numbers in the C language
8431  // is shown in Fig. 3.
8432  const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
8433  const double val = [&half]
8434  {
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);
8439  switch (exp)
8440  {
8441  case 0:
8442  return std::ldexp(mant, -24);
8443  case 31:
8444  return (mant == 0)
8445  ? std::numeric_limits<double>::infinity()
8446  : std::numeric_limits<double>::quiet_NaN();
8447  default:
8448  return std::ldexp(mant + 1024, exp - 25);
8449  }
8450  }();
8451  return sax->number_float((half & 0x8000u) != 0
8452  ? static_cast<number_float_t>(-val)
8453  : static_cast<number_float_t>(val), "");
8454  }
8455 
8456  case 0xFA: // Single-Precision Float (four-byte IEEE 754)
8457  {
8458  float number{};
8459  return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
8460  }
8461 
8462  case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
8463  {
8464  double number{};
8465  return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
8466  }
8467 
8468  default: // anything else (0xFF is handled inside the other types)
8469  {
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")));
8472  }
8473  }
8474  }
8475 
8487  bool get_cbor_string(string_t& result)
8488  {
8489  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
8490  {
8491  return false;
8492  }
8493 
8494  switch (current)
8495  {
8496  // UTF-8 string (0x00..0x17 bytes follow)
8497  case 0x60:
8498  case 0x61:
8499  case 0x62:
8500  case 0x63:
8501  case 0x64:
8502  case 0x65:
8503  case 0x66:
8504  case 0x67:
8505  case 0x68:
8506  case 0x69:
8507  case 0x6A:
8508  case 0x6B:
8509  case 0x6C:
8510  case 0x6D:
8511  case 0x6E:
8512  case 0x6F:
8513  case 0x70:
8514  case 0x71:
8515  case 0x72:
8516  case 0x73:
8517  case 0x74:
8518  case 0x75:
8519  case 0x76:
8520  case 0x77:
8521  {
8522  return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
8523  }
8524 
8525  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
8526  {
8527  std::uint8_t len{};
8528  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8529  }
8530 
8531  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
8532  {
8533  std::uint16_t len{};
8534  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8535  }
8536 
8537  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
8538  {
8539  std::uint32_t len{};
8540  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8541  }
8542 
8543  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
8544  {
8545  std::uint64_t len{};
8546  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8547  }
8548 
8549  case 0x7F: // UTF-8 string (indefinite length)
8550  {
8551  while (get() != 0xFF)
8552  {
8553  string_t chunk;
8554  if (!get_cbor_string(chunk))
8555  {
8556  return false;
8557  }
8558  result.append(chunk);
8559  }
8560  return true;
8561  }
8562 
8563  default:
8564  {
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")));
8567  }
8568  }
8569  }
8570 
8582  bool get_cbor_binary(binary_t& result)
8583  {
8584  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
8585  {
8586  return false;
8587  }
8588 
8589  switch (current)
8590  {
8591  // Binary data (0x00..0x17 bytes follow)
8592  case 0x40:
8593  case 0x41:
8594  case 0x42:
8595  case 0x43:
8596  case 0x44:
8597  case 0x45:
8598  case 0x46:
8599  case 0x47:
8600  case 0x48:
8601  case 0x49:
8602  case 0x4A:
8603  case 0x4B:
8604  case 0x4C:
8605  case 0x4D:
8606  case 0x4E:
8607  case 0x4F:
8608  case 0x50:
8609  case 0x51:
8610  case 0x52:
8611  case 0x53:
8612  case 0x54:
8613  case 0x55:
8614  case 0x56:
8615  case 0x57:
8616  {
8617  return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
8618  }
8619 
8620  case 0x58: // Binary data (one-byte uint8_t for n follows)
8621  {
8622  std::uint8_t len{};
8623  return get_number(input_format_t::cbor, len) &&
8624  get_binary(input_format_t::cbor, len, result);
8625  }
8626 
8627  case 0x59: // Binary data (two-byte uint16_t for n follow)
8628  {
8629  std::uint16_t len{};
8630  return get_number(input_format_t::cbor, len) &&
8631  get_binary(input_format_t::cbor, len, result);
8632  }
8633 
8634  case 0x5A: // Binary data (four-byte uint32_t for n follow)
8635  {
8636  std::uint32_t len{};
8637  return get_number(input_format_t::cbor, len) &&
8638  get_binary(input_format_t::cbor, len, result);
8639  }
8640 
8641  case 0x5B: // Binary data (eight-byte uint64_t for n follow)
8642  {
8643  std::uint64_t len{};
8644  return get_number(input_format_t::cbor, len) &&
8645  get_binary(input_format_t::cbor, len, result);
8646  }
8647 
8648  case 0x5F: // Binary data (indefinite length)
8649  {
8650  while (get() != 0xFF)
8651  {
8652  binary_t chunk;
8653  if (!get_cbor_binary(chunk))
8654  {
8655  return false;
8656  }
8657  result.insert(result.end(), chunk.begin(), chunk.end());
8658  }
8659  return true;
8660  }
8661 
8662  default:
8663  {
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")));
8666  }
8667  }
8668  }
8669 
8676  bool get_cbor_array(const std::size_t len,
8678  {
8679  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
8680  {
8681  return false;
8682  }
8683 
8684  if (len != std::size_t(-1))
8685  {
8686  for (std::size_t i = 0; i < len; ++i)
8687  {
8688  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
8689  {
8690  return false;
8691  }
8692  }
8693  }
8694  else
8695  {
8696  while (get() != 0xFF)
8697  {
8698  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
8699  {
8700  return false;
8701  }
8702  }
8703  }
8704 
8705  return sax->end_array();
8706  }
8707 
8714  bool get_cbor_object(const std::size_t len,
8716  {
8717  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
8718  {
8719  return false;
8720  }
8721 
8722  string_t key;
8723  if (len != std::size_t(-1))
8724  {
8725  for (std::size_t i = 0; i < len; ++i)
8726  {
8727  get();
8728  if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
8729  {
8730  return false;
8731  }
8732 
8733  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
8734  {
8735  return false;
8736  }
8737  key.clear();
8738  }
8739  }
8740  else
8741  {
8742  while (get() != 0xFF)
8743  {
8744  if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
8745  {
8746  return false;
8747  }
8748 
8749  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
8750  {
8751  return false;
8752  }
8753  key.clear();
8754  }
8755  }
8756 
8757  return sax->end_object();
8758  }
8759 
8761  // MsgPack //
8763 
8767  bool parse_msgpack_internal()
8768  {
8769  switch (get())
8770  {
8771  // EOF
8772  case std::char_traits<char_type>::eof():
8773  return unexpect_eof(input_format_t::msgpack, "value");
8774 
8775  // positive fixint
8776  case 0x00:
8777  case 0x01:
8778  case 0x02:
8779  case 0x03:
8780  case 0x04:
8781  case 0x05:
8782  case 0x06:
8783  case 0x07:
8784  case 0x08:
8785  case 0x09:
8786  case 0x0A:
8787  case 0x0B:
8788  case 0x0C:
8789  case 0x0D:
8790  case 0x0E:
8791  case 0x0F:
8792  case 0x10:
8793  case 0x11:
8794  case 0x12:
8795  case 0x13:
8796  case 0x14:
8797  case 0x15:
8798  case 0x16:
8799  case 0x17:
8800  case 0x18:
8801  case 0x19:
8802  case 0x1A:
8803  case 0x1B:
8804  case 0x1C:
8805  case 0x1D:
8806  case 0x1E:
8807  case 0x1F:
8808  case 0x20:
8809  case 0x21:
8810  case 0x22:
8811  case 0x23:
8812  case 0x24:
8813  case 0x25:
8814  case 0x26:
8815  case 0x27:
8816  case 0x28:
8817  case 0x29:
8818  case 0x2A:
8819  case 0x2B:
8820  case 0x2C:
8821  case 0x2D:
8822  case 0x2E:
8823  case 0x2F:
8824  case 0x30:
8825  case 0x31:
8826  case 0x32:
8827  case 0x33:
8828  case 0x34:
8829  case 0x35:
8830  case 0x36:
8831  case 0x37:
8832  case 0x38:
8833  case 0x39:
8834  case 0x3A:
8835  case 0x3B:
8836  case 0x3C:
8837  case 0x3D:
8838  case 0x3E:
8839  case 0x3F:
8840  case 0x40:
8841  case 0x41:
8842  case 0x42:
8843  case 0x43:
8844  case 0x44:
8845  case 0x45:
8846  case 0x46:
8847  case 0x47:
8848  case 0x48:
8849  case 0x49:
8850  case 0x4A:
8851  case 0x4B:
8852  case 0x4C:
8853  case 0x4D:
8854  case 0x4E:
8855  case 0x4F:
8856  case 0x50:
8857  case 0x51:
8858  case 0x52:
8859  case 0x53:
8860  case 0x54:
8861  case 0x55:
8862  case 0x56:
8863  case 0x57:
8864  case 0x58:
8865  case 0x59:
8866  case 0x5A:
8867  case 0x5B:
8868  case 0x5C:
8869  case 0x5D:
8870  case 0x5E:
8871  case 0x5F:
8872  case 0x60:
8873  case 0x61:
8874  case 0x62:
8875  case 0x63:
8876  case 0x64:
8877  case 0x65:
8878  case 0x66:
8879  case 0x67:
8880  case 0x68:
8881  case 0x69:
8882  case 0x6A:
8883  case 0x6B:
8884  case 0x6C:
8885  case 0x6D:
8886  case 0x6E:
8887  case 0x6F:
8888  case 0x70:
8889  case 0x71:
8890  case 0x72:
8891  case 0x73:
8892  case 0x74:
8893  case 0x75:
8894  case 0x76:
8895  case 0x77:
8896  case 0x78:
8897  case 0x79:
8898  case 0x7A:
8899  case 0x7B:
8900  case 0x7C:
8901  case 0x7D:
8902  case 0x7E:
8903  case 0x7F:
8904  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
8905 
8906  // fixmap
8907  case 0x80:
8908  case 0x81:
8909  case 0x82:
8910  case 0x83:
8911  case 0x84:
8912  case 0x85:
8913  case 0x86:
8914  case 0x87:
8915  case 0x88:
8916  case 0x89:
8917  case 0x8A:
8918  case 0x8B:
8919  case 0x8C:
8920  case 0x8D:
8921  case 0x8E:
8922  case 0x8F:
8923  return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
8924 
8925  // fixarray
8926  case 0x90:
8927  case 0x91:
8928  case 0x92:
8929  case 0x93:
8930  case 0x94:
8931  case 0x95:
8932  case 0x96:
8933  case 0x97:
8934  case 0x98:
8935  case 0x99:
8936  case 0x9A:
8937  case 0x9B:
8938  case 0x9C:
8939  case 0x9D:
8940  case 0x9E:
8941  case 0x9F:
8942  return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
8943 
8944  // fixstr
8945  case 0xA0:
8946  case 0xA1:
8947  case 0xA2:
8948  case 0xA3:
8949  case 0xA4:
8950  case 0xA5:
8951  case 0xA6:
8952  case 0xA7:
8953  case 0xA8:
8954  case 0xA9:
8955  case 0xAA:
8956  case 0xAB:
8957  case 0xAC:
8958  case 0xAD:
8959  case 0xAE:
8960  case 0xAF:
8961  case 0xB0:
8962  case 0xB1:
8963  case 0xB2:
8964  case 0xB3:
8965  case 0xB4:
8966  case 0xB5:
8967  case 0xB6:
8968  case 0xB7:
8969  case 0xB8:
8970  case 0xB9:
8971  case 0xBA:
8972  case 0xBB:
8973  case 0xBC:
8974  case 0xBD:
8975  case 0xBE:
8976  case 0xBF:
8977  case 0xD9: // str 8
8978  case 0xDA: // str 16
8979  case 0xDB: // str 32
8980  {
8981  string_t s;
8982  return get_msgpack_string(s) && sax->string(s);
8983  }
8984 
8985  case 0xC0: // nil
8986  return sax->null();
8987 
8988  case 0xC2: // false
8989  return sax->boolean(false);
8990 
8991  case 0xC3: // true
8992  return sax->boolean(true);
8993 
8994  case 0xC4: // bin 8
8995  case 0xC5: // bin 16
8996  case 0xC6: // bin 32
8997  case 0xC7: // ext 8
8998  case 0xC8: // ext 16
8999  case 0xC9: // ext 32
9000  case 0xD4: // fixext 1
9001  case 0xD5: // fixext 2
9002  case 0xD6: // fixext 4
9003  case 0xD7: // fixext 8
9004  case 0xD8: // fixext 16
9005  {
9006  binary_t b;
9007  return get_msgpack_binary(b) && sax->binary(b);
9008  }
9009 
9010  case 0xCA: // float 32
9011  {
9012  float number{};
9013  return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9014  }
9015 
9016  case 0xCB: // float 64
9017  {
9018  double number{};
9019  return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9020  }
9021 
9022  case 0xCC: // uint 8
9023  {
9024  std::uint8_t number{};
9025  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9026  }
9027 
9028  case 0xCD: // uint 16
9029  {
9030  std::uint16_t number{};
9031  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9032  }
9033 
9034  case 0xCE: // uint 32
9035  {
9036  std::uint32_t number{};
9037  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9038  }
9039 
9040  case 0xCF: // uint 64
9041  {
9042  std::uint64_t number{};
9043  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9044  }
9045 
9046  case 0xD0: // int 8
9047  {
9048  std::int8_t number{};
9049  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9050  }
9051 
9052  case 0xD1: // int 16
9053  {
9054  std::int16_t number{};
9055  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9056  }
9057 
9058  case 0xD2: // int 32
9059  {
9060  std::int32_t number{};
9061  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9062  }
9063 
9064  case 0xD3: // int 64
9065  {
9066  std::int64_t number{};
9067  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9068  }
9069 
9070  case 0xDC: // array 16
9071  {
9072  std::uint16_t len{};
9073  return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9074  }
9075 
9076  case 0xDD: // array 32
9077  {
9078  std::uint32_t len{};
9079  return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9080  }
9081 
9082  case 0xDE: // map 16
9083  {
9084  std::uint16_t len{};
9085  return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9086  }
9087 
9088  case 0xDF: // map 32
9089  {
9090  std::uint32_t len{};
9091  return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9092  }
9093 
9094  // negative fixint
9095  case 0xE0:
9096  case 0xE1:
9097  case 0xE2:
9098  case 0xE3:
9099  case 0xE4:
9100  case 0xE5:
9101  case 0xE6:
9102  case 0xE7:
9103  case 0xE8:
9104  case 0xE9:
9105  case 0xEA:
9106  case 0xEB:
9107  case 0xEC:
9108  case 0xED:
9109  case 0xEE:
9110  case 0xEF:
9111  case 0xF0:
9112  case 0xF1:
9113  case 0xF2:
9114  case 0xF3:
9115  case 0xF4:
9116  case 0xF5:
9117  case 0xF6:
9118  case 0xF7:
9119  case 0xF8:
9120  case 0xF9:
9121  case 0xFA:
9122  case 0xFB:
9123  case 0xFC:
9124  case 0xFD:
9125  case 0xFE:
9126  case 0xFF:
9127  return sax->number_integer(static_cast<std::int8_t>(current));
9128 
9129  default: // anything else
9130  {
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")));
9133  }
9134  }
9135  }
9136 
9147  bool get_msgpack_string(string_t& result)
9148  {
9149  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
9150  {
9151  return false;
9152  }
9153 
9154  switch (current)
9155  {
9156  // fixstr
9157  case 0xA0:
9158  case 0xA1:
9159  case 0xA2:
9160  case 0xA3:
9161  case 0xA4:
9162  case 0xA5:
9163  case 0xA6:
9164  case 0xA7:
9165  case 0xA8:
9166  case 0xA9:
9167  case 0xAA:
9168  case 0xAB:
9169  case 0xAC:
9170  case 0xAD:
9171  case 0xAE:
9172  case 0xAF:
9173  case 0xB0:
9174  case 0xB1:
9175  case 0xB2:
9176  case 0xB3:
9177  case 0xB4:
9178  case 0xB5:
9179  case 0xB6:
9180  case 0xB7:
9181  case 0xB8:
9182  case 0xB9:
9183  case 0xBA:
9184  case 0xBB:
9185  case 0xBC:
9186  case 0xBD:
9187  case 0xBE:
9188  case 0xBF:
9189  {
9190  return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
9191  }
9192 
9193  case 0xD9: // str 8
9194  {
9195  std::uint8_t len{};
9196  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9197  }
9198 
9199  case 0xDA: // str 16
9200  {
9201  std::uint16_t len{};
9202  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9203  }
9204 
9205  case 0xDB: // str 32
9206  {
9207  std::uint32_t len{};
9208  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9209  }
9210 
9211  default:
9212  {
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")));
9215  }
9216  }
9217  }
9218 
9229  bool get_msgpack_binary(binary_t& result)
9230  {
9231  // helper function to set the subtype
9232  auto assign_and_return_true = [&result](std::int8_t subtype)
9233  {
9234  result.set_subtype(static_cast<std::uint8_t>(subtype));
9235  return true;
9236  };
9237 
9238  switch (current)
9239  {
9240  case 0xC4: // bin 8
9241  {
9242  std::uint8_t len{};
9243  return get_number(input_format_t::msgpack, len) &&
9244  get_binary(input_format_t::msgpack, len, result);
9245  }
9246 
9247  case 0xC5: // bin 16
9248  {
9249  std::uint16_t len{};
9250  return get_number(input_format_t::msgpack, len) &&
9251  get_binary(input_format_t::msgpack, len, result);
9252  }
9253 
9254  case 0xC6: // bin 32
9255  {
9256  std::uint32_t len{};
9257  return get_number(input_format_t::msgpack, len) &&
9258  get_binary(input_format_t::msgpack, len, result);
9259  }
9260 
9261  case 0xC7: // ext 8
9262  {
9263  std::uint8_t len{};
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);
9269  }
9270 
9271  case 0xC8: // ext 16
9272  {
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);
9279  }
9280 
9281  case 0xC9: // ext 32
9282  {
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);
9289  }
9290 
9291  case 0xD4: // fixext 1
9292  {
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);
9297  }
9298 
9299  case 0xD5: // fixext 2
9300  {
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);
9305  }
9306 
9307  case 0xD6: // fixext 4
9308  {
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);
9313  }
9314 
9315  case 0xD7: // fixext 8
9316  {
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);
9321  }
9322 
9323  case 0xD8: // fixext 16
9324  {
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);
9329  }
9330 
9331  default: // LCOV_EXCL_LINE
9332  return false; // LCOV_EXCL_LINE
9333  }
9334  }
9335 
9340  bool get_msgpack_array(const std::size_t len)
9341  {
9342  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9343  {
9344  return false;
9345  }
9346 
9347  for (std::size_t i = 0; i < len; ++i)
9348  {
9349  if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9350  {
9351  return false;
9352  }
9353  }
9354 
9355  return sax->end_array();
9356  }
9357 
9362  bool get_msgpack_object(const std::size_t len)
9363  {
9364  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9365  {
9366  return false;
9367  }
9368 
9369  string_t key;
9370  for (std::size_t i = 0; i < len; ++i)
9371  {
9372  get();
9373  if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
9374  {
9375  return false;
9376  }
9377 
9378  if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9379  {
9380  return false;
9381  }
9382  key.clear();
9383  }
9384 
9385  return sax->end_object();
9386  }
9387 
9389  // UBJSON //
9391 
9399  bool parse_ubjson_internal(const bool get_char = true)
9400  {
9401  return get_ubjson_value(get_char ? get_ignore_noop() : current);
9402  }
9403 
9418  bool get_ubjson_string(string_t& result, const bool get_char = true)
9419  {
9420  if (get_char)
9421  {
9422  get(); // TODO(niels): may we ignore N here?
9423  }
9424 
9425  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
9426  {
9427  return false;
9428  }
9429 
9430  switch (current)
9431  {
9432  case 'U':
9433  {
9434  std::uint8_t len{};
9435  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9436  }
9437 
9438  case 'i':
9439  {
9440  std::int8_t len{};
9441  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9442  }
9443 
9444  case 'I':
9445  {
9446  std::int16_t len{};
9447  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9448  }
9449 
9450  case 'l':
9451  {
9452  std::int32_t len{};
9453  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9454  }
9455 
9456  case 'L':
9457  {
9458  std::int64_t len{};
9459  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9460  }
9461 
9462  default:
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")));
9465  }
9466  }
9467 
9472  bool get_ubjson_size_value(std::size_t& result)
9473  {
9474  switch (get_ignore_noop())
9475  {
9476  case 'U':
9477  {
9478  std::uint8_t number{};
9479  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9480  {
9481  return false;
9482  }
9483  result = static_cast<std::size_t>(number);
9484  return true;
9485  }
9486 
9487  case 'i':
9488  {
9489  std::int8_t number{};
9490  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9491  {
9492  return false;
9493  }
9494  result = static_cast<std::size_t>(number);
9495  return true;
9496  }
9497 
9498  case 'I':
9499  {
9500  std::int16_t number{};
9501  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9502  {
9503  return false;
9504  }
9505  result = static_cast<std::size_t>(number);
9506  return true;
9507  }
9508 
9509  case 'l':
9510  {
9511  std::int32_t number{};
9512  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9513  {
9514  return false;
9515  }
9516  result = static_cast<std::size_t>(number);
9517  return true;
9518  }
9519 
9520  case 'L':
9521  {
9522  std::int64_t number{};
9523  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9524  {
9525  return false;
9526  }
9527  result = static_cast<std::size_t>(number);
9528  return true;
9529  }
9530 
9531  default:
9532  {
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")));
9535  }
9536  }
9537  }
9538 
9549  bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
9550  {
9551  result.first = string_t::npos; // size
9552  result.second = 0; // type
9553 
9554  get_ignore_noop();
9555 
9556  if (current == '$')
9557  {
9558  result.second = get(); // must not ignore 'N', because 'N' maybe the type
9559  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
9560  {
9561  return false;
9562  }
9563 
9564  get_ignore_noop();
9565  if (JSON_HEDLEY_UNLIKELY(current != '#'))
9566  {
9567  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
9568  {
9569  return false;
9570  }
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")));
9573  }
9574 
9575  return get_ubjson_size_value(result.first);
9576  }
9577 
9578  if (current == '#')
9579  {
9580  return get_ubjson_size_value(result.first);
9581  }
9582 
9583  return true;
9584  }
9585 
9590  bool get_ubjson_value(const char_int_type prefix)
9591  {
9592  switch (prefix)
9593  {
9594  case std::char_traits<char_type>::eof(): // EOF
9595  return unexpect_eof(input_format_t::ubjson, "value");
9596 
9597  case 'T': // true
9598  return sax->boolean(true);
9599  case 'F': // false
9600  return sax->boolean(false);
9601 
9602  case 'Z': // null
9603  return sax->null();
9604 
9605  case 'U':
9606  {
9607  std::uint8_t number{};
9608  return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
9609  }
9610 
9611  case 'i':
9612  {
9613  std::int8_t number{};
9614  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9615  }
9616 
9617  case 'I':
9618  {
9619  std::int16_t number{};
9620  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9621  }
9622 
9623  case 'l':
9624  {
9625  std::int32_t number{};
9626  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9627  }
9628 
9629  case 'L':
9630  {
9631  std::int64_t number{};
9632  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9633  }
9634 
9635  case 'd':
9636  {
9637  float number{};
9638  return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
9639  }
9640 
9641  case 'D':
9642  {
9643  double number{};
9644  return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
9645  }
9646 
9647  case 'H':
9648  {
9649  return get_ubjson_high_precision_number();
9650  }
9651 
9652  case 'C': // char
9653  {
9654  get();
9655  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
9656  {
9657  return false;
9658  }
9659  if (JSON_HEDLEY_UNLIKELY(current > 127))
9660  {
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")));
9663  }
9664  string_t s(1, static_cast<typename string_t::value_type>(current));
9665  return sax->string(s);
9666  }
9667 
9668  case 'S': // string
9669  {
9670  string_t s;
9671  return get_ubjson_string(s) && sax->string(s);
9672  }
9673 
9674  case '[': // array
9675  return get_ubjson_array();
9676 
9677  case '{': // object
9678  return get_ubjson_object();
9679 
9680  default: // anything else
9681  {
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")));
9684  }
9685  }
9686  }
9687 
9691  bool get_ubjson_array()
9692  {
9693  std::pair<std::size_t, char_int_type> size_and_type;
9694  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
9695  {
9696  return false;
9697  }
9698 
9699  if (size_and_type.first != string_t::npos)
9700  {
9701  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
9702  {
9703  return false;
9704  }
9705 
9706  if (size_and_type.second != 0)
9707  {
9708  if (size_and_type.second != 'N')
9709  {
9710  for (std::size_t i = 0; i < size_and_type.first; ++i)
9711  {
9712  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
9713  {
9714  return false;
9715  }
9716  }
9717  }
9718  }
9719  else
9720  {
9721  for (std::size_t i = 0; i < size_and_type.first; ++i)
9722  {
9723  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9724  {
9725  return false;
9726  }
9727  }
9728  }
9729  }
9730  else
9731  {
9732  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
9733  {
9734  return false;
9735  }
9736 
9737  while (current != ']')
9738  {
9739  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
9740  {
9741  return false;
9742  }
9743  get_ignore_noop();
9744  }
9745  }
9746 
9747  return sax->end_array();
9748  }
9749 
9753  bool get_ubjson_object()
9754  {
9755  std::pair<std::size_t, char_int_type> size_and_type;
9756  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
9757  {
9758  return false;
9759  }
9760 
9761  string_t key;
9762  if (size_and_type.first != string_t::npos)
9763  {
9764  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
9765  {
9766  return false;
9767  }
9768 
9769  if (size_and_type.second != 0)
9770  {
9771  for (std::size_t i = 0; i < size_and_type.first; ++i)
9772  {
9773  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
9774  {
9775  return false;
9776  }
9777  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
9778  {
9779  return false;
9780  }
9781  key.clear();
9782  }
9783  }
9784  else
9785  {
9786  for (std::size_t i = 0; i < size_and_type.first; ++i)
9787  {
9788  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
9789  {
9790  return false;
9791  }
9792  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9793  {
9794  return false;
9795  }
9796  key.clear();
9797  }
9798  }
9799  }
9800  else
9801  {
9802  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
9803  {
9804  return false;
9805  }
9806 
9807  while (current != '}')
9808  {
9809  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
9810  {
9811  return false;
9812  }
9813  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9814  {
9815  return false;
9816  }
9817  get_ignore_noop();
9818  key.clear();
9819  }
9820  }
9821 
9822  return sax->end_object();
9823  }
9824 
9825  // Note, no reader for UBJSON binary types is implemented because they do
9826  // not exist
9827 
9828  bool get_ubjson_high_precision_number()
9829  {
9830  // get size of following number string
9831  std::size_t size{};
9832  auto res = get_ubjson_size_value(size);
9833  if (JSON_HEDLEY_UNLIKELY(!res))
9834  {
9835  return res;
9836  }
9837 
9838  // get number string
9839  std::vector<char> number_vector;
9840  for (std::size_t i = 0; i < size; ++i)
9841  {
9842  get();
9843  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
9844  {
9845  return false;
9846  }
9847  number_vector.push_back(static_cast<char>(current));
9848  }
9849 
9850  // parse number string
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();
9856 
9857  using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
9858 
9859  if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
9860  {
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")));
9862  }
9863 
9864  switch (result_number)
9865  {
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));
9872  default:
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")));
9874  }
9875  }
9876 
9878  // Utility functions //
9880 
9890  char_int_type get()
9891  {
9892  ++chars_read;
9893  return current = ia.get_character();
9894  }
9895 
9899  char_int_type get_ignore_noop()
9900  {
9901  do
9902  {
9903  get();
9904  }
9905  while (current == 'N');
9906 
9907  return current;
9908  }
9909 
9910  /*
9911  @brief read a number from the input
9912 
9913  @tparam NumberType the type of the number
9914  @param[in] format the current format (for diagnostics)
9915  @param[out] result number of type @a NumberType
9916 
9917  @return whether conversion completed
9918 
9919  @note This function needs to respect the system's endianess, because
9920  bytes in CBOR, MessagePack, and UBJSON are stored in network order
9921  (big endian) and therefore need reordering on little endian systems.
9922  */
9923  template<typename NumberType, bool InputIsLittleEndian = false>
9924  bool get_number(const input_format_t format, NumberType& result)
9925  {
9926  // step 1: read input into array with system's byte order
9927  std::array<std::uint8_t, sizeof(NumberType)> vec;
9928  for (std::size_t i = 0; i < sizeof(NumberType); ++i)
9929  {
9930  get();
9931  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
9932  {
9933  return false;
9934  }
9935 
9936  // reverse byte order prior to conversion if necessary
9938  {
9939  vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
9940  }
9941  else
9942  {
9943  vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
9944  }
9945  }
9946 
9947  // step 2: convert array into number of type T and return
9948  std::memcpy(&result, vec.data(), sizeof(NumberType));
9949  return true;
9950  }
9951 
9966  template<typename NumberType>
9967  bool get_string(const input_format_t format,
9968  const NumberType len,
9969  string_t& result)
9970  {
9971  bool success = true;
9972  for (NumberType i = 0; i < len; i++)
9973  {
9974  get();
9975  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
9976  {
9977  success = false;
9978  break;
9979  }
9980  result.push_back(static_cast<typename string_t::value_type>(current));
9981  };
9982  return success;
9983  }
9984 
9999  template<typename NumberType>
10000  bool get_binary(const input_format_t format,
10001  const NumberType len,
10002  binary_t& result)
10003  {
10004  bool success = true;
10005  for (NumberType i = 0; i < len; i++)
10006  {
10007  get();
10008  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
10009  {
10010  success = false;
10011  break;
10012  }
10013  result.push_back(static_cast<std::uint8_t>(current));
10014  }
10015  return success;
10016  }
10017 
10024  bool unexpect_eof(const input_format_t format, const char* context) const
10025  {
10026  if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10027  {
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)));
10030  }
10031  return true;
10032  }
10033 
10037  std::string get_token_string() const
10038  {
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()};
10042  }
10043 
10050  std::string exception_message(const input_format_t format,
10051  const std::string& detail,
10052  const std::string& context) const
10053  {
10054  std::string error_msg = "syntax error while parsing ";
10055 
10056  switch (format)
10057  {
10058  case input_format_t::cbor:
10059  error_msg += "CBOR";
10060  break;
10061 
10063  error_msg += "MessagePack";
10064  break;
10065 
10067  error_msg += "UBJSON";
10068  break;
10069 
10070  case input_format_t::bson:
10071  error_msg += "BSON";
10072  break;
10073 
10074  default: // LCOV_EXCL_LINE
10075  JSON_ASSERT(false); // LCOV_EXCL_LINE
10076  }
10077 
10078  return error_msg + " " + context + ": " + detail;
10079  }
10080 
10081  private:
10083  InputAdapterType ia;
10084 
10086  char_int_type current = std::char_traits<char_type>::eof();
10087 
10089  std::size_t chars_read = 0;
10090 
10093 
10095  json_sax_t* sax = nullptr;
10096 };
10097 } // namespace detail
10098 } // namespace nlohmann
10099 
10100 // #include <nlohmann/detail/input/input_adapters.hpp>
10101 
10102 // #include <nlohmann/detail/input/lexer.hpp>
10103 
10104 // #include <nlohmann/detail/input/parser.hpp>
10105 
10106 
10107 #include <cmath> // isfinite
10108 #include <cstdint> // uint8_t
10109 #include <functional> // function
10110 #include <string> // string
10111 #include <utility> // move
10112 #include <vector> // vector
10113 
10114 // #include <nlohmann/detail/exceptions.hpp>
10115 
10116 // #include <nlohmann/detail/input/input_adapters.hpp>
10117 
10118 // #include <nlohmann/detail/input/json_sax.hpp>
10119 
10120 // #include <nlohmann/detail/input/lexer.hpp>
10121 
10122 // #include <nlohmann/detail/macro_scope.hpp>
10123 
10124 // #include <nlohmann/detail/meta/is_sax.hpp>
10125 
10126 // #include <nlohmann/detail/value_t.hpp>
10127 
10128 
10129 namespace nlohmann
10130 {
10131 namespace detail
10132 {
10134 // parser //
10136 
10137 enum class parse_event_t : uint8_t
10138 {
10140  object_start,
10142  object_end,
10144  array_start,
10146  array_end,
10148  key,
10150  value
10151 };
10152 
10153 template<typename BasicJsonType>
10155  std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
10156 
10162 template<typename BasicJsonType, typename InputAdapterType>
10163 class parser
10164 {
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;
10171 
10172  public:
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)
10178  : callback(cb)
10179  , m_lexer(std::move(adapter), skip_comments)
10180  , allow_exceptions(allow_exceptions_)
10181  {
10182  // read first token
10183  get_token();
10184  }
10185 
10196  void parse(const bool strict, BasicJsonType& result)
10197  {
10198  if (callback)
10199  {
10201  sax_parse_internal(&sdp);
10202  result.assert_invariant();
10203 
10204  // in strict mode, input must be completely read
10205  if (strict && (get_token() != token_type::end_of_input))
10206  {
10210  exception_message(token_type::end_of_input, "value")));
10211  }
10212 
10213  // in case of an error, return discarded value
10214  if (sdp.is_errored())
10215  {
10216  result = value_t::discarded;
10217  return;
10218  }
10219 
10220  // set top-level value to null if it was discarded by the callback
10221  // function
10222  if (result.is_discarded())
10223  {
10224  result = nullptr;
10225  }
10226  }
10227  else
10228  {
10230  sax_parse_internal(&sdp);
10231  result.assert_invariant();
10232 
10233  // in strict mode, input must be completely read
10234  if (strict && (get_token() != token_type::end_of_input))
10235  {
10239  exception_message(token_type::end_of_input, "value")));
10240  }
10241 
10242  // in case of an error, return discarded value
10243  if (sdp.is_errored())
10244  {
10245  result = value_t::discarded;
10246  return;
10247  }
10248  }
10249  }
10250 
10257  bool accept(const bool strict = true)
10258  {
10259  json_sax_acceptor<BasicJsonType> sax_acceptor;
10260  return sax_parse(&sax_acceptor, strict);
10261  }
10262 
10263  template<typename SAX>
10265  bool sax_parse(SAX* sax, const bool strict = true)
10266  {
10268  const bool result = sax_parse_internal(sax);
10269 
10270  // strict mode: next byte must be EOF
10271  if (result && strict && (get_token() != token_type::end_of_input))
10272  {
10273  return sax->parse_error(m_lexer.get_position(),
10276  exception_message(token_type::end_of_input, "value")));
10277  }
10278 
10279  return result;
10280  }
10281 
10282  private:
10283  template<typename SAX>
10285  bool sax_parse_internal(SAX* sax)
10286  {
10287  // stack to remember the hierarchy of structured values we are parsing
10288  // true = array; false = object
10289  std::vector<bool> states;
10290  // value to avoid a goto (see comment where set to true)
10291  bool skip_to_state_evaluation = false;
10292 
10293  while (true)
10294  {
10295  if (!skip_to_state_evaluation)
10296  {
10297  // invariant: get_token() was called before each iteration
10298  switch (last_token)
10299  {
10300  case token_type::begin_object:
10301  {
10302  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10303  {
10304  return false;
10305  }
10306 
10307  // closing } -> we are done
10308  if (get_token() == token_type::end_object)
10309  {
10310  if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10311  {
10312  return false;
10313  }
10314  break;
10315  }
10316 
10317  // parse key
10318  if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
10319  {
10320  return sax->parse_error(m_lexer.get_position(),
10323  exception_message(token_type::value_string, "object key")));
10324  }
10325  if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10326  {
10327  return false;
10328  }
10329 
10330  // parse separator (:)
10331  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10332  {
10333  return sax->parse_error(m_lexer.get_position(),
10336  exception_message(token_type::name_separator, "object separator")));
10337  }
10338 
10339  // remember we are now inside an object
10340  states.push_back(false);
10341 
10342  // parse values
10343  get_token();
10344  continue;
10345  }
10346 
10347  case token_type::begin_array:
10348  {
10349  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10350  {
10351  return false;
10352  }
10353 
10354  // closing ] -> we are done
10355  if (get_token() == token_type::end_array)
10356  {
10357  if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10358  {
10359  return false;
10360  }
10361  break;
10362  }
10363 
10364  // remember we are now inside an array
10365  states.push_back(true);
10366 
10367  // parse values (no need to call get_token)
10368  continue;
10369  }
10370 
10371  case token_type::value_float:
10372  {
10373  const auto res = m_lexer.get_number_float();
10374 
10375  if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
10376  {
10377  return sax->parse_error(m_lexer.get_position(),
10379  out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
10380  }
10381 
10382  if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
10383  {
10384  return false;
10385  }
10386 
10387  break;
10388  }
10389 
10390  case token_type::literal_false:
10391  {
10392  if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
10393  {
10394  return false;
10395  }
10396  break;
10397  }
10398 
10399  case token_type::literal_null:
10400  {
10401  if (JSON_HEDLEY_UNLIKELY(!sax->null()))
10402  {
10403  return false;
10404  }
10405  break;
10406  }
10407 
10408  case token_type::literal_true:
10409  {
10410  if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
10411  {
10412  return false;
10413  }
10414  break;
10415  }
10416 
10417  case token_type::value_integer:
10418  {
10419  if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
10420  {
10421  return false;
10422  }
10423  break;
10424  }
10425 
10426  case token_type::value_string:
10427  {
10428  if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
10429  {
10430  return false;
10431  }
10432  break;
10433  }
10434 
10435  case token_type::value_unsigned:
10436  {
10437  if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
10438  {
10439  return false;
10440  }
10441  break;
10442  }
10443 
10444  case token_type::parse_error:
10445  {
10446  // using "uninitialized" to avoid "expected" message
10447  return sax->parse_error(m_lexer.get_position(),
10450  exception_message(token_type::uninitialized, "value")));
10451  }
10452 
10453  default: // the last token was unexpected
10454  {
10455  return sax->parse_error(m_lexer.get_position(),
10458  exception_message(token_type::literal_or_value, "value")));
10459  }
10460  }
10461  }
10462  else
10463  {
10464  skip_to_state_evaluation = false;
10465  }
10466 
10467  // we reached this line after we successfully parsed a value
10468  if (states.empty())
10469  {
10470  // empty stack: we reached the end of the hierarchy: done
10471  return true;
10472  }
10473 
10474  if (states.back()) // array
10475  {
10476  // comma -> next value
10477  if (get_token() == token_type::value_separator)
10478  {
10479  // parse a new value
10480  get_token();
10481  continue;
10482  }
10483 
10484  // closing ]
10485  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
10486  {
10487  if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10488  {
10489  return false;
10490  }
10491 
10492  // We are done with this array. Before we can parse a
10493  // new value, we need to evaluate the new state first.
10494  // By setting skip_to_state_evaluation to false, we
10495  // are effectively jumping to the beginning of this if.
10496  JSON_ASSERT(!states.empty());
10497  states.pop_back();
10498  skip_to_state_evaluation = true;
10499  continue;
10500  }
10501 
10502  return sax->parse_error(m_lexer.get_position(),
10505  exception_message(token_type::end_array, "array")));
10506  }
10507  else // object
10508  {
10509  // comma -> next value
10510  if (get_token() == token_type::value_separator)
10511  {
10512  // parse key
10513  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
10514  {
10515  return sax->parse_error(m_lexer.get_position(),
10518  exception_message(token_type::value_string, "object key")));
10519  }
10520 
10521  if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10522  {
10523  return false;
10524  }
10525 
10526  // parse separator (:)
10527  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10528  {
10529  return sax->parse_error(m_lexer.get_position(),
10532  exception_message(token_type::name_separator, "object separator")));
10533  }
10534 
10535  // parse values
10536  get_token();
10537  continue;
10538  }
10539 
10540  // closing }
10541  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
10542  {
10543  if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10544  {
10545  return false;
10546  }
10547 
10548  // We are done with this object. Before we can parse a
10549  // new value, we need to evaluate the new state first.
10550  // By setting skip_to_state_evaluation to false, we
10551  // are effectively jumping to the beginning of this if.
10552  JSON_ASSERT(!states.empty());
10553  states.pop_back();
10554  skip_to_state_evaluation = true;
10555  continue;
10556  }
10557 
10558  return sax->parse_error(m_lexer.get_position(),
10561  exception_message(token_type::end_object, "object")));
10562  }
10563  }
10564  }
10565 
10567  token_type get_token()
10568  {
10569  return last_token = m_lexer.scan();
10570  }
10571 
10572  std::string exception_message(const token_type expected, const std::string& context)
10573  {
10574  std::string error_msg = "syntax error ";
10575 
10576  if (!context.empty())
10577  {
10578  error_msg += "while parsing " + context + " ";
10579  }
10580 
10581  error_msg += "- ";
10582 
10583  if (last_token == token_type::parse_error)
10584  {
10585  error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
10586  m_lexer.get_token_string() + "'";
10587  }
10588  else
10589  {
10590  error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
10591  }
10592 
10593  if (expected != token_type::uninitialized)
10594  {
10595  error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
10596  }
10597 
10598  return error_msg;
10599  }
10600 
10601  private:
10603  const parser_callback_t<BasicJsonType> callback = nullptr;
10605  token_type last_token = token_type::uninitialized;
10609  const bool allow_exceptions = true;
10610 };
10611 } // namespace detail
10612 } // namespace nlohmann
10613 
10614 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
10615 
10616 
10617 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
10618 
10619 
10620 #include <cstddef> // ptrdiff_t
10621 #include <limits> // numeric_limits
10622 
10623 namespace nlohmann
10624 {
10625 namespace detail
10626 {
10627 /*
10628 @brief an iterator for primitive JSON types
10629 
10630 This class models an iterator for primitive JSON types (boolean, number,
10631 string). It's only purpose is to allow the iterator/const_iterator classes
10632 to "iterate" over primitive values. Internally, the iterator is modeled by
10633 a `difference_type` variable. Value begin_value (`0`) models the begin,
10634 end_value (`1`) models past the end.
10635 */
10637 {
10638  private:
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;
10642 
10644  difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
10645 
10646  public:
10647  constexpr difference_type get_value() const noexcept
10648  {
10649  return m_it;
10650  }
10651 
10653  void set_begin() noexcept
10654  {
10655  m_it = begin_value;
10656  }
10657 
10659  void set_end() noexcept
10660  {
10661  m_it = end_value;
10662  }
10663 
10665  constexpr bool is_begin() const noexcept
10666  {
10667  return m_it == begin_value;
10668  }
10669 
10671  constexpr bool is_end() const noexcept
10672  {
10673  return m_it == end_value;
10674  }
10675 
10676  friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10677  {
10678  return lhs.m_it == rhs.m_it;
10679  }
10680 
10681  friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10682  {
10683  return lhs.m_it < rhs.m_it;
10684  }
10685 
10687  {
10688  auto result = *this;
10689  result += n;
10690  return result;
10691  }
10692 
10694  {
10695  return lhs.m_it - rhs.m_it;
10696  }
10697 
10699  {
10700  ++m_it;
10701  return *this;
10702  }
10703 
10704  primitive_iterator_t const operator++(int) noexcept
10705  {
10706  auto result = *this;
10707  ++m_it;
10708  return result;
10709  }
10710 
10712  {
10713  --m_it;
10714  return *this;
10715  }
10716 
10717  primitive_iterator_t const operator--(int) noexcept
10718  {
10719  auto result = *this;
10720  --m_it;
10721  return result;
10722  }
10723 
10725  {
10726  m_it += n;
10727  return *this;
10728  }
10729 
10731  {
10732  m_it -= n;
10733  return *this;
10734  }
10735 };
10736 } // namespace detail
10737 } // namespace nlohmann
10738 
10739 
10740 namespace nlohmann
10741 {
10742 namespace detail
10743 {
10750 template<typename BasicJsonType> struct internal_iterator
10751 {
10753  typename BasicJsonType::object_t::iterator object_iterator {};
10755  typename BasicJsonType::array_t::iterator array_iterator {};
10758 };
10759 } // namespace detail
10760 } // namespace nlohmann
10761 
10762 // #include <nlohmann/detail/iterators/iter_impl.hpp>
10763 
10764 
10765 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
10766 #include <type_traits> // conditional, is_const, remove_const
10767 
10768 // #include <nlohmann/detail/exceptions.hpp>
10769 
10770 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
10771 
10772 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
10773 
10774 // #include <nlohmann/detail/macro_scope.hpp>
10775 
10776 // #include <nlohmann/detail/meta/cpp_future.hpp>
10777 
10778 // #include <nlohmann/detail/meta/type_traits.hpp>
10779 
10780 // #include <nlohmann/detail/value_t.hpp>
10781 
10782 
10783 namespace nlohmann
10784 {
10785 namespace detail
10786 {
10787 // forward declare, to be able to friend it later on
10788 template<typename IteratorType> class iteration_proxy;
10789 template<typename IteratorType> class iteration_proxy_value;
10790 
10807 template<typename BasicJsonType>
10809 {
10811  friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
10815 
10816  using object_t = typename BasicJsonType::object_t;
10817  using array_t = typename BasicJsonType::array_t;
10818  // make sure BasicJsonType is basic_json or const basic_json
10819  static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
10820  "iter_impl only accepts (const) basic_json");
10821 
10822  public:
10823 
10829  using iterator_category = std::bidirectional_iterator_tag;
10830 
10832  using value_type = typename BasicJsonType::value_type;
10834  using difference_type = typename BasicJsonType::difference_type;
10837  typename BasicJsonType::const_pointer,
10838  typename BasicJsonType::pointer>::type;
10840  using reference =
10842  typename BasicJsonType::const_reference,
10843  typename BasicJsonType::reference>::type;
10844 
10846  iter_impl() = default;
10847 
10854  explicit iter_impl(pointer object) noexcept : m_object(object)
10855  {
10856  JSON_ASSERT(m_object != nullptr);
10857 
10858  switch (m_object->m_type)
10859  {
10860  case value_t::object:
10861  {
10862  m_it.object_iterator = typename object_t::iterator();
10863  break;
10864  }
10865 
10866  case value_t::array:
10867  {
10868  m_it.array_iterator = typename array_t::iterator();
10869  break;
10870  }
10871 
10872  default:
10873  {
10875  break;
10876  }
10877  }
10878  }
10879 
10897  : m_object(other.m_object), m_it(other.m_it)
10898  {}
10899 
10907  {
10908  m_object = other.m_object;
10909  m_it = other.m_it;
10910  return *this;
10911  }
10912 
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)
10920  {}
10921 
10928  iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
10929  {
10930  m_object = other.m_object;
10931  m_it = other.m_it;
10932  return *this;
10933  }
10934 
10935  private:
10940  void set_begin() noexcept
10941  {
10942  JSON_ASSERT(m_object != nullptr);
10943 
10944  switch (m_object->m_type)
10945  {
10946  case value_t::object:
10947  {
10948  m_it.object_iterator = m_object->m_value.object->begin();
10949  break;
10950  }
10951 
10952  case value_t::array:
10953  {
10954  m_it.array_iterator = m_object->m_value.array->begin();
10955  break;
10956  }
10957 
10958  case value_t::null:
10959  {
10960  // set to end so begin()==end() is true: null is empty
10962  break;
10963  }
10964 
10965  default:
10966  {
10968  break;
10969  }
10970  }
10971  }
10972 
10977  void set_end() noexcept
10978  {
10979  JSON_ASSERT(m_object != nullptr);
10980 
10981  switch (m_object->m_type)
10982  {
10983  case value_t::object:
10984  {
10985  m_it.object_iterator = m_object->m_value.object->end();
10986  break;
10987  }
10988 
10989  case value_t::array:
10990  {
10991  m_it.array_iterator = m_object->m_value.array->end();
10992  break;
10993  }
10994 
10995  default:
10996  {
10998  break;
10999  }
11000  }
11001  }
11002 
11003  public:
11009  {
11010  JSON_ASSERT(m_object != nullptr);
11011 
11012  switch (m_object->m_type)
11013  {
11014  case value_t::object:
11015  {
11016  JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11017  return m_it.object_iterator->second;
11018  }
11019 
11020  case value_t::array:
11021  {
11022  JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11023  return *m_it.array_iterator;
11024  }
11025 
11026  case value_t::null:
11027  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11028 
11029  default:
11030  {
11031  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11032  {
11033  return *m_object;
11034  }
11035 
11036  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11037  }
11038  }
11039  }
11040 
11046  {
11047  JSON_ASSERT(m_object != nullptr);
11048 
11049  switch (m_object->m_type)
11050  {
11051  case value_t::object:
11052  {
11053  JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11054  return &(m_it.object_iterator->second);
11055  }
11056 
11057  case value_t::array:
11058  {
11059  JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11060  return &*m_it.array_iterator;
11061  }
11062 
11063  default:
11064  {
11065  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11066  {
11067  return m_object;
11068  }
11069 
11070  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11071  }
11072  }
11073  }
11074 
11080  {
11081  auto result = *this;
11082  ++(*this);
11083  return result;
11084  }
11085 
11091  {
11092  JSON_ASSERT(m_object != nullptr);
11093 
11094  switch (m_object->m_type)
11095  {
11096  case value_t::object:
11097  {
11098  std::advance(m_it.object_iterator, 1);
11099  break;
11100  }
11101 
11102  case value_t::array:
11103  {
11104  std::advance(m_it.array_iterator, 1);
11105  break;
11106  }
11107 
11108  default:
11109  {
11111  break;
11112  }
11113  }
11114 
11115  return *this;
11116  }
11117 
11123  {
11124  auto result = *this;
11125  --(*this);
11126  return result;
11127  }
11128 
11134  {
11135  JSON_ASSERT(m_object != nullptr);
11136 
11137  switch (m_object->m_type)
11138  {
11139  case value_t::object:
11140  {
11141  std::advance(m_it.object_iterator, -1);
11142  break;
11143  }
11144 
11145  case value_t::array:
11146  {
11147  std::advance(m_it.array_iterator, -1);
11148  break;
11149  }
11150 
11151  default:
11152  {
11154  break;
11155  }
11156  }
11157 
11158  return *this;
11159  }
11160 
11165  bool operator==(const iter_impl& other) const
11166  {
11167  // if objects are not the same, the comparison is undefined
11168  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11169  {
11170  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
11171  }
11172 
11173  JSON_ASSERT(m_object != nullptr);
11174 
11175  switch (m_object->m_type)
11176  {
11177  case value_t::object:
11178  return (m_it.object_iterator == other.m_it.object_iterator);
11179 
11180  case value_t::array:
11181  return (m_it.array_iterator == other.m_it.array_iterator);
11182 
11183  default:
11184  return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11185  }
11186  }
11187 
11192  bool operator!=(const iter_impl& other) const
11193  {
11194  return !operator==(other);
11195  }
11196 
11201  bool operator<(const iter_impl& other) const
11202  {
11203  // if objects are not the same, the comparison is undefined
11204  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11205  {
11206  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
11207  }
11208 
11209  JSON_ASSERT(m_object != nullptr);
11210 
11211  switch (m_object->m_type)
11212  {
11213  case value_t::object:
11214  JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
11215 
11216  case value_t::array:
11217  return (m_it.array_iterator < other.m_it.array_iterator);
11218 
11219  default:
11221  }
11222  }
11223 
11228  bool operator<=(const iter_impl& other) const
11229  {
11230  return !other.operator < (*this);
11231  }
11232 
11237  bool operator>(const iter_impl& other) const
11238  {
11239  return !operator<=(other);
11240  }
11241 
11246  bool operator>=(const iter_impl& other) const
11247  {
11248  return !operator<(other);
11249  }
11250 
11256  {
11257  JSON_ASSERT(m_object != nullptr);
11258 
11259  switch (m_object->m_type)
11260  {
11261  case value_t::object:
11262  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
11263 
11264  case value_t::array:
11265  {
11266  std::advance(m_it.array_iterator, i);
11267  break;
11268  }
11269 
11270  default:
11271  {
11272  m_it.primitive_iterator += i;
11273  break;
11274  }
11275  }
11276 
11277  return *this;
11278  }
11279 
11285  {
11286  return operator+=(-i);
11287  }
11288 
11294  {
11295  auto result = *this;
11296  result += i;
11297  return result;
11298  }
11299 
11305  {
11306  auto result = it;
11307  result += i;
11308  return result;
11309  }
11310 
11316  {
11317  auto result = *this;
11318  result -= i;
11319  return result;
11320  }
11321 
11327  {
11328  JSON_ASSERT(m_object != nullptr);
11329 
11330  switch (m_object->m_type)
11331  {
11332  case value_t::object:
11333  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
11334 
11335  case value_t::array:
11336  return m_it.array_iterator - other.m_it.array_iterator;
11337 
11338  default:
11340  }
11341  }
11342 
11348  {
11349  JSON_ASSERT(m_object != nullptr);
11350 
11351  switch (m_object->m_type)
11352  {
11353  case value_t::object:
11354  JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
11355 
11356  case value_t::array:
11357  return *std::next(m_it.array_iterator, n);
11358 
11359  case value_t::null:
11360  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11361 
11362  default:
11363  {
11364  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
11365  {
11366  return *m_object;
11367  }
11368 
11369  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11370  }
11371  }
11372  }
11373 
11378  const typename object_t::key_type& key() const
11379  {
11380  JSON_ASSERT(m_object != nullptr);
11381 
11382  if (JSON_HEDLEY_LIKELY(m_object->is_object()))
11383  {
11384  return m_it.object_iterator->first;
11385  }
11386 
11387  JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
11388  }
11389 
11395  {
11396  return operator*();
11397  }
11398 
11399  private:
11401  pointer m_object = nullptr;
11404 };
11405 } // namespace detail
11406 } // namespace nlohmann
11407 
11408 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
11409 
11410 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
11411 
11412 
11413 #include <cstddef> // ptrdiff_t
11414 #include <iterator> // reverse_iterator
11415 #include <utility> // declval
11416 
11417 namespace nlohmann
11418 {
11419 namespace detail
11420 {
11422 // reverse_iterator //
11424 
11443 template<typename Base>
11444 class json_reverse_iterator : public std::reverse_iterator<Base>
11445 {
11446  public:
11447  using difference_type = std::ptrdiff_t;
11449  using base_iterator = std::reverse_iterator<Base>;
11451  using reference = typename Base::reference;
11452 
11454  explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
11455  : base_iterator(it) {}
11456 
11458  explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
11459 
11462  {
11463  return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
11464  }
11465 
11468  {
11469  return static_cast<json_reverse_iterator&>(base_iterator::operator++());
11470  }
11471 
11474  {
11475  return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
11476  }
11477 
11480  {
11481  return static_cast<json_reverse_iterator&>(base_iterator::operator--());
11482  }
11483 
11486  {
11487  return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
11488  }
11489 
11492  {
11493  return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
11494  }
11495 
11498  {
11499  return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
11500  }
11501 
11504  {
11505  return base_iterator(*this) - base_iterator(other);
11506  }
11507 
11510  {
11511  return *(this->operator+(n));
11512  }
11513 
11515  auto key() const -> decltype(std::declval<Base>().key())
11516  {
11517  auto it = --this->base();
11518  return it.key();
11519  }
11520 
11523  {
11524  auto it = --this->base();
11525  return it.operator * ();
11526  }
11527 };
11528 } // namespace detail
11529 } // namespace nlohmann
11530 
11531 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
11532 
11533 // #include <nlohmann/detail/json_pointer.hpp>
11534 
11535 
11536 #include <algorithm> // all_of
11537 #include <cctype> // isdigit
11538 #include <limits> // max
11539 #include <numeric> // accumulate
11540 #include <string> // string
11541 #include <utility> // move
11542 #include <vector> // vector
11543 
11544 // #include <nlohmann/detail/exceptions.hpp>
11545 
11546 // #include <nlohmann/detail/macro_scope.hpp>
11547 
11548 // #include <nlohmann/detail/value_t.hpp>
11549 
11550 
11551 namespace nlohmann
11552 {
11553 template<typename BasicJsonType>
11555 {
11556  // allow basic_json to access private members
11557  NLOHMANN_BASIC_JSON_TPL_DECLARATION
11558  friend class basic_json;
11559 
11560  public:
11582  explicit json_pointer(const std::string& s = "")
11583  : reference_tokens(split(s))
11584  {}
11585 
11600  std::string to_string() const
11601  {
11602  return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
11603  std::string{},
11604  [](const std::string & a, const std::string & b)
11605  {
11606  return a + "/" + escape(b);
11607  });
11608  }
11609 
11611  operator std::string() const
11612  {
11613  return to_string();
11614  }
11615 
11633  {
11634  reference_tokens.insert(reference_tokens.end(),
11635  ptr.reference_tokens.begin(),
11636  ptr.reference_tokens.end());
11637  return *this;
11638  }
11639 
11656  json_pointer& operator/=(std::string token)
11657  {
11658  push_back(std::move(token));
11659  return *this;
11660  }
11661 
11678  json_pointer& operator/=(std::size_t array_idx)
11679  {
11680  return *this /= std::to_string(array_idx);
11681  }
11682 
11699  const json_pointer& rhs)
11700  {
11701  return json_pointer(lhs) /= rhs;
11702  }
11703 
11719  friend json_pointer operator/(const json_pointer& ptr, std::string token)
11720  {
11721  return json_pointer(ptr) /= std::move(token);
11722  }
11723 
11739  friend json_pointer operator/(const json_pointer& ptr, std::size_t array_idx)
11740  {
11741  return json_pointer(ptr) /= array_idx;
11742  }
11743 
11758  {
11759  if (empty())
11760  {
11761  return *this;
11762  }
11763 
11764  json_pointer res = *this;
11765  res.pop_back();
11766  return res;
11767  }
11768 
11782  void pop_back()
11783  {
11784  if (JSON_HEDLEY_UNLIKELY(empty()))
11785  {
11786  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
11787  }
11788 
11789  reference_tokens.pop_back();
11790  }
11791 
11806  const std::string& back() const
11807  {
11808  if (JSON_HEDLEY_UNLIKELY(empty()))
11809  {
11810  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
11811  }
11812 
11813  return reference_tokens.back();
11814  }
11815 
11828  void push_back(const std::string& token)
11829  {
11830  reference_tokens.push_back(token);
11831  }
11832 
11834  void push_back(std::string&& token)
11835  {
11836  reference_tokens.push_back(std::move(token));
11837  }
11838 
11853  bool empty() const noexcept
11854  {
11855  return reference_tokens.empty();
11856  }
11857 
11858  private:
11869  static typename BasicJsonType::size_type array_index(const std::string& s)
11870  {
11871  using size_type = typename BasicJsonType::size_type;
11872 
11873  // error condition (cf. RFC 6901, Sect. 4)
11874  if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
11875  {
11876  JSON_THROW(detail::parse_error::create(106, 0,
11877  "array index '" + s +
11878  "' must not begin with '0'"));
11879  }
11880 
11881  // error condition (cf. RFC 6901, Sect. 4)
11882  if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
11883  {
11884  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
11885  }
11886 
11887  std::size_t processed_chars = 0;
11888  unsigned long long res = 0;
11889  JSON_TRY
11890  {
11891  res = std::stoull(s, &processed_chars);
11892  }
11893  JSON_CATCH(std::out_of_range&)
11894  {
11895  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
11896  }
11897 
11898  // check if the string was completely read
11899  if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
11900  {
11901  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
11902  }
11903 
11904  // only triggered on special platforms (like 32bit), see also
11905  // https://github.com/nlohmann/json/pull/2203
11906  if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
11907  {
11908  JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
11909  }
11910 
11911  return static_cast<size_type>(res);
11912  }
11913 
11915  {
11916  if (JSON_HEDLEY_UNLIKELY(empty()))
11917  {
11918  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
11919  }
11920 
11921  json_pointer result = *this;
11922  result.reference_tokens = {reference_tokens[0]};
11923  return result;
11924  }
11925 
11934  BasicJsonType& get_and_create(BasicJsonType& j) const
11935  {
11936  auto result = &j;
11937 
11938  // in case no reference tokens exist, return a reference to the JSON value
11939  // j which will be overwritten by a primitive value
11940  for (const auto& reference_token : reference_tokens)
11941  {
11942  switch (result->type())
11943  {
11944  case detail::value_t::null:
11945  {
11946  if (reference_token == "0")
11947  {
11948  // start a new array if reference token is 0
11949  result = &result->operator[](0);
11950  }
11951  else
11952  {
11953  // start a new object otherwise
11954  result = &result->operator[](reference_token);
11955  }
11956  break;
11957  }
11958 
11960  {
11961  // create an entry in the object
11962  result = &result->operator[](reference_token);
11963  break;
11964  }
11965 
11967  {
11968  // create an entry in the array
11969  result = &result->operator[](array_index(reference_token));
11970  break;
11971  }
11972 
11973  /*
11974  The following code is only reached if there exists a reference
11975  token _and_ the current value is primitive. In this case, we have
11976  an error situation, because primitive values may only occur as
11977  single value; that is, with an empty list of reference tokens.
11978  */
11979  default:
11980  JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
11981  }
11982  }
11983 
11984  return *result;
11985  }
11986 
12006  BasicJsonType& get_unchecked(BasicJsonType* ptr) const
12007  {
12008  for (const auto& reference_token : reference_tokens)
12009  {
12010  // convert null values to arrays or objects before continuing
12011  if (ptr->is_null())
12012  {
12013  // check if reference token is a number
12014  const bool nums =
12015  std::all_of(reference_token.begin(), reference_token.end(),
12016  [](const unsigned char x)
12017  {
12018  return std::isdigit(x);
12019  });
12020 
12021  // change value to array for numbers or "-" or to object otherwise
12022  *ptr = (nums || reference_token == "-")
12025  }
12026 
12027  switch (ptr->type())
12028  {
12030  {
12031  // use unchecked object access
12032  ptr = &ptr->operator[](reference_token);
12033  break;
12034  }
12035 
12037  {
12038  if (reference_token == "-")
12039  {
12040  // explicitly treat "-" as index beyond the end
12041  ptr = &ptr->operator[](ptr->m_value.array->size());
12042  }
12043  else
12044  {
12045  // convert array index to number; unchecked access
12046  ptr = &ptr->operator[](array_index(reference_token));
12047  }
12048  break;
12049  }
12050 
12051  default:
12052  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12053  }
12054  }
12055 
12056  return *ptr;
12057  }
12058 
12065  BasicJsonType& get_checked(BasicJsonType* ptr) const
12066  {
12067  for (const auto& reference_token : reference_tokens)
12068  {
12069  switch (ptr->type())
12070  {
12072  {
12073  // note: at performs range check
12074  ptr = &ptr->at(reference_token);
12075  break;
12076  }
12077 
12079  {
12080  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12081  {
12082  // "-" always fails the range check
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"));
12086  }
12087 
12088  // note: at performs range check
12089  ptr = &ptr->at(array_index(reference_token));
12090  break;
12091  }
12092 
12093  default:
12094  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12095  }
12096  }
12097 
12098  return *ptr;
12099  }
12100 
12114  const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
12115  {
12116  for (const auto& reference_token : reference_tokens)
12117  {
12118  switch (ptr->type())
12119  {
12121  {
12122  // use unchecked object access
12123  ptr = &ptr->operator[](reference_token);
12124  break;
12125  }
12126 
12128  {
12129  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12130  {
12131  // "-" cannot be used for const access
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"));
12135  }
12136 
12137  // use unchecked array access
12138  ptr = &ptr->operator[](array_index(reference_token));
12139  break;
12140  }
12141 
12142  default:
12143  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12144  }
12145  }
12146 
12147  return *ptr;
12148  }
12149 
12156  const BasicJsonType& get_checked(const BasicJsonType* ptr) const
12157  {
12158  for (const auto& reference_token : reference_tokens)
12159  {
12160  switch (ptr->type())
12161  {
12163  {
12164  // note: at performs range check
12165  ptr = &ptr->at(reference_token);
12166  break;
12167  }
12168 
12170  {
12171  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12172  {
12173  // "-" always fails the range check
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"));
12177  }
12178 
12179  // note: at performs range check
12180  ptr = &ptr->at(array_index(reference_token));
12181  break;
12182  }
12183 
12184  default:
12185  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12186  }
12187  }
12188 
12189  return *ptr;
12190  }
12191 
12196  bool contains(const BasicJsonType* ptr) const
12197  {
12198  for (const auto& reference_token : reference_tokens)
12199  {
12200  switch (ptr->type())
12201  {
12203  {
12204  if (!ptr->contains(reference_token))
12205  {
12206  // we did not find the key in the object
12207  return false;
12208  }
12209 
12210  ptr = &ptr->operator[](reference_token);
12211  break;
12212  }
12213 
12215  {
12216  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12217  {
12218  // "-" always fails the range check
12219  return false;
12220  }
12221  if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
12222  {
12223  // invalid char
12224  return false;
12225  }
12226  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
12227  {
12228  if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
12229  {
12230  // first char should be between '1' and '9'
12231  return false;
12232  }
12233  for (std::size_t i = 1; i < reference_token.size(); i++)
12234  {
12235  if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
12236  {
12237  // other char should be between '0' and '9'
12238  return false;
12239  }
12240  }
12241  }
12242 
12243  const auto idx = array_index(reference_token);
12244  if (idx >= ptr->size())
12245  {
12246  // index out of range
12247  return false;
12248  }
12249 
12250  ptr = &ptr->operator[](idx);
12251  break;
12252  }
12253 
12254  default:
12255  {
12256  // we do not expect primitive values if there is still a
12257  // reference token to process
12258  return false;
12259  }
12260  }
12261  }
12262 
12263  // no reference token left means we found a primitive value
12264  return true;
12265  }
12266 
12276  static std::vector<std::string> split(const std::string& reference_string)
12277  {
12278  std::vector<std::string> result;
12279 
12280  // special case: empty reference string -> no reference tokens
12281  if (reference_string.empty())
12282  {
12283  return result;
12284  }
12285 
12286  // check if nonempty reference string begins with slash
12287  if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
12288  {
12289  JSON_THROW(detail::parse_error::create(107, 1,
12290  "JSON pointer must be empty or begin with '/' - was: '" +
12291  reference_string + "'"));
12292  }
12293 
12294  // extract the reference tokens:
12295  // - slash: position of the last read slash (or end of string)
12296  // - start: position after the previous slash
12297  for (
12298  // search for the first slash after the first character
12299  std::size_t slash = reference_string.find_first_of('/', 1),
12300  // set the beginning of the first reference token
12301  start = 1;
12302  // we can stop if start == 0 (if slash == std::string::npos)
12303  start != 0;
12304  // set the beginning of the next reference token
12305  // (will eventually be 0 if slash == std::string::npos)
12306  start = (slash == std::string::npos) ? 0 : slash + 1,
12307  // find next slash
12308  slash = reference_string.find_first_of('/', start))
12309  {
12310  // use the text between the beginning of the reference token
12311  // (start) and the last slash (slash).
12312  auto reference_token = reference_string.substr(start, slash - start);
12313 
12314  // check reference tokens are properly escaped
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))
12318  {
12319  JSON_ASSERT(reference_token[pos] == '~');
12320 
12321  // ~ must be followed by 0 or 1
12322  if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
12323  (reference_token[pos + 1] != '0' &&
12324  reference_token[pos + 1] != '1')))
12325  {
12326  JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
12327  }
12328  }
12329 
12330  // finally, store the reference token
12331  unescape(reference_token);
12332  result.push_back(reference_token);
12333  }
12334 
12335  return result;
12336  }
12337 
12351  static void replace_substring(std::string& s, const std::string& f,
12352  const std::string& t)
12353  {
12354  JSON_ASSERT(!f.empty());
12355  for (auto pos = s.find(f); // find first occurrence of f
12356  pos != std::string::npos; // make sure f was found
12357  s.replace(pos, f.size(), t), // replace with t, and
12358  pos = s.find(f, pos + t.size())) // find next occurrence of f
12359  {}
12360  }
12361 
12363  static std::string escape(std::string s)
12364  {
12365  replace_substring(s, "~", "~0");
12366  replace_substring(s, "/", "~1");
12367  return s;
12368  }
12369 
12371  static void unescape(std::string& s)
12372  {
12373  replace_substring(s, "~1", "/");
12374  replace_substring(s, "~0", "~");
12375  }
12376 
12384  static void flatten(const std::string& reference_string,
12385  const BasicJsonType& value,
12386  BasicJsonType& result)
12387  {
12388  switch (value.type())
12389  {
12391  {
12392  if (value.m_value.array->empty())
12393  {
12394  // flatten empty array as null
12395  result[reference_string] = nullptr;
12396  }
12397  else
12398  {
12399  // iterate array and use index as reference string
12400  for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
12401  {
12402  flatten(reference_string + "/" + std::to_string(i),
12403  value.m_value.array->operator[](i), result);
12404  }
12405  }
12406  break;
12407  }
12408 
12410  {
12411  if (value.m_value.object->empty())
12412  {
12413  // flatten empty object as null
12414  result[reference_string] = nullptr;
12415  }
12416  else
12417  {
12418  // iterate object and use keys as reference string
12419  for (const auto& element : *value.m_value.object)
12420  {
12421  flatten(reference_string + "/" + escape(element.first), element.second, result);
12422  }
12423  }
12424  break;
12425  }
12426 
12427  default:
12428  {
12429  // add primitive value with its reference string
12430  result[reference_string] = value;
12431  break;
12432  }
12433  }
12434  }
12435 
12446  static BasicJsonType
12447  unflatten(const BasicJsonType& value)
12448  {
12449  if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
12450  {
12451  JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
12452  }
12453 
12454  BasicJsonType result;
12455 
12456  // iterate the JSON object values
12457  for (const auto& element : *value.m_value.object)
12458  {
12459  if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
12460  {
12461  JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
12462  }
12463 
12464  // assign value to reference pointed to by JSON pointer; Note that if
12465  // the JSON pointer is "" (i.e., points to the whole value), function
12466  // get_and_create returns a reference to result itself. An assignment
12467  // will then create a primitive value.
12468  json_pointer(element.first).get_and_create(result) = element.second;
12469  }
12470 
12471  return result;
12472  }
12473 
12485  friend bool operator==(json_pointer const& lhs,
12486  json_pointer const& rhs) noexcept
12487  {
12488  return lhs.reference_tokens == rhs.reference_tokens;
12489  }
12490 
12502  friend bool operator!=(json_pointer const& lhs,
12503  json_pointer const& rhs) noexcept
12504  {
12505  return !(lhs == rhs);
12506  }
12507 
12509  std::vector<std::string> reference_tokens;
12510 };
12511 } // namespace nlohmann
12512 
12513 // #include <nlohmann/detail/json_ref.hpp>
12514 
12515 
12516 #include <initializer_list>
12517 #include <utility>
12518 
12519 // #include <nlohmann/detail/meta/type_traits.hpp>
12520 
12521 
12522 namespace nlohmann
12523 {
12524 namespace detail
12525 {
12526 template<typename BasicJsonType>
12528 {
12529  public:
12530  using value_type = BasicJsonType;
12531 
12533  : owned_value(std::move(value))
12535  , is_rvalue(true)
12536  {}
12537 
12539  : value_ref(const_cast<value_type*>(&value))
12540  , is_rvalue(false)
12541  {}
12542 
12543  json_ref(std::initializer_list<json_ref> init)
12544  : owned_value(init)
12546  , is_rvalue(true)
12547  {}
12548 
12549  template <
12550  class... Args,
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)...)
12555  , is_rvalue(true)
12556  {}
12557 
12558  // class should be movable only
12559  json_ref(json_ref&&) = default;
12560  json_ref(const json_ref&) = delete;
12561  json_ref& operator=(const json_ref&) = delete;
12563  ~json_ref() = default;
12564 
12566  {
12567  if (is_rvalue)
12568  {
12569  return std::move(*value_ref);
12570  }
12571  return *value_ref;
12572  }
12573 
12574  value_type const& operator*() const
12575  {
12576  return *static_cast<value_type const*>(value_ref);
12577  }
12578 
12579  value_type const* operator->() const
12580  {
12581  return static_cast<value_type const*>(value_ref);
12582  }
12583 
12584  private:
12585  mutable value_type owned_value = nullptr;
12586  value_type* value_ref = nullptr;
12587  const bool is_rvalue = true;
12588 };
12589 } // namespace detail
12590 } // namespace nlohmann
12591 
12592 // #include <nlohmann/detail/macro_scope.hpp>
12593 
12594 // #include <nlohmann/detail/meta/cpp_future.hpp>
12595 
12596 // #include <nlohmann/detail/meta/type_traits.hpp>
12597 
12598 // #include <nlohmann/detail/output/binary_writer.hpp>
12599 
12600 
12601 #include <algorithm> // reverse
12602 #include <array> // array
12603 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
12604 #include <cstring> // memcpy
12605 #include <limits> // numeric_limits
12606 #include <string> // string
12607 #include <cmath> // isnan, isinf
12608 
12609 // #include <nlohmann/detail/input/binary_reader.hpp>
12610 
12611 // #include <nlohmann/detail/macro_scope.hpp>
12612 
12613 // #include <nlohmann/detail/output/output_adapters.hpp>
12614 
12615 
12616 #include <algorithm> // copy
12617 #include <cstddef> // size_t
12618 #include <ios> // streamsize
12619 #include <iterator> // back_inserter
12620 #include <memory> // shared_ptr, make_shared
12621 #include <ostream> // basic_ostream
12622 #include <string> // basic_string
12623 #include <vector> // vector
12624 // #include <nlohmann/detail/macro_scope.hpp>
12625 
12626 
12627 namespace nlohmann
12628 {
12629 namespace detail
12630 {
12632 template<typename CharType> struct output_adapter_protocol
12633 {
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;
12637 };
12638 
12640 template<typename CharType>
12641 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
12642 
12644 template<typename CharType>
12646 {
12647  public:
12648  explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
12649  : v(vec)
12650  {}
12651 
12652  void write_character(CharType c) override
12653  {
12654  v.push_back(c);
12655  }
12656 
12658  void write_characters(const CharType* s, std::size_t length) override
12659  {
12660  std::copy(s, s + length, std::back_inserter(v));
12661  }
12662 
12663  private:
12664  std::vector<CharType>& v;
12665 };
12666 
12668 template<typename CharType>
12670 {
12671  public:
12672  explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
12673  : stream(s)
12674  {}
12675 
12676  void write_character(CharType c) override
12677  {
12678  stream.put(c);
12679  }
12680 
12682  void write_characters(const CharType* s, std::size_t length) override
12683  {
12684  stream.write(s, static_cast<std::streamsize>(length));
12685  }
12686 
12687  private:
12688  std::basic_ostream<CharType>& stream;
12689 };
12690 
12692 template<typename CharType, typename StringType = std::basic_string<CharType>>
12694 {
12695  public:
12696  explicit output_string_adapter(StringType& s) noexcept
12697  : str(s)
12698  {}
12699 
12700  void write_character(CharType c) override
12701  {
12702  str.push_back(c);
12703  }
12704 
12706  void write_characters(const CharType* s, std::size_t length) override
12707  {
12708  str.append(s, length);
12709  }
12710 
12711  private:
12712  StringType& str;
12713 };
12714 
12715 template<typename CharType, typename StringType = std::basic_string<CharType>>
12717 {
12718  public:
12719  output_adapter(std::vector<CharType>& vec)
12720  : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
12721 
12722  output_adapter(std::basic_ostream<CharType>& s)
12723  : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
12724 
12725  output_adapter(StringType& s)
12726  : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
12727 
12729  {
12730  return oa;
12731  }
12732 
12733  private:
12735 };
12736 } // namespace detail
12737 } // namespace nlohmann
12738 
12739 
12740 namespace nlohmann
12741 {
12742 namespace detail
12743 {
12745 // binary writer //
12747 
12751 template<typename BasicJsonType, typename CharType>
12753 {
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;
12757 
12758  public:
12764  explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
12765  {
12766  JSON_ASSERT(oa);
12767  }
12768 
12773  void write_bson(const BasicJsonType& j)
12774  {
12775  switch (j.type())
12776  {
12777  case value_t::object:
12778  {
12779  write_bson_object(*j.m_value.object);
12780  break;
12781  }
12782 
12783  default:
12784  {
12785  JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
12786  }
12787  }
12788  }
12789 
12793  void write_cbor(const BasicJsonType& j)
12794  {
12795  switch (j.type())
12796  {
12797  case value_t::null:
12798  {
12799  oa->write_character(to_char_type(0xF6));
12800  break;
12801  }
12802 
12803  case value_t::boolean:
12804  {
12805  oa->write_character(j.m_value.boolean
12806  ? to_char_type(0xF5)
12807  : to_char_type(0xF4));
12808  break;
12809  }
12810 
12812  {
12813  if (j.m_value.number_integer >= 0)
12814  {
12815  // CBOR does not differentiate between positive signed
12816  // integers and unsigned integers. Therefore, we used the
12817  // code from the value_t::number_unsigned case here.
12818  if (j.m_value.number_integer <= 0x17)
12819  {
12820  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
12821  }
12822  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
12823  {
12824  oa->write_character(to_char_type(0x18));
12825  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
12826  }
12827  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
12828  {
12829  oa->write_character(to_char_type(0x19));
12830  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
12831  }
12832  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
12833  {
12834  oa->write_character(to_char_type(0x1A));
12835  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
12836  }
12837  else
12838  {
12839  oa->write_character(to_char_type(0x1B));
12840  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
12841  }
12842  }
12843  else
12844  {
12845  // The conversions below encode the sign in the first
12846  // byte, and the value is converted to a positive number.
12847  const auto positive_number = -1 - j.m_value.number_integer;
12848  if (j.m_value.number_integer >= -24)
12849  {
12850  write_number(static_cast<std::uint8_t>(0x20 + positive_number));
12851  }
12852  else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
12853  {
12854  oa->write_character(to_char_type(0x38));
12855  write_number(static_cast<std::uint8_t>(positive_number));
12856  }
12857  else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
12858  {
12859  oa->write_character(to_char_type(0x39));
12860  write_number(static_cast<std::uint16_t>(positive_number));
12861  }
12862  else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
12863  {
12864  oa->write_character(to_char_type(0x3A));
12865  write_number(static_cast<std::uint32_t>(positive_number));
12866  }
12867  else
12868  {
12869  oa->write_character(to_char_type(0x3B));
12870  write_number(static_cast<std::uint64_t>(positive_number));
12871  }
12872  }
12873  break;
12874  }
12875 
12877  {
12878  if (j.m_value.number_unsigned <= 0x17)
12879  {
12880  write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
12881  }
12882  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
12883  {
12884  oa->write_character(to_char_type(0x18));
12885  write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
12886  }
12887  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
12888  {
12889  oa->write_character(to_char_type(0x19));
12890  write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
12891  }
12892  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
12893  {
12894  oa->write_character(to_char_type(0x1A));
12895  write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
12896  }
12897  else
12898  {
12899  oa->write_character(to_char_type(0x1B));
12900  write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
12901  }
12902  break;
12903  }
12904 
12905  case value_t::number_float:
12906  {
12907  if (std::isnan(j.m_value.number_float))
12908  {
12909  // NaN is 0xf97e00 in CBOR
12910  oa->write_character(to_char_type(0xF9));
12911  oa->write_character(to_char_type(0x7E));
12912  oa->write_character(to_char_type(0x00));
12913  }
12914  else if (std::isinf(j.m_value.number_float))
12915  {
12916  // Infinity is 0xf97c00, -Infinity is 0xf9fc00
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));
12920  }
12921  else
12922  {
12923  write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
12924  }
12925  break;
12926  }
12927 
12928  case value_t::string:
12929  {
12930  // step 1: write control byte and the string length
12931  const auto N = j.m_value.string->size();
12932  if (N <= 0x17)
12933  {
12934  write_number(static_cast<std::uint8_t>(0x60 + N));
12935  }
12936  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
12937  {
12938  oa->write_character(to_char_type(0x78));
12939  write_number(static_cast<std::uint8_t>(N));
12940  }
12941  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
12942  {
12943  oa->write_character(to_char_type(0x79));
12944  write_number(static_cast<std::uint16_t>(N));
12945  }
12946  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
12947  {
12948  oa->write_character(to_char_type(0x7A));
12949  write_number(static_cast<std::uint32_t>(N));
12950  }
12951  // LCOV_EXCL_START
12952  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
12953  {
12954  oa->write_character(to_char_type(0x7B));
12955  write_number(static_cast<std::uint64_t>(N));
12956  }
12957  // LCOV_EXCL_STOP
12958 
12959  // step 2: write the string
12960  oa->write_characters(
12961  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
12962  j.m_value.string->size());
12963  break;
12964  }
12965 
12966  case value_t::array:
12967  {
12968  // step 1: write control byte and the array size
12969  const auto N = j.m_value.array->size();
12970  if (N <= 0x17)
12971  {
12972  write_number(static_cast<std::uint8_t>(0x80 + N));
12973  }
12974  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
12975  {
12976  oa->write_character(to_char_type(0x98));
12977  write_number(static_cast<std::uint8_t>(N));
12978  }
12979  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
12980  {
12981  oa->write_character(to_char_type(0x99));
12982  write_number(static_cast<std::uint16_t>(N));
12983  }
12984  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
12985  {
12986  oa->write_character(to_char_type(0x9A));
12987  write_number(static_cast<std::uint32_t>(N));
12988  }
12989  // LCOV_EXCL_START
12990  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
12991  {
12992  oa->write_character(to_char_type(0x9B));
12993  write_number(static_cast<std::uint64_t>(N));
12994  }
12995  // LCOV_EXCL_STOP
12996 
12997  // step 2: write each element
12998  for (const auto& el : *j.m_value.array)
12999  {
13000  write_cbor(el);
13001  }
13002  break;
13003  }
13004 
13005  case value_t::binary:
13006  {
13007  if (j.m_value.binary->has_subtype())
13008  {
13009  write_number(static_cast<std::uint8_t>(0xd8));
13010  write_number(j.m_value.binary->subtype());
13011  }
13012 
13013  // step 1: write control byte and the binary array size
13014  const auto N = j.m_value.binary->size();
13015  if (N <= 0x17)
13016  {
13017  write_number(static_cast<std::uint8_t>(0x40 + N));
13018  }
13019  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13020  {
13021  oa->write_character(to_char_type(0x58));
13022  write_number(static_cast<std::uint8_t>(N));
13023  }
13024  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13025  {
13026  oa->write_character(to_char_type(0x59));
13027  write_number(static_cast<std::uint16_t>(N));
13028  }
13029  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13030  {
13031  oa->write_character(to_char_type(0x5A));
13032  write_number(static_cast<std::uint32_t>(N));
13033  }
13034  // LCOV_EXCL_START
13035  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13036  {
13037  oa->write_character(to_char_type(0x5B));
13038  write_number(static_cast<std::uint64_t>(N));
13039  }
13040  // LCOV_EXCL_STOP
13041 
13042  // step 2: write each element
13043  oa->write_characters(
13044  reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13045  N);
13046 
13047  break;
13048  }
13049 
13050  case value_t::object:
13051  {
13052  // step 1: write control byte and the object size
13053  const auto N = j.m_value.object->size();
13054  if (N <= 0x17)
13055  {
13056  write_number(static_cast<std::uint8_t>(0xA0 + N));
13057  }
13058  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13059  {
13060  oa->write_character(to_char_type(0xB8));
13061  write_number(static_cast<std::uint8_t>(N));
13062  }
13063  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13064  {
13065  oa->write_character(to_char_type(0xB9));
13066  write_number(static_cast<std::uint16_t>(N));
13067  }
13068  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13069  {
13070  oa->write_character(to_char_type(0xBA));
13071  write_number(static_cast<std::uint32_t>(N));
13072  }
13073  // LCOV_EXCL_START
13074  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13075  {
13076  oa->write_character(to_char_type(0xBB));
13077  write_number(static_cast<std::uint64_t>(N));
13078  }
13079  // LCOV_EXCL_STOP
13080 
13081  // step 2: write each element
13082  for (const auto& el : *j.m_value.object)
13083  {
13084  write_cbor(el.first);
13085  write_cbor(el.second);
13086  }
13087  break;
13088  }
13089 
13090  default:
13091  break;
13092  }
13093  }
13094 
13098  void write_msgpack(const BasicJsonType& j)
13099  {
13100  switch (j.type())
13101  {
13102  case value_t::null: // nil
13103  {
13104  oa->write_character(to_char_type(0xC0));
13105  break;
13106  }
13107 
13108  case value_t::boolean: // true and false
13109  {
13110  oa->write_character(j.m_value.boolean
13111  ? to_char_type(0xC3)
13112  : to_char_type(0xC2));
13113  break;
13114  }
13115 
13117  {
13118  if (j.m_value.number_integer >= 0)
13119  {
13120  // MessagePack does not differentiate between positive
13121  // signed integers and unsigned integers. Therefore, we used
13122  // the code from the value_t::number_unsigned case here.
13123  if (j.m_value.number_unsigned < 128)
13124  {
13125  // positive fixnum
13126  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13127  }
13128  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13129  {
13130  // uint 8
13131  oa->write_character(to_char_type(0xCC));
13132  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13133  }
13134  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13135  {
13136  // uint 16
13137  oa->write_character(to_char_type(0xCD));
13138  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13139  }
13140  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13141  {
13142  // uint 32
13143  oa->write_character(to_char_type(0xCE));
13144  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13145  }
13146  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13147  {
13148  // uint 64
13149  oa->write_character(to_char_type(0xCF));
13150  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13151  }
13152  }
13153  else
13154  {
13155  if (j.m_value.number_integer >= -32)
13156  {
13157  // negative fixnum
13158  write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13159  }
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)())
13162  {
13163  // int 8
13164  oa->write_character(to_char_type(0xD0));
13165  write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13166  }
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)())
13169  {
13170  // int 16
13171  oa->write_character(to_char_type(0xD1));
13172  write_number(static_cast<std::int16_t>(j.m_value.number_integer));
13173  }
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)())
13176  {
13177  // int 32
13178  oa->write_character(to_char_type(0xD2));
13179  write_number(static_cast<std::int32_t>(j.m_value.number_integer));
13180  }
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)())
13183  {
13184  // int 64
13185  oa->write_character(to_char_type(0xD3));
13186  write_number(static_cast<std::int64_t>(j.m_value.number_integer));
13187  }
13188  }
13189  break;
13190  }
13191 
13193  {
13194  if (j.m_value.number_unsigned < 128)
13195  {
13196  // positive fixnum
13197  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13198  }
13199  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13200  {
13201  // uint 8
13202  oa->write_character(to_char_type(0xCC));
13203  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13204  }
13205  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13206  {
13207  // uint 16
13208  oa->write_character(to_char_type(0xCD));
13209  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13210  }
13211  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13212  {
13213  // uint 32
13214  oa->write_character(to_char_type(0xCE));
13215  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13216  }
13217  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13218  {
13219  // uint 64
13220  oa->write_character(to_char_type(0xCF));
13221  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13222  }
13223  break;
13224  }
13225 
13226  case value_t::number_float:
13227  {
13228  write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
13229  break;
13230  }
13231 
13232  case value_t::string:
13233  {
13234  // step 1: write control byte and the string length
13235  const auto N = j.m_value.string->size();
13236  if (N <= 31)
13237  {
13238  // fixstr
13239  write_number(static_cast<std::uint8_t>(0xA0 | N));
13240  }
13241  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13242  {
13243  // str 8
13244  oa->write_character(to_char_type(0xD9));
13245  write_number(static_cast<std::uint8_t>(N));
13246  }
13247  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13248  {
13249  // str 16
13250  oa->write_character(to_char_type(0xDA));
13251  write_number(static_cast<std::uint16_t>(N));
13252  }
13253  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13254  {
13255  // str 32
13256  oa->write_character(to_char_type(0xDB));
13257  write_number(static_cast<std::uint32_t>(N));
13258  }
13259 
13260  // step 2: write the string
13261  oa->write_characters(
13262  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13263  j.m_value.string->size());
13264  break;
13265  }
13266 
13267  case value_t::array:
13268  {
13269  // step 1: write control byte and the array size
13270  const auto N = j.m_value.array->size();
13271  if (N <= 15)
13272  {
13273  // fixarray
13274  write_number(static_cast<std::uint8_t>(0x90 | N));
13275  }
13276  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13277  {
13278  // array 16
13279  oa->write_character(to_char_type(0xDC));
13280  write_number(static_cast<std::uint16_t>(N));
13281  }
13282  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13283  {
13284  // array 32
13285  oa->write_character(to_char_type(0xDD));
13286  write_number(static_cast<std::uint32_t>(N));
13287  }
13288 
13289  // step 2: write each element
13290  for (const auto& el : *j.m_value.array)
13291  {
13292  write_msgpack(el);
13293  }
13294  break;
13295  }
13296 
13297  case value_t::binary:
13298  {
13299  // step 0: determine if the binary type has a set subtype to
13300  // determine whether or not to use the ext or fixext types
13301  const bool use_ext = j.m_value.binary->has_subtype();
13302 
13303  // step 1: write control byte and the byte string length
13304  const auto N = j.m_value.binary->size();
13305  if (N <= (std::numeric_limits<std::uint8_t>::max)())
13306  {
13307  std::uint8_t output_type{};
13308  bool fixed = true;
13309  if (use_ext)
13310  {
13311  switch (N)
13312  {
13313  case 1:
13314  output_type = 0xD4; // fixext 1
13315  break;
13316  case 2:
13317  output_type = 0xD5; // fixext 2
13318  break;
13319  case 4:
13320  output_type = 0xD6; // fixext 4
13321  break;
13322  case 8:
13323  output_type = 0xD7; // fixext 8
13324  break;
13325  case 16:
13326  output_type = 0xD8; // fixext 16
13327  break;
13328  default:
13329  output_type = 0xC7; // ext 8
13330  fixed = false;
13331  break;
13332  }
13333 
13334  }
13335  else
13336  {
13337  output_type = 0xC4; // bin 8
13338  fixed = false;
13339  }
13340 
13341  oa->write_character(to_char_type(output_type));
13342  if (!fixed)
13343  {
13344  write_number(static_cast<std::uint8_t>(N));
13345  }
13346  }
13347  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13348  {
13349  std::uint8_t output_type = use_ext
13350  ? 0xC8 // ext 16
13351  : 0xC5; // bin 16
13352 
13353  oa->write_character(to_char_type(output_type));
13354  write_number(static_cast<std::uint16_t>(N));
13355  }
13356  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13357  {
13358  std::uint8_t output_type = use_ext
13359  ? 0xC9 // ext 32
13360  : 0xC6; // bin 32
13361 
13362  oa->write_character(to_char_type(output_type));
13363  write_number(static_cast<std::uint32_t>(N));
13364  }
13365 
13366  // step 1.5: if this is an ext type, write the subtype
13367  if (use_ext)
13368  {
13369  write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
13370  }
13371 
13372  // step 2: write the byte string
13373  oa->write_characters(
13374  reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13375  N);
13376 
13377  break;
13378  }
13379 
13380  case value_t::object:
13381  {
13382  // step 1: write control byte and the object size
13383  const auto N = j.m_value.object->size();
13384  if (N <= 15)
13385  {
13386  // fixmap
13387  write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
13388  }
13389  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13390  {
13391  // map 16
13392  oa->write_character(to_char_type(0xDE));
13393  write_number(static_cast<std::uint16_t>(N));
13394  }
13395  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13396  {
13397  // map 32
13398  oa->write_character(to_char_type(0xDF));
13399  write_number(static_cast<std::uint32_t>(N));
13400  }
13401 
13402  // step 2: write each element
13403  for (const auto& el : *j.m_value.object)
13404  {
13405  write_msgpack(el.first);
13406  write_msgpack(el.second);
13407  }
13408  break;
13409  }
13410 
13411  default:
13412  break;
13413  }
13414  }
13415 
13422  void write_ubjson(const BasicJsonType& j, const bool use_count,
13423  const bool use_type, const bool add_prefix = true)
13424  {
13425  switch (j.type())
13426  {
13427  case value_t::null:
13428  {
13429  if (add_prefix)
13430  {
13431  oa->write_character(to_char_type('Z'));
13432  }
13433  break;
13434  }
13435 
13436  case value_t::boolean:
13437  {
13438  if (add_prefix)
13439  {
13440  oa->write_character(j.m_value.boolean
13441  ? to_char_type('T')
13442  : to_char_type('F'));
13443  }
13444  break;
13445  }
13446 
13448  {
13449  write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
13450  break;
13451  }
13452 
13454  {
13455  write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
13456  break;
13457  }
13458 
13459  case value_t::number_float:
13460  {
13461  write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
13462  break;
13463  }
13464 
13465  case value_t::string:
13466  {
13467  if (add_prefix)
13468  {
13469  oa->write_character(to_char_type('S'));
13470  }
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());
13475  break;
13476  }
13477 
13478  case value_t::array:
13479  {
13480  if (add_prefix)
13481  {
13482  oa->write_character(to_char_type('['));
13483  }
13484 
13485  bool prefix_required = true;
13486  if (use_type && !j.m_value.array->empty())
13487  {
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)
13492  {
13493  return ubjson_prefix(v) == first_prefix;
13494  });
13495 
13496  if (same_prefix)
13497  {
13498  prefix_required = false;
13499  oa->write_character(to_char_type('$'));
13500  oa->write_character(first_prefix);
13501  }
13502  }
13503 
13504  if (use_count)
13505  {
13506  oa->write_character(to_char_type('#'));
13507  write_number_with_ubjson_prefix(j.m_value.array->size(), true);
13508  }
13509 
13510  for (const auto& el : *j.m_value.array)
13511  {
13512  write_ubjson(el, use_count, use_type, prefix_required);
13513  }
13514 
13515  if (!use_count)
13516  {
13517  oa->write_character(to_char_type(']'));
13518  }
13519 
13520  break;
13521  }
13522 
13523  case value_t::binary:
13524  {
13525  if (add_prefix)
13526  {
13527  oa->write_character(to_char_type('['));
13528  }
13529 
13530  if (use_type && !j.m_value.binary->empty())
13531  {
13532  JSON_ASSERT(use_count);
13533  oa->write_character(to_char_type('$'));
13534  oa->write_character('U');
13535  }
13536 
13537  if (use_count)
13538  {
13539  oa->write_character(to_char_type('#'));
13540  write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
13541  }
13542 
13543  if (use_type)
13544  {
13545  oa->write_characters(
13546  reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13547  j.m_value.binary->size());
13548  }
13549  else
13550  {
13551  for (size_t i = 0; i < j.m_value.binary->size(); ++i)
13552  {
13553  oa->write_character(to_char_type('U'));
13554  oa->write_character(j.m_value.binary->data()[i]);
13555  }
13556  }
13557 
13558  if (!use_count)
13559  {
13560  oa->write_character(to_char_type(']'));
13561  }
13562 
13563  break;
13564  }
13565 
13566  case value_t::object:
13567  {
13568  if (add_prefix)
13569  {
13570  oa->write_character(to_char_type('{'));
13571  }
13572 
13573  bool prefix_required = true;
13574  if (use_type && !j.m_value.object->empty())
13575  {
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)
13580  {
13581  return ubjson_prefix(v) == first_prefix;
13582  });
13583 
13584  if (same_prefix)
13585  {
13586  prefix_required = false;
13587  oa->write_character(to_char_type('$'));
13588  oa->write_character(first_prefix);
13589  }
13590  }
13591 
13592  if (use_count)
13593  {
13594  oa->write_character(to_char_type('#'));
13595  write_number_with_ubjson_prefix(j.m_value.object->size(), true);
13596  }
13597 
13598  for (const auto& el : *j.m_value.object)
13599  {
13600  write_number_with_ubjson_prefix(el.first.size(), true);
13601  oa->write_characters(
13602  reinterpret_cast<const CharType*>(el.first.c_str()),
13603  el.first.size());
13604  write_ubjson(el.second, use_count, use_type, prefix_required);
13605  }
13606 
13607  if (!use_count)
13608  {
13609  oa->write_character(to_char_type('}'));
13610  }
13611 
13612  break;
13613  }
13614 
13615  default:
13616  break;
13617  }
13618  }
13619 
13620  private:
13622  // BSON //
13624 
13629  static std::size_t calc_bson_entry_header_size(const string_t& name)
13630  {
13631  const auto it = name.find(static_cast<typename string_t::value_type>(0));
13632  if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
13633  {
13634  JSON_THROW(out_of_range::create(409,
13635  "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
13636  }
13637 
13638  return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
13639  }
13640 
13645  const std::uint8_t element_type)
13646  {
13647  oa->write_character(to_char_type(element_type)); // boolean
13648  oa->write_characters(
13649  reinterpret_cast<const CharType*>(name.c_str()),
13650  name.size() + 1u);
13651  }
13652 
13656  void write_bson_boolean(const string_t& name,
13657  const bool value)
13658  {
13659  write_bson_entry_header(name, 0x08);
13660  oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
13661  }
13662 
13666  void write_bson_double(const string_t& name,
13667  const double value)
13668  {
13669  write_bson_entry_header(name, 0x01);
13670  write_number<double, true>(value);
13671  }
13672 
13676  static std::size_t calc_bson_string_size(const string_t& value)
13677  {
13678  return sizeof(std::int32_t) + value.size() + 1ul;
13679  }
13680 
13684  void write_bson_string(const string_t& name,
13685  const string_t& value)
13686  {
13687  write_bson_entry_header(name, 0x02);
13688 
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()),
13692  value.size() + 1);
13693  }
13694 
13698  void write_bson_null(const string_t& name)
13699  {
13700  write_bson_entry_header(name, 0x0A);
13701  }
13702 
13706  static std::size_t calc_bson_integer_size(const std::int64_t value)
13707  {
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);
13711  }
13712 
13716  void write_bson_integer(const string_t& name,
13717  const std::int64_t value)
13718  {
13719  if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
13720  {
13721  write_bson_entry_header(name, 0x10); // int32
13722  write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
13723  }
13724  else
13725  {
13726  write_bson_entry_header(name, 0x12); // int64
13727  write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
13728  }
13729  }
13730 
13734  static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
13735  {
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);
13739  }
13740 
13744  void write_bson_unsigned(const string_t& name,
13745  const std::uint64_t value)
13746  {
13747  if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
13748  {
13749  write_bson_entry_header(name, 0x10 /* int32 */);
13750  write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
13751  }
13752  else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
13753  {
13754  write_bson_entry_header(name, 0x12 /* int64 */);
13755  write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
13756  }
13757  else
13758  {
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"));
13760  }
13761  }
13762 
13767  const typename BasicJsonType::object_t& value)
13768  {
13769  write_bson_entry_header(name, 0x03); // object
13771  }
13772 
13776  static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
13777  {
13778  std::size_t array_index = 0ul;
13779 
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)
13781  {
13782  return result + calc_bson_element_size(std::to_string(array_index++), el);
13783  });
13784 
13785  return sizeof(std::int32_t) + embedded_document_size + 1ul;
13786  }
13787 
13791  static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
13792  {
13793  return sizeof(std::int32_t) + value.size() + 1ul;
13794  }
13795 
13799  void write_bson_array(const string_t& name,
13800  const typename BasicJsonType::array_t& value)
13801  {
13802  write_bson_entry_header(name, 0x04); // array
13803  write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
13804 
13805  std::size_t array_index = 0ul;
13806 
13807  for (const auto& el : value)
13808  {
13809  write_bson_element(std::to_string(array_index++), el);
13810  }
13811 
13812  oa->write_character(to_char_type(0x00));
13813  }
13814 
13818  void write_bson_binary(const string_t& name,
13819  const binary_t& value)
13820  {
13821  write_bson_entry_header(name, 0x05);
13822 
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));
13825 
13826  oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
13827  }
13828 
13833  static std::size_t calc_bson_element_size(const string_t& name,
13834  const BasicJsonType& j)
13835  {
13836  const auto header_size = calc_bson_entry_header_size(name);
13837  switch (j.type())
13838  {
13839  case value_t::object:
13840  return header_size + calc_bson_object_size(*j.m_value.object);
13841 
13842  case value_t::array:
13843  return header_size + calc_bson_array_size(*j.m_value.array);
13844 
13845  case value_t::binary:
13846  return header_size + calc_bson_binary_size(*j.m_value.binary);
13847 
13848  case value_t::boolean:
13849  return header_size + 1ul;
13850 
13851  case value_t::number_float:
13852  return header_size + 8ul;
13853 
13855  return header_size + calc_bson_integer_size(j.m_value.number_integer);
13856 
13858  return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
13859 
13860  case value_t::string:
13861  return header_size + calc_bson_string_size(*j.m_value.string);
13862 
13863  case value_t::null:
13864  return header_size + 0ul;
13865 
13866  // LCOV_EXCL_START
13867  default:
13868  JSON_ASSERT(false);
13869  return 0ul;
13870  // LCOV_EXCL_STOP
13871  }
13872  }
13873 
13881  void write_bson_element(const string_t& name,
13882  const BasicJsonType& j)
13883  {
13884  switch (j.type())
13885  {
13886  case value_t::object:
13887  return write_bson_object_entry(name, *j.m_value.object);
13888 
13889  case value_t::array:
13890  return write_bson_array(name, *j.m_value.array);
13891 
13892  case value_t::binary:
13893  return write_bson_binary(name, *j.m_value.binary);
13894 
13895  case value_t::boolean:
13896  return write_bson_boolean(name, j.m_value.boolean);
13897 
13898  case value_t::number_float:
13899  return write_bson_double(name, j.m_value.number_float);
13900 
13902  return write_bson_integer(name, j.m_value.number_integer);
13903 
13905  return write_bson_unsigned(name, j.m_value.number_unsigned);
13906 
13907  case value_t::string:
13908  return write_bson_string(name, *j.m_value.string);
13909 
13910  case value_t::null:
13911  return write_bson_null(name);
13912 
13913  // LCOV_EXCL_START
13914  default:
13915  JSON_ASSERT(false);
13916  return;
13917  // LCOV_EXCL_STOP
13918  }
13919  }
13920 
13927  static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
13928  {
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)
13931  {
13932  return result += calc_bson_element_size(el.first, el.second);
13933  });
13934 
13935  return sizeof(std::int32_t) + document_size + 1ul;
13936  }
13937 
13942  void write_bson_object(const typename BasicJsonType::object_t& value)
13943  {
13944  write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
13945 
13946  for (const auto& el : value)
13947  {
13948  write_bson_element(el.first, el.second);
13949  }
13950 
13951  oa->write_character(to_char_type(0x00));
13952  }
13953 
13955  // CBOR //
13957 
13958  static constexpr CharType get_cbor_float_prefix(float /*unused*/)
13959  {
13960  return to_char_type(0xFA); // Single-Precision Float
13961  }
13962 
13963  static constexpr CharType get_cbor_float_prefix(double /*unused*/)
13964  {
13965  return to_char_type(0xFB); // Double-Precision Float
13966  }
13967 
13969  // MsgPack //
13971 
13972  static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
13973  {
13974  return to_char_type(0xCA); // float 32
13975  }
13976 
13977  static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
13978  {
13979  return to_char_type(0xCB); // float 64
13980  }
13981 
13983  // UBJSON //
13985 
13986  // UBJSON: write number (floating point)
13987  template<typename NumberType, typename std::enable_if<
13989  void write_number_with_ubjson_prefix(const NumberType n,
13990  const bool add_prefix)
13991  {
13992  if (add_prefix)
13993  {
13994  oa->write_character(get_ubjson_float_prefix(n));
13995  }
13996  write_number(n);
13997  }
13998 
13999  // UBJSON: write number (unsigned integer)
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)
14004  {
14005  if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14006  {
14007  if (add_prefix)
14008  {
14009  oa->write_character(to_char_type('i')); // int8
14010  }
14011  write_number(static_cast<std::uint8_t>(n));
14012  }
14013  else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14014  {
14015  if (add_prefix)
14016  {
14017  oa->write_character(to_char_type('U')); // uint8
14018  }
14019  write_number(static_cast<std::uint8_t>(n));
14020  }
14021  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14022  {
14023  if (add_prefix)
14024  {
14025  oa->write_character(to_char_type('I')); // int16
14026  }
14027  write_number(static_cast<std::int16_t>(n));
14028  }
14029  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14030  {
14031  if (add_prefix)
14032  {
14033  oa->write_character(to_char_type('l')); // int32
14034  }
14035  write_number(static_cast<std::int32_t>(n));
14036  }
14037  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14038  {
14039  if (add_prefix)
14040  {
14041  oa->write_character(to_char_type('L')); // int64
14042  }
14043  write_number(static_cast<std::int64_t>(n));
14044  }
14045  else
14046  {
14047  if (add_prefix)
14048  {
14049  oa->write_character(to_char_type('H')); // high-precision number
14050  }
14051 
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)
14055  {
14056  oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14057  }
14058  }
14059  }
14060 
14061  // UBJSON: write number (signed integer)
14062  template < typename NumberType, typename std::enable_if <
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)
14067  {
14068  if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14069  {
14070  if (add_prefix)
14071  {
14072  oa->write_character(to_char_type('i')); // int8
14073  }
14074  write_number(static_cast<std::int8_t>(n));
14075  }
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)()))
14077  {
14078  if (add_prefix)
14079  {
14080  oa->write_character(to_char_type('U')); // uint8
14081  }
14082  write_number(static_cast<std::uint8_t>(n));
14083  }
14084  else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14085  {
14086  if (add_prefix)
14087  {
14088  oa->write_character(to_char_type('I')); // int16
14089  }
14090  write_number(static_cast<std::int16_t>(n));
14091  }
14092  else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14093  {
14094  if (add_prefix)
14095  {
14096  oa->write_character(to_char_type('l')); // int32
14097  }
14098  write_number(static_cast<std::int32_t>(n));
14099  }
14100  else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14101  {
14102  if (add_prefix)
14103  {
14104  oa->write_character(to_char_type('L')); // int64
14105  }
14106  write_number(static_cast<std::int64_t>(n));
14107  }
14108  // LCOV_EXCL_START
14109  else
14110  {
14111  if (add_prefix)
14112  {
14113  oa->write_character(to_char_type('H')); // high-precision number
14114  }
14115 
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)
14119  {
14120  oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14121  }
14122  }
14123  // LCOV_EXCL_STOP
14124  }
14125 
14129  CharType ubjson_prefix(const BasicJsonType& j) const noexcept
14130  {
14131  switch (j.type())
14132  {
14133  case value_t::null:
14134  return 'Z';
14135 
14136  case value_t::boolean:
14137  return j.m_value.boolean ? 'T' : 'F';
14138 
14140  {
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)())
14142  {
14143  return 'i';
14144  }
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)())
14146  {
14147  return 'U';
14148  }
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)())
14150  {
14151  return 'I';
14152  }
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)())
14154  {
14155  return 'l';
14156  }
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)())
14158  {
14159  return 'L';
14160  }
14161  // anything else is treated as high-precision number
14162  return 'H'; // LCOV_EXCL_LINE
14163  }
14164 
14166  {
14167  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14168  {
14169  return 'i';
14170  }
14171  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
14172  {
14173  return 'U';
14174  }
14175  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14176  {
14177  return 'I';
14178  }
14179  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14180  {
14181  return 'l';
14182  }
14183  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14184  {
14185  return 'L';
14186  }
14187  // anything else is treated as high-precision number
14188  return 'H'; // LCOV_EXCL_LINE
14189  }
14190 
14191  case value_t::number_float:
14192  return get_ubjson_float_prefix(j.m_value.number_float);
14193 
14194  case value_t::string:
14195  return 'S';
14196 
14197  case value_t::array: // fallthrough
14198  case value_t::binary:
14199  return '[';
14200 
14201  case value_t::object:
14202  return '{';
14203 
14204  default: // discarded values
14205  return 'N';
14206  }
14207  }
14208 
14209  static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
14210  {
14211  return 'd'; // float 32
14212  }
14213 
14214  static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
14215  {
14216  return 'D'; // float 64
14217  }
14218 
14220  // Utility functions //
14222 
14223  /*
14224  @brief write a number to output input
14225  @param[in] n number of type @a NumberType
14226  @tparam NumberType the type of the number
14227  @tparam OutputIsLittleEndian Set to true if output data is
14228  required to be little endian
14229 
14230  @note This function needs to respect the system's endianess, because bytes
14231  in CBOR, MessagePack, and UBJSON are stored in network order (big
14232  endian) and therefore need reordering on little endian systems.
14233  */
14234  template<typename NumberType, bool OutputIsLittleEndian = false>
14235  void write_number(const NumberType n)
14236  {
14237  // step 1: write number to array of length NumberType
14238  std::array<CharType, sizeof(NumberType)> vec;
14239  std::memcpy(vec.data(), &n, sizeof(NumberType));
14240 
14241  // step 2: write array to output (with possible reordering)
14242  if (is_little_endian != OutputIsLittleEndian)
14243  {
14244  // reverse byte order prior to conversion if necessary
14245  std::reverse(vec.begin(), vec.end());
14246  }
14247 
14248  oa->write_characters(vec.data(), sizeof(NumberType));
14249  }
14250 
14252  {
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))
14256  {
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));
14261  }
14262  else
14263  {
14264  oa->write_character(format == detail::input_format_t::cbor
14267  write_number(n);
14268  }
14269  }
14270 
14271  public:
14272  // The following to_char_type functions are implement the conversion
14273  // between uint8_t and CharType. In case CharType is not unsigned,
14274  // such a conversion is required to allow values greater than 128.
14275  // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
14276  template < typename C = CharType,
14278  static constexpr CharType to_char_type(std::uint8_t x) noexcept
14279  {
14280  return *reinterpret_cast<char*>(&x);
14281  }
14282 
14283  template < typename C = CharType,
14285  static CharType to_char_type(std::uint8_t x) noexcept
14286  {
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");
14289  CharType result;
14290  std::memcpy(&result, &x, sizeof(x));
14291  return result;
14292  }
14293 
14294  template<typename C = CharType,
14296  static constexpr CharType to_char_type(std::uint8_t x) noexcept
14297  {
14298  return x;
14299  }
14300 
14301  template < typename InputCharType, typename C = CharType,
14302  enable_if_t <
14305  std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
14306  > * = nullptr >
14307  static constexpr CharType to_char_type(InputCharType x) noexcept
14308  {
14309  return x;
14310  }
14311 
14312  private:
14315 
14318 };
14319 } // namespace detail
14320 } // namespace nlohmann
14321 
14322 // #include <nlohmann/detail/output/output_adapters.hpp>
14323 
14324 // #include <nlohmann/detail/output/serializer.hpp>
14325 
14326 
14327 #include <algorithm> // reverse, remove, fill, find, none_of
14328 #include <array> // array
14329 #include <clocale> // localeconv, lconv
14330 #include <cmath> // labs, isfinite, isnan, signbit
14331 #include <cstddef> // size_t, ptrdiff_t
14332 #include <cstdint> // uint8_t
14333 #include <cstdio> // snprintf
14334 #include <limits> // numeric_limits
14335 #include <string> // string, char_traits
14336 #include <type_traits> // is_same
14337 #include <utility> // move
14338 
14339 // #include <nlohmann/detail/conversions/to_chars.hpp>
14340 
14341 
14342 #include <array> // array
14343 #include <cmath> // signbit, isfinite
14344 #include <cstdint> // intN_t, uintN_t
14345 #include <cstring> // memcpy, memmove
14346 #include <limits> // numeric_limits
14347 #include <type_traits> // conditional
14348 
14349 // #include <nlohmann/detail/macro_scope.hpp>
14350 
14351 
14352 namespace nlohmann
14353 {
14354 namespace detail
14355 {
14356 
14376 namespace dtoa_impl
14377 {
14378 
14379 template<typename Target, typename Source>
14380 Target reinterpret_bits(const Source source)
14381 {
14382  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
14383 
14384  Target target;
14385  std::memcpy(&target, &source, sizeof(Source));
14386  return target;
14387 }
14388 
14389 struct diyfp // f * 2^e
14390 {
14391  static constexpr int kPrecision = 64; // = q
14392 
14393  std::uint64_t f = 0;
14394  int e = 0;
14395 
14396  constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
14397 
14402  static diyfp sub(const diyfp& x, const diyfp& y) noexcept
14403  {
14404  JSON_ASSERT(x.e == y.e);
14405  JSON_ASSERT(x.f >= y.f);
14406 
14407  return {x.f - y.f, x.e};
14408  }
14409 
14414  static diyfp mul(const diyfp& x, const diyfp& y) noexcept
14415  {
14416  static_assert(kPrecision == 64, "internal error");
14417 
14418  // Computes:
14419  // f = round((x.f * y.f) / 2^q)
14420  // e = x.e + y.e + q
14421 
14422  // Emulate the 64-bit * 64-bit multiplication:
14423  //
14424  // p = u * v
14425  // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
14426  // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
14427  // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
14428  // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
14429  // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
14430  // = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
14431  // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
14432  //
14433  // (Since Q might be larger than 2^32 - 1)
14434  //
14435  // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
14436  //
14437  // (Q_hi + H does not overflow a 64-bit int)
14438  //
14439  // = p_lo + 2^64 p_hi
14440 
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;
14445 
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;
14450 
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;
14456 
14457  std::uint64_t Q = p0_hi + p1_lo + p2_lo;
14458 
14459  // The full product might now be computed as
14460  //
14461  // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
14462  // p_lo = p0_lo + (Q << 32)
14463  //
14464  // But in this particular case here, the full p_lo is not required.
14465  // Effectively we only need to add the highest bit in p_lo to p_hi (and
14466  // Q_hi + 1 does not overflow).
14467 
14468  Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
14469 
14470  const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
14471 
14472  return {h, x.e + y.e + 64};
14473  }
14474 
14479  static diyfp normalize(diyfp x) noexcept
14480  {
14481  JSON_ASSERT(x.f != 0);
14482 
14483  while ((x.f >> 63u) == 0)
14484  {
14485  x.f <<= 1u;
14486  x.e--;
14487  }
14488 
14489  return x;
14490  }
14491 
14496  static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
14497  {
14498  const int delta = x.e - target_exponent;
14499 
14500  JSON_ASSERT(delta >= 0);
14501  JSON_ASSERT(((x.f << delta) >> delta) == x.f);
14502 
14503  return {x.f << delta, target_exponent};
14504  }
14505 };
14506 
14508 {
14512 };
14513 
14520 template<typename FloatType>
14522 {
14523  JSON_ASSERT(std::isfinite(value));
14524  JSON_ASSERT(value > 0);
14525 
14526  // Convert the IEEE representation into a diyfp.
14527  //
14528  // If v is denormal:
14529  // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
14530  // If v is normalized:
14531  // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
14532 
14533  static_assert(std::numeric_limits<FloatType>::is_iec559,
14534  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
14535 
14536  constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
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); // = 2^(p-1)
14540 
14541  using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
14542 
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);
14546 
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);
14551 
14552  // Compute the boundaries m- and m+ of the floating-point value
14553  // v = f * 2^e.
14554  //
14555  // Determine v- and v+, the floating-point predecessor and successor if v,
14556  // respectively.
14557  //
14558  // v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
14559  // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
14560  //
14561  // v+ = v + 2^e
14562  //
14563  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
14564  // between m- and m+ round to v, regardless of how the input rounding
14565  // algorithm breaks ties.
14566  //
14567  // ---+-------------+-------------+-------------+-------------+--- (A)
14568  // v- m- v m+ v+
14569  //
14570  // -----------------+------+------+-------------+-------------+--- (B)
14571  // v- m- v m+ v+
14572 
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) // (B)
14577  : diyfp(2 * v.f - 1, v.e - 1); // (A)
14578 
14579  // Determine the normalized w+ = m+.
14581 
14582  // Determine w- = m- such that e_(w-) = e_(w+).
14584 
14585  return {diyfp::normalize(v), w_minus, w_plus};
14586 }
14587 
14588 // Given normalized diyfp w, Grisu needs to find a (normalized) cached
14589 // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
14590 // within a certain range [alpha, gamma] (Definition 3.2 from [1])
14591 //
14592 // alpha <= e = e_c + e_w + q <= gamma
14593 //
14594 // or
14595 //
14596 // f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
14597 // <= f_c * f_w * 2^gamma
14598 //
14599 // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
14600 //
14601 // 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
14602 //
14603 // or
14604 //
14605 // 2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
14606 //
14607 // The choice of (alpha,gamma) determines the size of the table and the form of
14608 // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
14609 // in practice:
14610 //
14611 // The idea is to cut the number c * w = f * 2^e into two parts, which can be
14612 // processed independently: An integral part p1, and a fractional part p2:
14613 //
14614 // f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
14615 // = (f div 2^-e) + (f mod 2^-e) * 2^e
14616 // = p1 + p2 * 2^e
14617 //
14618 // The conversion of p1 into decimal form requires a series of divisions and
14619 // modulos by (a power of) 10. These operations are faster for 32-bit than for
14620 // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
14621 // achieved by choosing
14622 //
14623 // -e >= 32 or e <= -32 := gamma
14624 //
14625 // In order to convert the fractional part
14626 //
14627 // p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
14628 //
14629 // into decimal form, the fraction is repeatedly multiplied by 10 and the digits
14630 // d[-i] are extracted in order:
14631 //
14632 // (10 * p2) div 2^-e = d[-1]
14633 // (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
14634 //
14635 // The multiplication by 10 must not overflow. It is sufficient to choose
14636 //
14637 // 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
14638 //
14639 // Since p2 = f mod 2^-e < 2^-e,
14640 //
14641 // -e <= 60 or e >= -60 := alpha
14642 
14643 constexpr int kAlpha = -60;
14644 constexpr int kGamma = -32;
14645 
14646 struct cached_power // c = f * 2^e ~= 10^k
14647 {
14648  std::uint64_t f;
14649  int e;
14650  int k;
14651 };
14652 
14661 {
14662  // Now
14663  //
14664  // alpha <= e_c + e + q <= gamma (1)
14665  // ==> f_c * 2^alpha <= c * 2^e * 2^q
14666  //
14667  // and since the c's are normalized, 2^(q-1) <= f_c,
14668  //
14669  // ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
14670  // ==> 2^(alpha - e - 1) <= c
14671  //
14672  // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
14673  //
14674  // k = ceil( log_10( 2^(alpha - e - 1) ) )
14675  // = ceil( (alpha - e - 1) * log_10(2) )
14676  //
14677  // From the paper:
14678  // "In theory the result of the procedure could be wrong since c is rounded,
14679  // and the computation itself is approximated [...]. In practice, however,
14680  // this simple function is sufficient."
14681  //
14682  // For IEEE double precision floating-point numbers converted into
14683  // normalized diyfp's w = f * 2^e, with q = 64,
14684  //
14685  // e >= -1022 (min IEEE exponent)
14686  // -52 (p - 1)
14687  // -52 (p - 1, possibly normalize denormal IEEE numbers)
14688  // -11 (normalize the diyfp)
14689  // = -1137
14690  //
14691  // and
14692  //
14693  // e <= +1023 (max IEEE exponent)
14694  // -52 (p - 1)
14695  // -11 (normalize the diyfp)
14696  // = 960
14697  //
14698  // This binary exponent range [-1137,960] results in a decimal exponent
14699  // range [-307,324]. One does not need to store a cached power for each
14700  // k in this range. For each such k it suffices to find a cached power
14701  // such that the exponent of the product lies in [alpha,gamma].
14702  // This implies that the difference of the decimal exponents of adjacent
14703  // table entries must be less than or equal to
14704  //
14705  // floor( (gamma - alpha) * log_10(2) ) = 8.
14706  //
14707  // (A smaller distance gamma-alpha would require a larger table.)
14708 
14709  // NB:
14710  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
14711 
14712  constexpr int kCachedPowersMinDecExp = -300;
14713  constexpr int kCachedPowersDecStep = 8;
14714 
14715  static constexpr std::array<cached_power, 79> kCachedPowers =
14716  {
14717  {
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 },
14797  }
14798  };
14799 
14800  // This computation gives exactly the same results for k as
14801  // k = ceil((kAlpha - e - 1) * 0.30102999566398114)
14802  // for |e| <= 1500, but doesn't require floating-point operations.
14803  // NB: log_10(2) ~= 78913 / 2^18
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);
14808 
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());
14812 
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);
14816 
14817  return cached;
14818 }
14819 
14824 inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
14825 {
14826  // LCOV_EXCL_START
14827  if (n >= 1000000000)
14828  {
14829  pow10 = 1000000000;
14830  return 10;
14831  }
14832  // LCOV_EXCL_STOP
14833  else if (n >= 100000000)
14834  {
14835  pow10 = 100000000;
14836  return 9;
14837  }
14838  else if (n >= 10000000)
14839  {
14840  pow10 = 10000000;
14841  return 8;
14842  }
14843  else if (n >= 1000000)
14844  {
14845  pow10 = 1000000;
14846  return 7;
14847  }
14848  else if (n >= 100000)
14849  {
14850  pow10 = 100000;
14851  return 6;
14852  }
14853  else if (n >= 10000)
14854  {
14855  pow10 = 10000;
14856  return 5;
14857  }
14858  else if (n >= 1000)
14859  {
14860  pow10 = 1000;
14861  return 4;
14862  }
14863  else if (n >= 100)
14864  {
14865  pow10 = 100;
14866  return 3;
14867  }
14868  else if (n >= 10)
14869  {
14870  pow10 = 10;
14871  return 2;
14872  }
14873  else
14874  {
14875  pow10 = 1;
14876  return 1;
14877  }
14878 }
14879 
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)
14882 {
14883  JSON_ASSERT(len >= 1);
14884  JSON_ASSERT(dist <= delta);
14885  JSON_ASSERT(rest <= delta);
14886  JSON_ASSERT(ten_k > 0);
14887 
14888  // <--------------------------- delta ---->
14889  // <---- dist --------->
14890  // --------------[------------------+-------------------]--------------
14891  // M- w M+
14892  //
14893  // ten_k
14894  // <------>
14895  // <---- rest ---->
14896  // --------------[------------------+----+--------------]--------------
14897  // w V
14898  // = buf * 10^k
14899  //
14900  // ten_k represents a unit-in-the-last-place in the decimal representation
14901  // stored in buf.
14902  // Decrement buf by ten_k while this takes buf closer to w.
14903 
14904  // The tests are written in this order to avoid overflow in unsigned
14905  // integer arithmetic.
14906 
14907  while (rest < dist
14908  && delta - rest >= ten_k
14909  && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
14910  {
14911  JSON_ASSERT(buf[len - 1] != '0');
14912  buf[len - 1]--;
14913  rest += ten_k;
14914  }
14915 }
14916 
14921 inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
14923 {
14924  static_assert(kAlpha >= -60, "internal error");
14925  static_assert(kGamma <= -32, "internal error");
14926 
14927  // Generates the digits (and the exponent) of a decimal floating-point
14928  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
14929  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
14930  //
14931  // <--------------------------- delta ---->
14932  // <---- dist --------->
14933  // --------------[------------------+-------------------]--------------
14934  // M- w M+
14935  //
14936  // Grisu2 generates the digits of M+ from left to right and stops as soon as
14937  // V is in [M-,M+].
14938 
14939  JSON_ASSERT(M_plus.e >= kAlpha);
14940  JSON_ASSERT(M_plus.e <= kGamma);
14941 
14942  std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
14943  std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
14944 
14945  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
14946  //
14947  // M+ = f * 2^e
14948  // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
14949  // = ((p1 ) * 2^-e + (p2 )) * 2^e
14950  // = p1 + p2 * 2^e
14951 
14952  const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
14953 
14954  auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
14955  std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
14956 
14957  // 1)
14958  //
14959  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
14960 
14961  JSON_ASSERT(p1 > 0);
14962 
14963  std::uint32_t pow10;
14964  const int k = find_largest_pow10(p1, pow10);
14965 
14966  // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
14967  //
14968  // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
14969  // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
14970  //
14971  // M+ = p1 + p2 * 2^e
14972  // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
14973  // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
14974  // = d[k-1] * 10^(k-1) + ( rest) * 2^e
14975  //
14976  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
14977  //
14978  // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
14979  //
14980  // but stop as soon as
14981  //
14982  // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
14983 
14984  int n = k;
14985  while (n > 0)
14986  {
14987  // Invariants:
14988  // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
14989  // pow10 = 10^(n-1) <= p1 < 10^n
14990  //
14991  const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
14992  const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
14993  //
14994  // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
14995  // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
14996  //
14997  JSON_ASSERT(d <= 9);
14998  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
14999  //
15000  // M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
15001  //
15002  p1 = r;
15003  n--;
15004  //
15005  // M+ = buffer * 10^n + (p1 + p2 * 2^e)
15006  // pow10 = 10^n
15007  //
15008 
15009  // Now check if enough digits have been generated.
15010  // Compute
15011  //
15012  // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
15013  //
15014  // Note:
15015  // Since rest and delta share the same exponent e, it suffices to
15016  // compare the significands.
15017  const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15018  if (rest <= delta)
15019  {
15020  // V = buffer * 10^n, with M- <= V <= M+.
15021 
15022  decimal_exponent += n;
15023 
15024  // We may now just stop. But instead look if the buffer could be
15025  // decremented to bring V closer to w.
15026  //
15027  // pow10 = 10^n is now 1 ulp in the decimal representation V.
15028  // The rounding procedure works with diyfp's with an implicit
15029  // exponent of e.
15030  //
15031  // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
15032  //
15033  const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15034  grisu2_round(buffer, length, dist, delta, rest, ten_n);
15035 
15036  return;
15037  }
15038 
15039  pow10 /= 10;
15040  //
15041  // pow10 = 10^(n-1) <= p1 < 10^n
15042  // Invariants restored.
15043  }
15044 
15045  // 2)
15046  //
15047  // The digits of the integral part have been generated:
15048  //
15049  // M+ = d[k-1]...d[1]d[0] + p2 * 2^e
15050  // = buffer + p2 * 2^e
15051  //
15052  // Now generate the digits of the fractional part p2 * 2^e.
15053  //
15054  // Note:
15055  // No decimal point is generated: the exponent is adjusted instead.
15056  //
15057  // p2 actually represents the fraction
15058  //
15059  // p2 * 2^e
15060  // = p2 / 2^-e
15061  // = d[-1] / 10^1 + d[-2] / 10^2 + ...
15062  //
15063  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
15064  //
15065  // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
15066  // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
15067  //
15068  // using
15069  //
15070  // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
15071  // = ( d) * 2^-e + ( r)
15072  //
15073  // or
15074  // 10^m * p2 * 2^e = d + r * 2^e
15075  //
15076  // i.e.
15077  //
15078  // M+ = buffer + p2 * 2^e
15079  // = buffer + 10^-m * (d + r * 2^e)
15080  // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
15081  //
15082  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
15083 
15084  JSON_ASSERT(p2 > delta);
15085 
15086  int m = 0;
15087  for (;;)
15088  {
15089  // Invariant:
15090  // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
15091  // = buffer * 10^-m + 10^-m * (p2 ) * 2^e
15092  // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
15093  // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
15094  //
15095  JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15096  p2 *= 10;
15097  const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
15098  const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
15099  //
15100  // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
15101  // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
15102  // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
15103  //
15104  JSON_ASSERT(d <= 9);
15105  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
15106  //
15107  // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
15108  //
15109  p2 = r;
15110  m++;
15111  //
15112  // M+ = buffer * 10^-m + 10^-m * p2 * 2^e
15113  // Invariant restored.
15114 
15115  // Check if enough digits have been generated.
15116  //
15117  // 10^-m * p2 * 2^e <= delta * 2^e
15118  // p2 * 2^e <= 10^m * delta * 2^e
15119  // p2 <= 10^m * delta
15120  delta *= 10;
15121  dist *= 10;
15122  if (p2 <= delta)
15123  {
15124  break;
15125  }
15126  }
15127 
15128  // V = buffer * 10^-m, with M- <= V <= M+.
15129 
15130  decimal_exponent -= m;
15131 
15132  // 1 ulp in the decimal representation is now 10^-m.
15133  // Since delta and dist are now scaled by 10^m, we need to do the
15134  // same with ulp in order to keep the units in sync.
15135  //
15136  // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
15137  //
15138  const std::uint64_t ten_m = one.f;
15139  grisu2_round(buffer, length, dist, delta, p2, ten_m);
15140 
15141  // By construction this algorithm generates the shortest possible decimal
15142  // number (Loitsch, Theorem 6.2) which rounds back to w.
15143  // For an input number of precision p, at least
15144  //
15145  // N = 1 + ceil(p * log_10(2))
15146  //
15147  // decimal digits are sufficient to identify all binary floating-point
15148  // numbers (Matula, "In-and-Out conversions").
15149  // This implies that the algorithm does not produce more than N decimal
15150  // digits.
15151  //
15152  // N = 17 for p = 53 (IEEE double precision)
15153  // N = 9 for p = 24 (IEEE single precision)
15154 }
15155 
15162 inline void grisu2(char* buf, int& len, int& decimal_exponent,
15164 {
15167 
15168  // --------(-----------------------+-----------------------)-------- (A)
15169  // m- v m+
15170  //
15171  // --------------------(-----------+-----------------------)-------- (B)
15172  // m- v m+
15173  //
15174  // First scale v (and m- and m+) such that the exponent is in the range
15175  // [alpha, gamma].
15176 
15178 
15179  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
15180 
15181  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
15185 
15186  // ----(---+---)---------------(---+---)---------------(---+---)----
15187  // w- w w+
15188  // = c*m- = c*v = c*m+
15189  //
15190  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
15191  // w+ are now off by a small amount.
15192  // In fact:
15193  //
15194  // w - v * 10^k < 1 ulp
15195  //
15196  // To account for this inaccuracy, add resp. subtract 1 ulp.
15197  //
15198  // --------+---[---------------(---+---)---------------]---+--------
15199  // w- M- w M+ w+
15200  //
15201  // Now any number in [M-, M+] (bounds included) will round to w when input,
15202  // regardless of how the input rounding algorithm breaks ties.
15203  //
15204  // And digit_gen generates the shortest possible such number in [M-, M+].
15205  // Note that this does not mean that Grisu2 always generates the shortest
15206  // possible number in the interval (m-, m+).
15208  const diyfp M_plus (w_plus.f - 1, w_plus.e );
15209 
15210  decimal_exponent = -cached.k; // = -(-k) = k
15211 
15213 }
15214 
15220 template<typename FloatType>
15222 void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
15223 {
15224  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
15225  "internal error: not enough precision");
15226 
15227  JSON_ASSERT(std::isfinite(value));
15229 
15230  // If the neighbors (and boundaries) of 'value' are always computed for double-precision
15231  // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
15232  // decimal representations are not exactly "short".
15233  //
15234  // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
15235  // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
15236  // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
15237  // does.
15238  // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
15239  // representation using the corresponding std::from_chars function recovers value exactly". That
15240  // indicates that single precision floating-point numbers should be recovered using
15241  // 'std::strtof'.
15242  //
15243  // NB: If the neighbors are computed for single-precision numbers, there is a single float
15244  // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
15245  // value is off by 1 ulp.
15246 #if 0
15247  const boundaries w = compute_boundaries(static_cast<double>(value));
15248 #else
15250 #endif
15251 
15252  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
15253 }
15254 
15261 JSON_HEDLEY_RETURNS_NON_NULL
15262 inline char* append_exponent(char* buf, int e)
15263 {
15264  JSON_ASSERT(e > -1000);
15265  JSON_ASSERT(e < 1000);
15266 
15267  if (e < 0)
15268  {
15269  e = -e;
15270  *buf++ = '-';
15271  }
15272  else
15273  {
15274  *buf++ = '+';
15275  }
15276 
15277  auto k = static_cast<std::uint32_t>(e);
15278  if (k < 10)
15279  {
15280  // Always print at least two digits in the exponent.
15281  // This is for compatibility with printf("%g").
15282  *buf++ = '0';
15283  *buf++ = static_cast<char>('0' + k);
15284  }
15285  else if (k < 100)
15286  {
15287  *buf++ = static_cast<char>('0' + k / 10);
15288  k %= 10;
15289  *buf++ = static_cast<char>('0' + k);
15290  }
15291  else
15292  {
15293  *buf++ = static_cast<char>('0' + k / 100);
15294  k %= 100;
15295  *buf++ = static_cast<char>('0' + k / 10);
15296  k %= 10;
15297  *buf++ = static_cast<char>('0' + k);
15298  }
15299 
15300  return buf;
15301 }
15302 
15313 JSON_HEDLEY_RETURNS_NON_NULL
15314 inline char* format_buffer(char* buf, int len, int decimal_exponent,
15315  int min_exp, int max_exp)
15316 {
15317  JSON_ASSERT(min_exp < 0);
15319 
15320  const int k = len;
15321  const int n = len + decimal_exponent;
15322 
15323  // v = buf * 10^(n-k)
15324  // k is the length of the buffer (number of decimal digits)
15325  // n is the position of the decimal point relative to the start of the buffer.
15326 
15327  if (k <= n && n <= max_exp)
15328  {
15329  // digits[000]
15330  // len <= max_exp + 2
15331 
15332  std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
15333  // Make it look like a floating-point number (#362, #378)
15334  buf[n + 0] = '.';
15335  buf[n + 1] = '0';
15336  return buf + (static_cast<size_t>(n) + 2);
15337  }
15338 
15339  if (0 < n && n <= max_exp)
15340  {
15341  // dig.its
15342  // len <= max_digits10 + 1
15343 
15344  JSON_ASSERT(k > n);
15345 
15346  std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
15347  buf[n] = '.';
15348  return buf + (static_cast<size_t>(k) + 1U);
15349  }
15350 
15351  if (min_exp < n && n <= 0)
15352  {
15353  // 0.[000]digits
15354  // len <= 2 + (-min_exp - 1) + max_digits10
15355 
15356  std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
15357  buf[0] = '0';
15358  buf[1] = '.';
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));
15361  }
15362 
15363  if (k == 1)
15364  {
15365  // dE+123
15366  // len <= 1 + 5
15367 
15368  buf += 1;
15369  }
15370  else
15371  {
15372  // d.igitsE+123
15373  // len <= max_digits10 + 1 + 5
15374 
15375  std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
15376  buf[1] = '.';
15377  buf += 1 + static_cast<size_t>(k);
15378  }
15379 
15380  *buf++ = 'e';
15381  return append_exponent(buf, n - 1);
15382 }
15383 
15384 } // namespace dtoa_impl
15385 
15396 template<typename FloatType>
15398 JSON_HEDLEY_RETURNS_NON_NULL
15399 char* to_chars(char* first, const char* last, FloatType value)
15400 {
15401  static_cast<void>(last); // maybe unused - fix warning
15402  JSON_ASSERT(std::isfinite(value));
15403 
15404  // Use signbit(value) instead of (value < 0) since signbit works for -0.
15405  if (std::signbit(value))
15406  {
15407  value = -value;
15408  *first++ = '-';
15409  }
15410 
15411  if (value == 0) // +-0
15412  {
15413  *first++ = '0';
15414  // Make it look like a floating-point number (#362, #378)
15415  *first++ = '.';
15416  *first++ = '0';
15417  return first;
15418  }
15419 
15420  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
15421 
15422  // Compute v = buffer * 10^decimal_exponent.
15423  // The decimal digits are stored in the buffer, which needs to be interpreted
15424  // as an unsigned decimal integer.
15425  // len is the length of the buffer, i.e. the number of decimal digits.
15426  int len = 0;
15429 
15430  JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
15431 
15432  // Format the buffer like printf("%.*g", prec, value)
15433  constexpr int kMinExp = -4;
15434  // Use digits10 here to increase compatibility with version 2.
15435  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
15436 
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);
15440 
15441  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
15442 }
15443 
15444 } // namespace detail
15445 } // namespace nlohmann
15446 
15447 // #include <nlohmann/detail/exceptions.hpp>
15448 
15449 // #include <nlohmann/detail/macro_scope.hpp>
15450 
15451 // #include <nlohmann/detail/meta/cpp_future.hpp>
15452 
15453 // #include <nlohmann/detail/output/binary_writer.hpp>
15454 
15455 // #include <nlohmann/detail/output/output_adapters.hpp>
15456 
15457 // #include <nlohmann/detail/value_t.hpp>
15458 
15459 
15460 namespace nlohmann
15461 {
15462 namespace detail
15463 {
15465 // serialization //
15467 
15470 {
15471  strict,
15472  replace,
15473  ignore
15474 };
15475 
15476 template<typename BasicJsonType>
15478 {
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;
15486 
15487  public:
15493  serializer(output_adapter_t<char> s, const char ichar,
15494  error_handler_t error_handler_ = error_handler_t::strict)
15495  : o(std::move(s))
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_)
15502  {}
15503 
15504  // delete because of pointer members
15505  serializer(const serializer&) = delete;
15506  serializer& operator=(const serializer&) = delete;
15507  serializer(serializer&&) = delete;
15509  ~serializer() = default;
15510 
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)
15538  {
15539  switch (val.m_type)
15540  {
15541  case value_t::object:
15542  {
15543  if (val.m_value.object->empty())
15544  {
15545  o->write_characters("{}", 2);
15546  return;
15547  }
15548 
15549  if (pretty_print)
15550  {
15551  o->write_characters("{\n", 2);
15552 
15553  // variable to hold indentation for recursive calls
15554  const auto new_indent = current_indent + indent_step;
15555  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15556  {
15557  indent_string.resize(indent_string.size() * 2, ' ');
15558  }
15559 
15560  // first n-1 elements
15561  auto i = val.m_value.object->cbegin();
15562  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
15563  {
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);
15570  }
15571 
15572  // last element
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);
15580 
15581  o->write_character('\n');
15582  o->write_characters(indent_string.c_str(), current_indent);
15583  o->write_character('}');
15584  }
15585  else
15586  {
15587  o->write_character('{');
15588 
15589  // first n-1 elements
15590  auto i = val.m_value.object->cbegin();
15591  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
15592  {
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(',');
15598  }
15599 
15600  // last element
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);
15607 
15608  o->write_character('}');
15609  }
15610 
15611  return;
15612  }
15613 
15614  case value_t::array:
15615  {
15616  if (val.m_value.array->empty())
15617  {
15618  o->write_characters("[]", 2);
15619  return;
15620  }
15621 
15622  if (pretty_print)
15623  {
15624  o->write_characters("[\n", 2);
15625 
15626  // variable to hold indentation for recursive calls
15627  const auto new_indent = current_indent + indent_step;
15628  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15629  {
15630  indent_string.resize(indent_string.size() * 2, ' ');
15631  }
15632 
15633  // first n-1 elements
15634  for (auto i = val.m_value.array->cbegin();
15635  i != val.m_value.array->cend() - 1; ++i)
15636  {
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);
15640  }
15641 
15642  // last element
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);
15646 
15647  o->write_character('\n');
15648  o->write_characters(indent_string.c_str(), current_indent);
15649  o->write_character(']');
15650  }
15651  else
15652  {
15653  o->write_character('[');
15654 
15655  // first n-1 elements
15656  for (auto i = val.m_value.array->cbegin();
15657  i != val.m_value.array->cend() - 1; ++i)
15658  {
15659  dump(*i, false, ensure_ascii, indent_step, current_indent);
15660  o->write_character(',');
15661  }
15662 
15663  // last element
15664  JSON_ASSERT(!val.m_value.array->empty());
15665  dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
15666 
15667  o->write_character(']');
15668  }
15669 
15670  return;
15671  }
15672 
15673  case value_t::string:
15674  {
15675  o->write_character('\"');
15676  dump_escaped(*val.m_value.string, ensure_ascii);
15677  o->write_character('\"');
15678  return;
15679  }
15680 
15681  case value_t::binary:
15682  {
15683  if (pretty_print)
15684  {
15685  o->write_characters("{\n", 2);
15686 
15687  // variable to hold indentation for recursive calls
15688  const auto new_indent = current_indent + indent_step;
15689  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15690  {
15691  indent_string.resize(indent_string.size() * 2, ' ');
15692  }
15693 
15694  o->write_characters(indent_string.c_str(), new_indent);
15695 
15696  o->write_characters("\"bytes\": [", 10);
15697 
15698  if (!val.m_value.binary->empty())
15699  {
15700  for (auto i = val.m_value.binary->cbegin();
15701  i != val.m_value.binary->cend() - 1; ++i)
15702  {
15703  dump_integer(*i);
15704  o->write_characters(", ", 2);
15705  }
15706  dump_integer(val.m_value.binary->back());
15707  }
15708 
15709  o->write_characters("],\n", 3);
15710  o->write_characters(indent_string.c_str(), new_indent);
15711 
15712  o->write_characters("\"subtype\": ", 11);
15713  if (val.m_value.binary->has_subtype())
15714  {
15715  dump_integer(val.m_value.binary->subtype());
15716  }
15717  else
15718  {
15719  o->write_characters("null", 4);
15720  }
15721  o->write_character('\n');
15722  o->write_characters(indent_string.c_str(), current_indent);
15723  o->write_character('}');
15724  }
15725  else
15726  {
15727  o->write_characters("{\"bytes\":[", 10);
15728 
15729  if (!val.m_value.binary->empty())
15730  {
15731  for (auto i = val.m_value.binary->cbegin();
15732  i != val.m_value.binary->cend() - 1; ++i)
15733  {
15734  dump_integer(*i);
15735  o->write_character(',');
15736  }
15737  dump_integer(val.m_value.binary->back());
15738  }
15739 
15740  o->write_characters("],\"subtype\":", 12);
15741  if (val.m_value.binary->has_subtype())
15742  {
15743  dump_integer(val.m_value.binary->subtype());
15744  o->write_character('}');
15745  }
15746  else
15747  {
15748  o->write_characters("null}", 5);
15749  }
15750  }
15751  return;
15752  }
15753 
15754  case value_t::boolean:
15755  {
15756  if (val.m_value.boolean)
15757  {
15758  o->write_characters("true", 4);
15759  }
15760  else
15761  {
15762  o->write_characters("false", 5);
15763  }
15764  return;
15765  }
15766 
15768  {
15769  dump_integer(val.m_value.number_integer);
15770  return;
15771  }
15772 
15774  {
15775  dump_integer(val.m_value.number_unsigned);
15776  return;
15777  }
15778 
15779  case value_t::number_float:
15780  {
15781  dump_float(val.m_value.number_float);
15782  return;
15783  }
15784 
15785  case value_t::discarded:
15786  {
15787  o->write_characters("<discarded>", 11);
15788  return;
15789  }
15790 
15791  case value_t::null:
15792  {
15793  o->write_characters("null", 4);
15794  return;
15795  }
15796 
15797  default: // LCOV_EXCL_LINE
15798  JSON_ASSERT(false); // LCOV_EXCL_LINE
15799  }
15800  }
15801 
15802  private:
15817  void dump_escaped(const string_t& s, const bool ensure_ascii)
15818  {
15819  std::uint32_t codepoint;
15820  std::uint8_t state = UTF8_ACCEPT;
15821  std::size_t bytes = 0; // number of bytes written to string_buffer
15822 
15823  // number of bytes written at the point of the last valid byte
15824  std::size_t bytes_after_last_accept = 0;
15825  std::size_t undumped_chars = 0;
15826 
15827  for (std::size_t i = 0; i < s.size(); ++i)
15828  {
15829  const auto byte = static_cast<uint8_t>(s[i]);
15830 
15831  switch (decode(state, codepoint, byte))
15832  {
15833  case UTF8_ACCEPT: // decode found a new code point
15834  {
15835  switch (codepoint)
15836  {
15837  case 0x08: // backspace
15838  {
15839  string_buffer[bytes++] = '\\';
15840  string_buffer[bytes++] = 'b';
15841  break;
15842  }
15843 
15844  case 0x09: // horizontal tab
15845  {
15846  string_buffer[bytes++] = '\\';
15847  string_buffer[bytes++] = 't';
15848  break;
15849  }
15850 
15851  case 0x0A: // newline
15852  {
15853  string_buffer[bytes++] = '\\';
15854  string_buffer[bytes++] = 'n';
15855  break;
15856  }
15857 
15858  case 0x0C: // formfeed
15859  {
15860  string_buffer[bytes++] = '\\';
15861  string_buffer[bytes++] = 'f';
15862  break;
15863  }
15864 
15865  case 0x0D: // carriage return
15866  {
15867  string_buffer[bytes++] = '\\';
15868  string_buffer[bytes++] = 'r';
15869  break;
15870  }
15871 
15872  case 0x22: // quotation mark
15873  {
15874  string_buffer[bytes++] = '\\';
15875  string_buffer[bytes++] = '\"';
15876  break;
15877  }
15878 
15879  case 0x5C: // reverse solidus
15880  {
15881  string_buffer[bytes++] = '\\';
15882  string_buffer[bytes++] = '\\';
15883  break;
15884  }
15885 
15886  default:
15887  {
15888  // escape control characters (0x00..0x1F) or, if
15889  // ensure_ascii parameter is used, non-ASCII characters
15890  if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
15891  {
15892  if (codepoint <= 0xFFFF)
15893  {
15894  (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
15895  static_cast<std::uint16_t>(codepoint));
15896  bytes += 6;
15897  }
15898  else
15899  {
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)));
15903  bytes += 12;
15904  }
15905  }
15906  else
15907  {
15908  // copy byte to buffer (all previous bytes
15909  // been copied have in default case above)
15910  string_buffer[bytes++] = s[i];
15911  }
15912  break;
15913  }
15914  }
15915 
15916  // write buffer and reset index; there must be 13 bytes
15917  // left, as this is the maximal number of bytes to be
15918  // written ("\uxxxx\uxxxx\0") for one code point
15919  if (string_buffer.size() - bytes < 13)
15920  {
15921  o->write_characters(string_buffer.data(), bytes);
15922  bytes = 0;
15923  }
15924 
15925  // remember the byte position of this accept
15926  bytes_after_last_accept = bytes;
15927  undumped_chars = 0;
15928  break;
15929  }
15930 
15931  case UTF8_REJECT: // decode found invalid UTF-8 byte
15932  {
15933  switch (error_handler)
15934  {
15936  {
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));
15940  }
15941 
15944  {
15945  // in case we saw this character the first time, we
15946  // would like to read it again, because the byte
15947  // may be OK for itself, but just not OK for the
15948  // previous sequence
15949  if (undumped_chars > 0)
15950  {
15951  --i;
15952  }
15953 
15954  // reset length buffer to the last accepted index;
15955  // thus removing/ignoring the invalid characters
15956  bytes = bytes_after_last_accept;
15957 
15959  {
15960  // add a replacement character
15961  if (ensure_ascii)
15962  {
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';
15969  }
15970  else
15971  {
15975  }
15976 
15977  // write buffer and reset index; there must be 13 bytes
15978  // left, as this is the maximal number of bytes to be
15979  // written ("\uxxxx\uxxxx\0") for one code point
15980  if (string_buffer.size() - bytes < 13)
15981  {
15982  o->write_characters(string_buffer.data(), bytes);
15983  bytes = 0;
15984  }
15985 
15986  bytes_after_last_accept = bytes;
15987  }
15988 
15989  undumped_chars = 0;
15990 
15991  // continue processing the string
15992  state = UTF8_ACCEPT;
15993  break;
15994  }
15995 
15996  default: // LCOV_EXCL_LINE
15997  JSON_ASSERT(false); // LCOV_EXCL_LINE
15998  }
15999  break;
16000  }
16001 
16002  default: // decode found yet incomplete multi-byte code point
16003  {
16004  if (!ensure_ascii)
16005  {
16006  // code point will not be escaped - copy byte to buffer
16007  string_buffer[bytes++] = s[i];
16008  }
16009  ++undumped_chars;
16010  break;
16011  }
16012  }
16013  }
16014 
16015  // we finished processing the string
16016  if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16017  {
16018  // write buffer
16019  if (bytes > 0)
16020  {
16021  o->write_characters(string_buffer.data(), bytes);
16022  }
16023  }
16024  else
16025  {
16026  // we finish reading, but do not accept: string was incomplete
16027  switch (error_handler)
16028  {
16030  {
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));
16034  }
16035 
16037  {
16038  // write all accepted bytes
16039  o->write_characters(string_buffer.data(), bytes_after_last_accept);
16040  break;
16041  }
16042 
16044  {
16045  // write all accepted bytes
16046  o->write_characters(string_buffer.data(), bytes_after_last_accept);
16047  // add a replacement character
16048  if (ensure_ascii)
16049  {
16050  o->write_characters("\\ufffd", 6);
16051  }
16052  else
16053  {
16054  o->write_characters("\xEF\xBF\xBD", 3);
16055  }
16056  break;
16057  }
16058 
16059  default: // LCOV_EXCL_LINE
16060  JSON_ASSERT(false); // LCOV_EXCL_LINE
16061  }
16062  }
16063  }
16064 
16073  inline unsigned int count_digits(number_unsigned_t x) noexcept
16074  {
16075  unsigned int n_digits = 1;
16076  for (;;)
16077  {
16078  if (x < 10)
16079  {
16080  return n_digits;
16081  }
16082  if (x < 100)
16083  {
16084  return n_digits + 1;
16085  }
16086  if (x < 1000)
16087  {
16088  return n_digits + 2;
16089  }
16090  if (x < 10000)
16091  {
16092  return n_digits + 3;
16093  }
16094  x = x / 10000u;
16095  n_digits += 4;
16096  }
16097  }
16098 
16108  template < typename NumberType, detail::enable_if_t <
16112  int > = 0 >
16113  void dump_integer(NumberType x)
16114  {
16115  static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16116  {
16117  {
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'}},
16128  }
16129  };
16130 
16131  // special case for "0"
16132  if (x == 0)
16133  {
16134  o->write_character('0');
16135  return;
16136  }
16137 
16138  // use a pointer to fill the buffer
16139  auto buffer_ptr = number_buffer.begin();
16140 
16141  const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
16142  number_unsigned_t abs_value;
16143 
16144  unsigned int n_chars;
16145 
16146  if (is_negative)
16147  {
16148  *buffer_ptr = '-';
16149  abs_value = remove_sign(static_cast<number_integer_t>(x));
16150 
16151  // account one more byte for the minus sign
16152  n_chars = 1 + count_digits(abs_value);
16153  }
16154  else
16155  {
16156  abs_value = static_cast<number_unsigned_t>(x);
16157  n_chars = count_digits(abs_value);
16158  }
16159 
16160  // spare 1 byte for '\0'
16161  JSON_ASSERT(n_chars < number_buffer.size() - 1);
16162 
16163  // jump to the end to generate the string from backward
16164  // so we later avoid reversing the result
16165  buffer_ptr += n_chars;
16166 
16167  // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
16168  // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
16169  while (abs_value >= 100)
16170  {
16171  const auto digits_index = static_cast<unsigned>((abs_value % 100));
16172  abs_value /= 100;
16173  *(--buffer_ptr) = digits_to_99[digits_index][1];
16174  *(--buffer_ptr) = digits_to_99[digits_index][0];
16175  }
16176 
16177  if (abs_value >= 10)
16178  {
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];
16182  }
16183  else
16184  {
16185  *(--buffer_ptr) = static_cast<char>('0' + abs_value);
16186  }
16187 
16188  o->write_characters(number_buffer.data(), n_chars);
16189  }
16190 
16200  {
16201  // NaN / inf
16202  if (!std::isfinite(x))
16203  {
16204  o->write_characters("null", 4);
16205  return;
16206  }
16207 
16208  // If number_float_t is an IEEE-754 single or double precision number,
16209  // use the Grisu2 algorithm to produce short numbers which are
16210  // guaranteed to round-trip, using strtof and strtod, resp.
16211  //
16212  // NB: The test below works if <long double> == <double>.
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);
16216 
16217  dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
16218  }
16219 
16220  void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
16221  {
16222  char* begin = number_buffer.data();
16223  char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
16224 
16225  o->write_characters(begin, static_cast<size_t>(end - begin));
16226  }
16227 
16228  void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
16229  {
16230  // get number of digits for a float -> text -> float round-trip
16231  static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
16232 
16233  // the actual conversion
16234  std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
16235 
16236  // negative value indicates an error
16237  JSON_ASSERT(len > 0);
16238  // check if buffer was large enough
16239  JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
16240 
16241  // erase thousands separator
16242  if (thousands_sep != '\0')
16243  {
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());
16249  }
16250 
16251  // convert decimal point to '.'
16252  if (decimal_point != '\0' && decimal_point != '.')
16253  {
16254  const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
16255  if (dec_pos != number_buffer.end())
16256  {
16257  *dec_pos = '.';
16258  }
16259  }
16260 
16261  o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
16262 
16263  // determine if need to append ".0"
16264  const bool value_is_int_like =
16265  std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
16266  [](char c)
16267  {
16268  return c == '.' || c == 'e';
16269  });
16270 
16271  if (value_is_int_like)
16272  {
16273  o->write_characters(".0", 2);
16274  }
16275  }
16276 
16298  static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
16299  {
16300  static const std::array<std::uint8_t, 400> utf8d =
16301  {
16302  {
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, // 00..1F
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, // 20..3F
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, // 40..5F
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, // 60..7F
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, // 80..9F
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, // A0..BF
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, // C0..DF
16310  0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
16311  0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
16312  0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
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, // s1..s2
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, // s3..s4
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, // s5..s6
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 // s7..s8
16317  }
16318  };
16319 
16320  const std::uint8_t type = utf8d[byte];
16321 
16322  codep = (state != UTF8_ACCEPT)
16323  ? (byte & 0x3fu) | (codep << 6u)
16324  : (0xFFu >> type) & (byte);
16325 
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];
16329  return state;
16330  }
16331 
16332  /*
16333  * Overload to make the compiler happy while it is instantiating
16334  * dump_integer for number_unsigned_t.
16335  * Must never be called.
16336  */
16338  {
16339  JSON_ASSERT(false); // LCOV_EXCL_LINE
16340  return x; // LCOV_EXCL_LINE
16341  }
16342 
16343  /*
16344  * Helper function for dump_integer
16345  *
16346  * This function takes a negative signed integer and returns its absolute
16347  * value as unsigned integer. The plus/minus shuffling is necessary as we can
16348  * not directly remove the sign of an arbitrary signed integer as the
16349  * absolute values of INT_MIN and INT_MAX are usually not the same. See
16350  * #1708 for details.
16351  */
16353  {
16354  JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
16355  return static_cast<number_unsigned_t>(-(x + 1)) + 1;
16356  }
16357 
16358  private:
16361 
16363  std::array<char, 64> number_buffer{{}};
16364 
16366  const std::lconv* loc = nullptr;
16368  const char thousands_sep = '\0';
16370  const char decimal_point = '\0';
16371 
16373  std::array<char, 512> string_buffer{{}};
16374 
16376  const char indent_char;
16379 
16382 };
16383 } // namespace detail
16384 } // namespace nlohmann
16385 
16386 // #include <nlohmann/detail/value_t.hpp>
16387 
16388 // #include <nlohmann/json_fwd.hpp>
16389 
16390 // #include <nlohmann/ordered_map.hpp>
16391 
16392 
16393 #include <functional> // less
16394 #include <memory> // allocator
16395 #include <utility> // pair
16396 #include <vector> // vector
16397 
16398 namespace nlohmann
16399 {
16400 
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>
16406 {
16407  using key_type = Key;
16408  using mapped_type = T;
16409  using Container = std::vector<std::pair<const Key, T>, Allocator>;
16410  using typename Container::iterator;
16411  using typename Container::const_iterator;
16412  using typename Container::size_type;
16413  using typename Container::value_type;
16414 
16415  // Explicit constructors instead of `using Container::Container`
16416  // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
16417  ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
16418  template <class It>
16419  ordered_map(It first, It last, const Allocator& alloc = Allocator())
16420  : Container{first, last, alloc} {}
16421  ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
16422  : Container{init, alloc} {}
16423 
16424  std::pair<iterator, bool> emplace(const key_type& key, T&& t)
16425  {
16426  for (auto it = this->begin(); it != this->end(); ++it)
16427  {
16428  if (it->first == key)
16429  {
16430  return {it, false};
16431  }
16432  }
16433  Container::emplace_back(key, t);
16434  return {--this->end(), true};
16435  }
16436 
16437  T& operator[](const Key& key)
16438  {
16439  return emplace(key, T{}).first->second;
16440  }
16441 
16442  const T& operator[](const Key& key) const
16443  {
16444  return at(key);
16445  }
16446 
16447  T& at(const Key& key)
16448  {
16449  for (auto it = this->begin(); it != this->end(); ++it)
16450  {
16451  if (it->first == key)
16452  {
16453  return it->second;
16454  }
16455  }
16456 
16457  throw std::out_of_range("key not found");
16458  }
16459 
16460  const T& at(const Key& key) const
16461  {
16462  for (auto it = this->begin(); it != this->end(); ++it)
16463  {
16464  if (it->first == key)
16465  {
16466  return it->second;
16467  }
16468  }
16469 
16470  throw std::out_of_range("key not found");
16471  }
16472 
16473  size_type erase(const Key& key)
16474  {
16475  for (auto it = this->begin(); it != this->end(); ++it)
16476  {
16477  if (it->first == key)
16478  {
16479  // Since we cannot move const Keys, re-construct them in place
16480  for (auto next = it; ++next != this->end(); ++it)
16481  {
16482  it->~value_type(); // Destroy but keep allocation
16483  new (&*it) value_type{std::move(*next)};
16484  }
16485  Container::pop_back();
16486  return 1;
16487  }
16488  }
16489  return 0;
16490  }
16491 
16492  iterator erase(iterator pos)
16493  {
16494  auto it = pos;
16495 
16496  // Since we cannot move const Keys, re-construct them in place
16497  for (auto next = it; ++next != this->end(); ++it)
16498  {
16499  it->~value_type(); // Destroy but keep allocation
16500  new (&*it) value_type{std::move(*next)};
16501  }
16502  Container::pop_back();
16503  return pos;
16504  }
16505 
16506  size_type count(const Key& key) const
16507  {
16508  for (auto it = this->begin(); it != this->end(); ++it)
16509  {
16510  if (it->first == key)
16511  {
16512  return 1;
16513  }
16514  }
16515  return 0;
16516  }
16517 
16518  iterator find(const Key& key)
16519  {
16520  for (auto it = this->begin(); it != this->end(); ++it)
16521  {
16522  if (it->first == key)
16523  {
16524  return it;
16525  }
16526  }
16527  return Container::end();
16528  }
16529 
16530  const_iterator find(const Key& key) const
16531  {
16532  for (auto it = this->begin(); it != this->end(); ++it)
16533  {
16534  if (it->first == key)
16535  {
16536  return it;
16537  }
16538  }
16539  return Container::end();
16540  }
16541 
16542  std::pair<iterator, bool> insert( value_type&& value )
16543  {
16544  return emplace(value.first, std::move(value.second));
16545  }
16546 
16547  std::pair<iterator, bool> insert( const value_type& value )
16548  {
16549  for (auto it = this->begin(); it != this->end(); ++it)
16550  {
16551  if (it->first == value.first)
16552  {
16553  return {it, false};
16554  }
16555  }
16556  Container::push_back(value);
16557  return {--this->end(), true};
16558  }
16559 };
16560 
16561 } // namespace nlohmann
16562 
16563 
16569 namespace nlohmann
16570 {
16571 
16656 NLOHMANN_BASIC_JSON_TPL_DECLARATION
16658 {
16659  private:
16660  template<detail::value_t> friend struct detail::external_constructor;
16661  friend ::nlohmann::json_pointer<basic_json>;
16662 
16663  template<typename BasicJsonType, typename InputType>
16664  friend class ::nlohmann::detail::parser;
16665  friend ::nlohmann::detail::serializer<basic_json>;
16666  template<typename BasicJsonType>
16667  friend class ::nlohmann::detail::iter_impl;
16668  template<typename BasicJsonType, typename CharType>
16669  friend class ::nlohmann::detail::binary_writer;
16670  template<typename BasicJsonType, typename InputType, typename SAX>
16671  friend class ::nlohmann::detail::binary_reader;
16672  template<typename BasicJsonType>
16673  friend class ::nlohmann::detail::json_sax_dom_parser;
16674  template<typename BasicJsonType>
16675  friend class ::nlohmann::detail::json_sax_dom_callback_parser;
16676 
16678  using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
16679 
16680  // convenience aliases for types residing in namespace detail;
16682 
16683  template<typename InputAdapterType>
16684  static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
16685  InputAdapterType adapter,
16687  const bool allow_exceptions = true,
16688  const bool ignore_comments = false
16689  )
16690  {
16691  return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
16692  std::move(cb), allow_exceptions, ignore_comments);
16693  }
16694 
16696  template<typename BasicJsonType>
16698  template<typename BasicJsonType>
16700  template<typename Iterator>
16703 
16704  template<typename CharType>
16706 
16707  template<typename InputType>
16710 
16712 
16713  public:
16717  template<typename T, typename SFINAE>
16718  using json_serializer = JSONSerializer<T, SFINAE>;
16724  using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
16725 
16729 
16731  // exceptions //
16733 
16737 
16750 
16752 
16753 
16755  // container types //
16757 
16762 
16765 
16769  using const_reference = const value_type&;
16770 
16772  using difference_type = std::ptrdiff_t;
16774  using size_type = std::size_t;
16775 
16777  using allocator_type = AllocatorType<basic_json>;
16778 
16780  using pointer = typename std::allocator_traits<allocator_type>::pointer;
16782  using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
16783 
16792 
16794 
16795 
16800  {
16801  return allocator_type();
16802  }
16803 
16830  JSON_HEDLEY_WARN_UNUSED_RESULT
16831  static basic_json meta()
16832  {
16833  basic_json result;
16834 
16835  result["copyright"] = "(C) 2013-2020 Niels Lohmann";
16836  result["name"] = "JSON for Modern C++";
16837  result["url"] = "https://github.com/nlohmann/json";
16838  result["version"]["string"] =
16839  std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
16840  std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
16841  std::to_string(NLOHMANN_JSON_VERSION_PATCH);
16842  result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
16843  result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
16844  result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
16845 
16846 #ifdef _WIN32
16847  result["platform"] = "win32";
16848 #elif defined __linux__
16849  result["platform"] = "linux";
16850 #elif defined __APPLE__
16851  result["platform"] = "apple";
16852 #elif defined __unix__
16853  result["platform"] = "unix";
16854 #else
16855  result["platform"] = "unknown";
16856 #endif
16857 
16858 #if defined(__ICC) || defined(__INTEL_COMPILER)
16859  result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
16860 #elif defined(__clang__)
16861  result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
16862 #elif defined(__GNUC__) || defined(__GNUG__)
16863  result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
16864 #elif defined(__HP_cc) || defined(__HP_aCC)
16865  result["compiler"] = "hp"
16866 #elif defined(__IBMCPP__)
16867  result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
16868 #elif defined(_MSC_VER)
16869  result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
16870 #elif defined(__PGI)
16871  result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
16872 #elif defined(__SUNPRO_CC)
16873  result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
16874 #else
16875  result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
16876 #endif
16877 
16878 #ifdef __cplusplus
16879  result["compiler"]["c++"] = std::to_string(__cplusplus);
16880 #else
16881  result["compiler"]["c++"] = "unknown";
16882 #endif
16883  return result;
16884  }
16885 
16886 
16888  // JSON value data types //
16890 
16895 
16896 #if defined(JSON_HAS_CPP_14)
16897  // Use transparent comparator if possible, combined with perfect forwarding
16898  // on find() and count() calls prevents unnecessary string construction.
16899  using object_comparator_t = std::less<>;
16900 #else
16901  using object_comparator_t = std::less<StringType>;
16902 #endif
16903 
16987  using object_t = ObjectType<StringType,
16988  basic_json,
16990  AllocatorType<std::pair<const StringType,
16991  basic_json>>>;
16992 
17037  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
17038 
17090  using string_t = StringType;
17091 
17116  using boolean_t = BooleanType;
17117 
17188  using number_integer_t = NumberIntegerType;
17189 
17259  using number_unsigned_t = NumberUnsignedType;
17260 
17327  using number_float_t = NumberFloatType;
17328 
17400 
17401  private:
17402 
17404  template<typename T, typename... Args>
17405  JSON_HEDLEY_RETURNS_NON_NULL
17406  static T* create(Args&& ... args)
17407  {
17408  AllocatorType<T> alloc;
17409  using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
17410 
17411  auto deleter = [&](T * object)
17412  {
17413  AllocatorTraits::deallocate(alloc, object, 1);
17414  };
17415  std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
17416  AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
17417  JSON_ASSERT(object != nullptr);
17418  return object.release();
17419  }
17420 
17422  // JSON value storage //
17424 
17451  {
17468 
17470  json_value() = default;
17472  json_value(boolean_t v) noexcept : boolean(v) {}
17481  {
17482  switch (t)
17483  {
17484  case value_t::object:
17485  {
17486  object = create<object_t>();
17487  break;
17488  }
17489 
17490  case value_t::array:
17491  {
17492  array = create<array_t>();
17493  break;
17494  }
17495 
17496  case value_t::string:
17497  {
17498  string = create<string_t>("");
17499  break;
17500  }
17501 
17502  case value_t::binary:
17503  {
17504  binary = create<binary_t>();
17505  break;
17506  }
17507 
17508  case value_t::boolean:
17509  {
17510  boolean = boolean_t(false);
17511  break;
17512  }
17513 
17515  {
17517  break;
17518  }
17519 
17521  {
17523  break;
17524  }
17525 
17526  case value_t::number_float:
17527  {
17529  break;
17530  }
17531 
17532  case value_t::null:
17533  {
17534  object = nullptr; // silence warning, see #821
17535  break;
17536  }
17537 
17538  default:
17539  {
17540  object = nullptr; // silence warning, see #821
17541  if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
17542  {
17543  JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1")); // LCOV_EXCL_LINE
17544  }
17545  break;
17546  }
17547  }
17548  }
17549 
17552  {
17553  string = create<string_t>(value);
17554  }
17555 
17558  {
17559  string = create<string_t>(std::move(value));
17560  }
17561 
17564  {
17565  object = create<object_t>(value);
17566  }
17567 
17570  {
17571  object = create<object_t>(std::move(value));
17572  }
17573 
17576  {
17577  array = create<array_t>(value);
17578  }
17579 
17582  {
17583  array = create<array_t>(std::move(value));
17584  }
17585 
17588  {
17589  binary = create<binary_t>(value);
17590  }
17591 
17594  {
17595  binary = create<binary_t>(std::move(value));
17596  }
17597 
17600  {
17601  binary = create<binary_t>(value);
17602  }
17603 
17606  {
17607  binary = create<binary_t>(std::move(value));
17608  }
17609 
17610  void destroy(value_t t) noexcept
17611  {
17612  // flatten the current json_value to a heap-allocated stack
17613  std::vector<basic_json> stack;
17614 
17615  // move the top-level items to stack
17616  if (t == value_t::array)
17617  {
17618  stack.reserve(array->size());
17619  std::move(array->begin(), array->end(), std::back_inserter(stack));
17620  }
17621  else if (t == value_t::object)
17622  {
17623  stack.reserve(object->size());
17624  for (auto&& it : *object)
17625  {
17626  stack.push_back(std::move(it.second));
17627  }
17628  }
17629 
17630  while (!stack.empty())
17631  {
17632  // move the last item to local variable to be processed
17633  basic_json current_item(std::move(stack.back()));
17634  stack.pop_back();
17635 
17636  // if current_item is array/object, move
17637  // its children to the stack to be processed later
17638  if (current_item.is_array())
17639  {
17640  std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
17641  std::back_inserter(stack));
17642 
17643  current_item.m_value.array->clear();
17644  }
17645  else if (current_item.is_object())
17646  {
17647  for (auto&& it : *current_item.m_value.object)
17648  {
17649  stack.push_back(std::move(it.second));
17650  }
17651 
17652  current_item.m_value.object->clear();
17653  }
17654 
17655  // it's now safe that current_item get destructed
17656  // since it doesn't have any children
17657  }
17658 
17659  switch (t)
17660  {
17661  case value_t::object:
17662  {
17663  AllocatorType<object_t> alloc;
17664  std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
17665  std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
17666  break;
17667  }
17668 
17669  case value_t::array:
17670  {
17671  AllocatorType<array_t> alloc;
17672  std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
17673  std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
17674  break;
17675  }
17676 
17677  case value_t::string:
17678  {
17679  AllocatorType<string_t> alloc;
17680  std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
17681  std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
17682  break;
17683  }
17684 
17685  case value_t::binary:
17686  {
17687  AllocatorType<binary_t> alloc;
17688  std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
17689  std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
17690  break;
17691  }
17692 
17693  default:
17694  {
17695  break;
17696  }
17697  }
17698  }
17699  };
17700 
17710  void assert_invariant() const noexcept
17711  {
17712  JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
17713  JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
17714  JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
17715  JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
17716  }
17717 
17718  public:
17720  // JSON parser callback //
17722 
17739 
17790 
17792  // constructors //
17794 
17799 
17831  : m_type(v), m_value(v)
17832  {
17833  assert_invariant();
17834  }
17835 
17854  basic_json(std::nullptr_t = nullptr) noexcept
17855  : basic_json(value_t::null)
17856  {
17857  assert_invariant();
17858  }
17859 
17923  template < typename CompatibleType,
17924  typename U = detail::uncvref_t<CompatibleType>,
17927  basic_json(CompatibleType && val) noexcept(noexcept(
17928  JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
17929  std::forward<CompatibleType>(val))))
17930  {
17931  JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
17932  assert_invariant();
17933  }
17934 
17961  template < typename BasicJsonType,
17964  basic_json(const BasicJsonType& val)
17965  {
17966  using other_boolean_t = typename BasicJsonType::boolean_t;
17967  using other_number_float_t = typename BasicJsonType::number_float_t;
17968  using other_number_integer_t = typename BasicJsonType::number_integer_t;
17969  using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
17970  using other_string_t = typename BasicJsonType::string_t;
17971  using other_object_t = typename BasicJsonType::object_t;
17972  using other_array_t = typename BasicJsonType::array_t;
17973  using other_binary_t = typename BasicJsonType::binary_t;
17974 
17975  switch (val.type())
17976  {
17977  case value_t::boolean:
17978  JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
17979  break;
17980  case value_t::number_float:
17981  JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
17982  break;
17984  JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
17985  break;
17987  JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
17988  break;
17989  case value_t::string:
17990  JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
17991  break;
17992  case value_t::object:
17993  JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
17994  break;
17995  case value_t::array:
17996  JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
17997  break;
17998  case value_t::binary:
17999  JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
18000  break;
18001  case value_t::null:
18002  *this = nullptr;
18003  break;
18004  case value_t::discarded:
18005  m_type = value_t::discarded;
18006  break;
18007  default: // LCOV_EXCL_LINE
18008  JSON_ASSERT(false); // LCOV_EXCL_LINE
18009  }
18010  assert_invariant();
18011  }
18012 
18088  bool type_deduction = true,
18089  value_t manual_type = value_t::array)
18090  {
18091  // check if each element is an array with two elements whose first
18092  // element is a string
18093  bool is_an_object = std::all_of(init.begin(), init.end(),
18094  [](const detail::json_ref<basic_json>& element_ref)
18095  {
18096  return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
18097  });
18098 
18099  // adjust type if type deduction is not wanted
18100  if (!type_deduction)
18101  {
18102  // if array is wanted, do not create an object though possible
18103  if (manual_type == value_t::array)
18104  {
18105  is_an_object = false;
18106  }
18107 
18108  // if object is wanted but impossible, throw an exception
18109  if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
18110  {
18111  JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
18112  }
18113  }
18114 
18115  if (is_an_object)
18116  {
18117  // the initializer list is a list of pairs -> create object
18118  m_type = value_t::object;
18120 
18121  std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
18122  {
18123  auto element = element_ref.moved_or_copied();
18124  m_value.object->emplace(
18125  std::move(*((*element.m_value.array)[0].m_value.string)),
18126  std::move((*element.m_value.array)[1]));
18127  });
18128  }
18129  else
18130  {
18131  // the initializer list describes an array -> create array
18132  m_type = value_t::array;
18133  m_value.array = create<array_t>(init.begin(), init.end());
18134  }
18135 
18136  assert_invariant();
18137  }
18138 
18166  JSON_HEDLEY_WARN_UNUSED_RESULT
18167  static basic_json binary(const typename binary_t::container_type& init)
18168  {
18169  auto res = basic_json();
18170  res.m_type = value_t::binary;
18171  res.m_value = init;
18172  return res;
18173  }
18174 
18203  JSON_HEDLEY_WARN_UNUSED_RESULT
18204  static basic_json binary(const typename binary_t::container_type& init, std::uint8_t subtype)
18205  {
18206  auto res = basic_json();
18207  res.m_type = value_t::binary;
18208  res.m_value = binary_t(init, subtype);
18209  return res;
18210  }
18211 
18213  JSON_HEDLEY_WARN_UNUSED_RESULT
18215  {
18216  auto res = basic_json();
18217  res.m_type = value_t::binary;
18218  res.m_value = std::move(init);
18219  return res;
18220  }
18221 
18223  JSON_HEDLEY_WARN_UNUSED_RESULT
18224  static basic_json binary(typename binary_t::container_type&& init, std::uint8_t subtype)
18225  {
18226  auto res = basic_json();
18227  res.m_type = value_t::binary;
18228  res.m_value = binary_t(std::move(init), subtype);
18229  return res;
18230  }
18231 
18269  JSON_HEDLEY_WARN_UNUSED_RESULT
18271  {
18272  return basic_json(init, false, value_t::array);
18273  }
18274 
18313  JSON_HEDLEY_WARN_UNUSED_RESULT
18315  {
18316  return basic_json(init, false, value_t::object);
18317  }
18318 
18342  : m_type(value_t::array)
18343  {
18344  m_value.array = create<array_t>(cnt, val);
18345  assert_invariant();
18346  }
18347 
18403  template < class InputIT, typename std::enable_if <
18406  basic_json(InputIT first, InputIT last)
18407  {
18408  JSON_ASSERT(first.m_object != nullptr);
18409  JSON_ASSERT(last.m_object != nullptr);
18410 
18411  // make sure iterator fits the current value
18412  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
18413  {
18414  JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
18415  }
18416 
18417  // copy type from first iterator
18418  m_type = first.m_object->m_type;
18419 
18420  // check if iterator range is complete for primitive values
18421  switch (m_type)
18422  {
18423  case value_t::boolean:
18424  case value_t::number_float:
18427  case value_t::string:
18428  {
18429  if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
18430  || !last.m_it.primitive_iterator.is_end()))
18431  {
18432  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
18433  }
18434  break;
18435  }
18436 
18437  default:
18438  break;
18439  }
18440 
18441  switch (m_type)
18442  {
18444  {
18445  m_value.number_integer = first.m_object->m_value.number_integer;
18446  break;
18447  }
18448 
18450  {
18451  m_value.number_unsigned = first.m_object->m_value.number_unsigned;
18452  break;
18453  }
18454 
18455  case value_t::number_float:
18456  {
18457  m_value.number_float = first.m_object->m_value.number_float;
18458  break;
18459  }
18460 
18461  case value_t::boolean:
18462  {
18463  m_value.boolean = first.m_object->m_value.boolean;
18464  break;
18465  }
18466 
18467  case value_t::string:
18468  {
18469  m_value = *first.m_object->m_value.string;
18470  break;
18471  }
18472 
18473  case value_t::object:
18474  {
18475  m_value.object = create<object_t>(first.m_it.object_iterator,
18476  last.m_it.object_iterator);
18477  break;
18478  }
18479 
18480  case value_t::array:
18481  {
18482  m_value.array = create<array_t>(first.m_it.array_iterator,
18483  last.m_it.array_iterator);
18484  break;
18485  }
18486 
18487  case value_t::binary:
18488  {
18489  m_value = *first.m_object->m_value.binary;
18490  break;
18491  }
18492 
18493  default:
18494  JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
18495  std::string(first.m_object->type_name())));
18496  }
18497 
18498  assert_invariant();
18499  }
18500 
18501 
18503  // other constructors and destructor //
18505 
18506  template<typename JsonRef,
18508  std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
18509  basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
18510 
18536  basic_json(const basic_json& other)
18537  : m_type(other.m_type)
18538  {
18539  // check of passed value is valid
18540  other.assert_invariant();
18541 
18542  switch (m_type)
18543  {
18544  case value_t::object:
18545  {
18546  m_value = *other.m_value.object;
18547  break;
18548  }
18549 
18550  case value_t::array:
18551  {
18552  m_value = *other.m_value.array;
18553  break;
18554  }
18555 
18556  case value_t::string:
18557  {
18558  m_value = *other.m_value.string;
18559  break;
18560  }
18561 
18562  case value_t::boolean:
18563  {
18564  m_value = other.m_value.boolean;
18565  break;
18566  }
18567 
18569  {
18570  m_value = other.m_value.number_integer;
18571  break;
18572  }
18573 
18575  {
18577  break;
18578  }
18579 
18580  case value_t::number_float:
18581  {
18582  m_value = other.m_value.number_float;
18583  break;
18584  }
18585 
18586  case value_t::binary:
18587  {
18588  m_value = *other.m_value.binary;
18589  break;
18590  }
18591 
18592  default:
18593  break;
18594  }
18595 
18596  assert_invariant();
18597  }
18598 
18625  basic_json(basic_json&& other) noexcept
18626  : m_type(std::move(other.m_type)),
18627  m_value(std::move(other.m_value))
18628  {
18629  // check that passed value is valid
18630  other.assert_invariant();
18631 
18632  // invalidate payload
18633  other.m_type = value_t::null;
18634  other.m_value = {};
18635 
18636  assert_invariant();
18637  }
18638 
18662  basic_json& operator=(basic_json other) noexcept (
18667  )
18668  {
18669  // check that passed value is valid
18670  other.assert_invariant();
18671 
18672  using std::swap;
18673  swap(m_type, other.m_type);
18674  swap(m_value, other.m_value);
18675 
18676  assert_invariant();
18677  return *this;
18678  }
18679 
18695  ~basic_json() noexcept
18696  {
18697  assert_invariant();
18698  m_value.destroy(m_type);
18699  }
18700 
18702 
18703  public:
18705  // object inspection //
18707 
18711 
18759  string_t dump(const int indent = -1,
18760  const char indent_char = ' ',
18761  const bool ensure_ascii = false,
18762  const error_handler_t error_handler = error_handler_t::strict) const
18763  {
18764  string_t result;
18765  serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
18766 
18767  if (indent >= 0)
18768  {
18769  s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
18770  }
18771  else
18772  {
18773  s.dump(*this, false, ensure_ascii, 0);
18774  }
18775 
18776  return result;
18777  }
18778 
18812  constexpr value_t type() const noexcept
18813  {
18814  return m_type;
18815  }
18816 
18843  constexpr bool is_primitive() const noexcept
18844  {
18845  return is_null() || is_string() || is_boolean() || is_number() || is_binary();
18846  }
18847 
18870  constexpr bool is_structured() const noexcept
18871  {
18872  return is_array() || is_object();
18873  }
18874 
18892  constexpr bool is_null() const noexcept
18893  {
18894  return m_type == value_t::null;
18895  }
18896 
18914  constexpr bool is_boolean() const noexcept
18915  {
18916  return m_type == value_t::boolean;
18917  }
18918 
18944  constexpr bool is_number() const noexcept
18945  {
18946  return is_number_integer() || is_number_float();
18947  }
18948 
18973  constexpr bool is_number_integer() const noexcept
18974  {
18975  return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
18976  }
18977 
19001  constexpr bool is_number_unsigned() const noexcept
19002  {
19003  return m_type == value_t::number_unsigned;
19004  }
19005 
19029  constexpr bool is_number_float() const noexcept
19030  {
19031  return m_type == value_t::number_float;
19032  }
19033 
19051  constexpr bool is_object() const noexcept
19052  {
19053  return m_type == value_t::object;
19054  }
19055 
19073  constexpr bool is_array() const noexcept
19074  {
19075  return m_type == value_t::array;
19076  }
19077 
19095  constexpr bool is_string() const noexcept
19096  {
19097  return m_type == value_t::string;
19098  }
19099 
19117  constexpr bool is_binary() const noexcept
19118  {
19119  return m_type == value_t::binary;
19120  }
19121 
19144  constexpr bool is_discarded() const noexcept
19145  {
19146  return m_type == value_t::discarded;
19147  }
19148 
19170  constexpr operator value_t() const noexcept
19171  {
19172  return m_type;
19173  }
19174 
19176 
19177  private:
19179  // value access //
19181 
19183  boolean_t get_impl(boolean_t* /*unused*/) const
19184  {
19185  if (JSON_HEDLEY_LIKELY(is_boolean()))
19186  {
19187  return m_value.boolean;
19188  }
19189 
19190  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
19191  }
19192 
19194  object_t* get_impl_ptr(object_t* /*unused*/) noexcept
19195  {
19196  return is_object() ? m_value.object : nullptr;
19197  }
19198 
19200  constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
19201  {
19202  return is_object() ? m_value.object : nullptr;
19203  }
19204 
19206  array_t* get_impl_ptr(array_t* /*unused*/) noexcept
19207  {
19208  return is_array() ? m_value.array : nullptr;
19209  }
19210 
19212  constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
19213  {
19214  return is_array() ? m_value.array : nullptr;
19215  }
19216 
19218  string_t* get_impl_ptr(string_t* /*unused*/) noexcept
19219  {
19220  return is_string() ? m_value.string : nullptr;
19221  }
19222 
19224  constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
19225  {
19226  return is_string() ? m_value.string : nullptr;
19227  }
19228 
19230  boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
19231  {
19232  return is_boolean() ? &m_value.boolean : nullptr;
19233  }
19234 
19236  constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
19237  {
19238  return is_boolean() ? &m_value.boolean : nullptr;
19239  }
19240 
19243  {
19244  return is_number_integer() ? &m_value.number_integer : nullptr;
19245  }
19246 
19248  constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
19249  {
19250  return is_number_integer() ? &m_value.number_integer : nullptr;
19251  }
19252 
19255  {
19256  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
19257  }
19258 
19260  constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
19261  {
19262  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
19263  }
19264 
19267  {
19268  return is_number_float() ? &m_value.number_float : nullptr;
19269  }
19270 
19272  constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
19273  {
19274  return is_number_float() ? &m_value.number_float : nullptr;
19275  }
19276 
19278  binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
19279  {
19280  return is_binary() ? m_value.binary : nullptr;
19281  }
19282 
19284  constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
19285  {
19286  return is_binary() ? m_value.binary : nullptr;
19287  }
19288 
19300  template<typename ReferenceType, typename ThisType>
19301  static ReferenceType get_ref_impl(ThisType& obj)
19302  {
19303  // delegate the call to get_ptr<>()
19304  auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
19305 
19306  if (JSON_HEDLEY_LIKELY(ptr != nullptr))
19307  {
19308  return *ptr;
19309  }
19310 
19311  JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
19312  }
19313 
19314  public:
19318 
19333  template<typename BasicJsonType, detail::enable_if_t<
19334  std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
19335  int> = 0>
19336  basic_json get() const
19337  {
19338  return *this;
19339  }
19340 
19356  template < typename BasicJsonType, detail::enable_if_t <
19359  BasicJsonType get() const
19360  {
19361  return *this;
19362  }
19363 
19403  template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
19404  detail::enable_if_t <
19405  !detail::is_basic_json<ValueType>::value &&
19406  detail::has_from_json<basic_json_t, ValueType>::value &&
19407  !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
19408  int > = 0 >
19409  ValueType get() const noexcept(noexcept(
19410  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
19411  {
19412  // we cannot static_assert on ValueTypeCV being non-const, because
19413  // there is support for get<const basic_json_t>(), which is why we
19414  // still need the uncvref
19416  "get() cannot be used with reference types, you might want to use get_ref()");
19418  "types must be DefaultConstructible when used with get()");
19419 
19420  ValueType ret;
19422  return ret;
19423  }
19424 
19456  template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
19457  detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
19458  detail::has_non_default_from_json<basic_json_t, ValueType>::value,
19459  int > = 0 >
19460  ValueType get() const noexcept(noexcept(
19461  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
19462  {
19464  "get() cannot be used with reference types, you might want to use get_ref()");
19466  }
19467 
19501  template < typename ValueType,
19505  int > = 0 >
19506  ValueType & get_to(ValueType& v) const noexcept(noexcept(
19507  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
19508  {
19510  return v;
19511  }
19512 
19513  // specialization to allow to call get_to with a basic_json value
19514  // see https://github.com/nlohmann/json/issues/2175
19515  template<typename ValueType,
19518  int> = 0>
19519  ValueType & get_to(ValueType& v) const
19520  {
19521  v = *this;
19522  return v;
19523  }
19524 
19525  template <
19526  typename T, std::size_t N,
19527  typename Array = T (&)[N],
19530  Array get_to(T (&v)[N]) const
19531  noexcept(noexcept(JSONSerializer<Array>::from_json(
19532  std::declval<const basic_json_t&>(), v)))
19533  {
19535  return v;
19536  }
19537 
19538 
19565  template<typename PointerType, typename std::enable_if<
19567  auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
19568  {
19569  // delegate the call to get_impl_ptr<>()
19570  return get_impl_ptr(static_cast<PointerType>(nullptr));
19571  }
19572 
19577  template < typename PointerType, typename std::enable_if <
19579  std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
19580  constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
19581  {
19582  // delegate the call to get_impl_ptr<>() const
19583  return get_impl_ptr(static_cast<PointerType>(nullptr));
19584  }
19585 
19613  template<typename PointerType, typename std::enable_if<
19615  auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
19616  {
19617  // delegate the call to get_ptr
19618  return get_ptr<PointerType>();
19619  }
19620 
19625  template<typename PointerType, typename std::enable_if<
19627  constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
19628  {
19629  // delegate the call to get_ptr
19630  return get_ptr<PointerType>();
19631  }
19632 
19659  template<typename ReferenceType, typename std::enable_if<
19661  ReferenceType get_ref()
19662  {
19663  // delegate call to get_ref_impl
19664  return get_ref_impl<ReferenceType>(*this);
19665  }
19666 
19671  template < typename ReferenceType, typename std::enable_if <
19673  std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
19674  ReferenceType get_ref() const
19675  {
19676  // delegate call to get_ref_impl
19677  return get_ref_impl<ReferenceType>(*this);
19678  }
19679 
19709  template < typename ValueType, typename std::enable_if <
19711  !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
19714  && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
19715 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
19717 #endif
19719  , int >::type = 0 >
19720  JSON_EXPLICIT operator ValueType() const
19721  {
19722  // delegate the call to get<>() const
19723  return get<ValueType>();
19724  }
19725 
19736  {
19737  if (!is_binary())
19738  {
19739  JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
19740  }
19741 
19742  return *get_ptr<binary_t*>();
19743  }
19744 
19746  const binary_t& get_binary() const
19747  {
19748  if (!is_binary())
19749  {
19750  JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
19751  }
19752 
19753  return *get_ptr<const binary_t*>();
19754  }
19755 
19757 
19758 
19760  // element access //
19762 
19766 
19794  {
19795  // at only works for arrays
19796  if (JSON_HEDLEY_LIKELY(is_array()))
19797  {
19798  JSON_TRY
19799  {
19800  return m_value.array->at(idx);
19801  }
19802  JSON_CATCH (std::out_of_range&)
19803  {
19804  // create better exception explanation
19805  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
19806  }
19807  }
19808  else
19809  {
19810  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19811  }
19812  }
19813 
19841  {
19842  // at only works for arrays
19843  if (JSON_HEDLEY_LIKELY(is_array()))
19844  {
19845  JSON_TRY
19846  {
19847  return m_value.array->at(idx);
19848  }
19849  JSON_CATCH (std::out_of_range&)
19850  {
19851  // create better exception explanation
19852  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
19853  }
19854  }
19855  else
19856  {
19857  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19858  }
19859  }
19860 
19891  reference at(const typename object_t::key_type& key)
19892  {
19893  // at only works for objects
19894  if (JSON_HEDLEY_LIKELY(is_object()))
19895  {
19896  JSON_TRY
19897  {
19898  return m_value.object->at(key);
19899  }
19900  JSON_CATCH (std::out_of_range&)
19901  {
19902  // create better exception explanation
19903  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
19904  }
19905  }
19906  else
19907  {
19908  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19909  }
19910  }
19911 
19942  const_reference at(const typename object_t::key_type& key) const
19943  {
19944  // at only works for objects
19945  if (JSON_HEDLEY_LIKELY(is_object()))
19946  {
19947  JSON_TRY
19948  {
19949  return m_value.object->at(key);
19950  }
19951  JSON_CATCH (std::out_of_range&)
19952  {
19953  // create better exception explanation
19954  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
19955  }
19956  }
19957  else
19958  {
19959  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19960  }
19961  }
19962 
19989  {
19990  // implicitly convert null value to an empty array
19991  if (is_null())
19992  {
19993  m_type = value_t::array;
19994  m_value.array = create<array_t>();
19995  assert_invariant();
19996  }
19997 
19998  // operator[] only works for arrays
19999  if (JSON_HEDLEY_LIKELY(is_array()))
20000  {
20001  // fill up array with null values if given idx is outside range
20002  if (idx >= m_value.array->size())
20003  {
20004  m_value.array->insert(m_value.array->end(),
20005  idx - m_value.array->size() + 1,
20006  basic_json());
20007  }
20008 
20009  return m_value.array->operator[](idx);
20010  }
20011 
20012  JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
20013  }
20014 
20035  {
20036  // const operator[] only works for arrays
20037  if (JSON_HEDLEY_LIKELY(is_array()))
20038  {
20039  return m_value.array->operator[](idx);
20040  }
20041 
20042  JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
20043  }
20044 
20072  reference operator[](const typename object_t::key_type& key)
20073  {
20074  // implicitly convert null value to an empty object
20075  if (is_null())
20076  {
20077  m_type = value_t::object;
20078  m_value.object = create<object_t>();
20079  assert_invariant();
20080  }
20081 
20082  // operator[] only works for objects
20083  if (JSON_HEDLEY_LIKELY(is_object()))
20084  {
20085  return m_value.object->operator[](key);
20086  }
20087 
20088  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20089  }
20090 
20121  const_reference operator[](const typename object_t::key_type& key) const
20122  {
20123  // const operator[] only works for objects
20124  if (JSON_HEDLEY_LIKELY(is_object()))
20125  {
20126  JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
20127  return m_value.object->find(key)->second;
20128  }
20129 
20130  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20131  }
20132 
20160  template<typename T>
20162  reference operator[](T* key)
20163  {
20164  // implicitly convert null to object
20165  if (is_null())
20166  {
20167  m_type = value_t::object;
20169  assert_invariant();
20170  }
20171 
20172  // at only works for objects
20173  if (JSON_HEDLEY_LIKELY(is_object()))
20174  {
20175  return m_value.object->operator[](key);
20176  }
20177 
20178  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20179  }
20180 
20211  template<typename T>
20213  const_reference operator[](T* key) const
20214  {
20215  // at only works for objects
20216  if (JSON_HEDLEY_LIKELY(is_object()))
20217  {
20218  JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
20219  return m_value.object->find(key)->second;
20220  }
20221 
20222  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20223  }
20224 
20275  // using std::is_convertible in a std::enable_if will fail when using explicit conversions
20276  template < class ValueType, typename std::enable_if <
20279  ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
20280  {
20281  // at only works for objects
20282  if (JSON_HEDLEY_LIKELY(is_object()))
20283  {
20284  // if key is found, return value and given default value otherwise
20285  const auto it = find(key);
20286  if (it != end())
20287  {
20288  return it->template get<ValueType>();
20289  }
20290 
20291  return default_value;
20292  }
20293 
20294  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
20295  }
20296 
20301  string_t value(const typename object_t::key_type& key, const char* default_value) const
20302  {
20303  return value(key, string_t(default_value));
20304  }
20305 
20349  template<class ValueType, typename std::enable_if<
20351  ValueType value(const json_pointer& ptr, const ValueType& default_value) const
20352  {
20353  // at only works for objects
20354  if (JSON_HEDLEY_LIKELY(is_object()))
20355  {
20356  // if pointer resolves a value, return it or use default value
20357  JSON_TRY
20358  {
20359  return ptr.get_checked(this).template get<ValueType>();
20360  }
20361  JSON_INTERNAL_CATCH (out_of_range&)
20362  {
20363  return default_value;
20364  }
20365  }
20366 
20367  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
20368  }
20369 
20375  string_t value(const json_pointer& ptr, const char* default_value) const
20376  {
20377  return value(ptr, string_t(default_value));
20378  }
20379 
20406  {
20407  return *begin();
20408  }
20409 
20414  {
20415  return *cbegin();
20416  }
20417 
20450  {
20451  auto tmp = end();
20452  --tmp;
20453  return *tmp;
20454  }
20455 
20460  {
20461  auto tmp = cend();
20462  --tmp;
20463  return *tmp;
20464  }
20465 
20512  template < class IteratorType, typename std::enable_if <
20515  = 0 >
20516  IteratorType erase(IteratorType pos)
20517  {
20518  // make sure iterator fits the current value
20519  if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
20520  {
20521  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
20522  }
20523 
20524  IteratorType result = end();
20525 
20526  switch (m_type)
20527  {
20528  case value_t::boolean:
20529  case value_t::number_float:
20532  case value_t::string:
20533  case value_t::binary:
20534  {
20535  if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
20536  {
20537  JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
20538  }
20539 
20540  if (is_string())
20541  {
20542  AllocatorType<string_t> alloc;
20543  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
20544  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
20545  m_value.string = nullptr;
20546  }
20547  else if (is_binary())
20548  {
20549  AllocatorType<binary_t> alloc;
20550  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
20551  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
20552  m_value.binary = nullptr;
20553  }
20554 
20555  m_type = value_t::null;
20556  assert_invariant();
20557  break;
20558  }
20559 
20560  case value_t::object:
20561  {
20562  result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
20563  break;
20564  }
20565 
20566  case value_t::array:
20567  {
20568  result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
20569  break;
20570  }
20571 
20572  default:
20573  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20574  }
20575 
20576  return result;
20577  }
20578 
20625  template < class IteratorType, typename std::enable_if <
20628  = 0 >
20629  IteratorType erase(IteratorType first, IteratorType last)
20630  {
20631  // make sure iterator fits the current value
20632  if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
20633  {
20634  JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
20635  }
20636 
20637  IteratorType result = end();
20638 
20639  switch (m_type)
20640  {
20641  case value_t::boolean:
20642  case value_t::number_float:
20645  case value_t::string:
20646  case value_t::binary:
20647  {
20648  if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
20649  || !last.m_it.primitive_iterator.is_end()))
20650  {
20651  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
20652  }
20653 
20654  if (is_string())
20655  {
20656  AllocatorType<string_t> alloc;
20657  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
20658  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
20659  m_value.string = nullptr;
20660  }
20661  else if (is_binary())
20662  {
20663  AllocatorType<binary_t> alloc;
20664  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
20665  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
20666  m_value.binary = nullptr;
20667  }
20668 
20669  m_type = value_t::null;
20670  assert_invariant();
20671  break;
20672  }
20673 
20674  case value_t::object:
20675  {
20676  result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
20677  last.m_it.object_iterator);
20678  break;
20679  }
20680 
20681  case value_t::array:
20682  {
20683  result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
20684  last.m_it.array_iterator);
20685  break;
20686  }
20687 
20688  default:
20689  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20690  }
20691 
20692  return result;
20693  }
20694 
20724  size_type erase(const typename object_t::key_type& key)
20725  {
20726  // this erase only works for objects
20727  if (JSON_HEDLEY_LIKELY(is_object()))
20728  {
20729  return m_value.object->erase(key);
20730  }
20731 
20732  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20733  }
20734 
20759  void erase(const size_type idx)
20760  {
20761  // this erase only works for arrays
20762  if (JSON_HEDLEY_LIKELY(is_array()))
20763  {
20764  if (JSON_HEDLEY_UNLIKELY(idx >= size()))
20765  {
20766  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
20767  }
20768 
20769  m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
20770  }
20771  else
20772  {
20773  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20774  }
20775  }
20776 
20778 
20779 
20781  // lookup //
20783 
20786 
20811  template<typename KeyT>
20812  iterator find(KeyT&& key)
20813  {
20814  auto result = end();
20815 
20816  if (is_object())
20817  {
20818  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
20819  }
20820 
20821  return result;
20822  }
20823 
20828  template<typename KeyT>
20829  const_iterator find(KeyT&& key) const
20830  {
20831  auto result = cend();
20832 
20833  if (is_object())
20834  {
20835  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
20836  }
20837 
20838  return result;
20839  }
20840 
20862  template<typename KeyT>
20863  size_type count(KeyT&& key) const
20864  {
20865  // return 0 for all nonobject types
20866  return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
20867  }
20868 
20894  template < typename KeyT, typename std::enable_if <
20895  !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
20896  bool contains(KeyT && key) const
20897  {
20898  return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
20899  }
20900 
20927  bool contains(const json_pointer& ptr) const
20928  {
20929  return ptr.contains(this);
20930  }
20931 
20933 
20934 
20936  // iterators //
20938 
20941 
20966  iterator begin() noexcept
20967  {
20968  iterator result(this);
20969  result.set_begin();
20970  return result;
20971  }
20972 
20977  {
20978  return cbegin();
20979  }
20980 
21007  {
21008  const_iterator result(this);
21009  result.set_begin();
21010  return result;
21011  }
21012 
21037  iterator end() noexcept
21038  {
21039  iterator result(this);
21040  result.set_end();
21041  return result;
21042  }
21043 
21048  {
21049  return cend();
21050  }
21051 
21078  {
21079  const_iterator result(this);
21080  result.set_end();
21081  return result;
21082  }
21083 
21108  {
21109  return reverse_iterator(end());
21110  }
21111 
21116  {
21117  return crbegin();
21118  }
21119 
21145  {
21146  return reverse_iterator(begin());
21147  }
21148 
21153  {
21154  return crend();
21155  }
21156 
21182  {
21183  return const_reverse_iterator(cend());
21184  }
21185 
21211  {
21212  return const_reverse_iterator(cbegin());
21213  }
21214 
21215  public:
21274  static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
21275  {
21276  return ref.items();
21277  }
21278 
21283  static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
21284  {
21285  return ref.items();
21286  }
21287 
21357  {
21358  return iteration_proxy<iterator>(*this);
21359  }
21360 
21365  {
21366  return iteration_proxy<const_iterator>(*this);
21367  }
21368 
21370 
21371 
21373  // capacity //
21375 
21378 
21421  bool empty() const noexcept
21422  {
21423  switch (m_type)
21424  {
21425  case value_t::null:
21426  {
21427  // null values are empty
21428  return true;
21429  }
21430 
21431  case value_t::array:
21432  {
21433  // delegate call to array_t::empty()
21434  return m_value.array->empty();
21435  }
21436 
21437  case value_t::object:
21438  {
21439  // delegate call to object_t::empty()
21440  return m_value.object->empty();
21441  }
21442 
21443  default:
21444  {
21445  // all other types are nonempty
21446  return false;
21447  }
21448  }
21449  }
21450 
21494  size_type size() const noexcept
21495  {
21496  switch (m_type)
21497  {
21498  case value_t::null:
21499  {
21500  // null values are empty
21501  return 0;
21502  }
21503 
21504  case value_t::array:
21505  {
21506  // delegate call to array_t::size()
21507  return m_value.array->size();
21508  }
21509 
21510  case value_t::object:
21511  {
21512  // delegate call to object_t::size()
21513  return m_value.object->size();
21514  }
21515 
21516  default:
21517  {
21518  // all other types have size 1
21519  return 1;
21520  }
21521  }
21522  }
21523 
21566  {
21567  switch (m_type)
21568  {
21569  case value_t::array:
21570  {
21571  // delegate call to array_t::max_size()
21572  return m_value.array->max_size();
21573  }
21574 
21575  case value_t::object:
21576  {
21577  // delegate call to object_t::max_size()
21578  return m_value.object->max_size();
21579  }
21580 
21581  default:
21582  {
21583  // all other types have max_size() == size()
21584  return size();
21585  }
21586  }
21587  }
21588 
21590 
21591 
21593  // modifiers //
21595 
21598 
21636  void clear() noexcept
21637  {
21638  switch (m_type)
21639  {
21641  {
21642  m_value.number_integer = 0;
21643  break;
21644  }
21645 
21647  {
21649  break;
21650  }
21651 
21652  case value_t::number_float:
21653  {
21654  m_value.number_float = 0.0;
21655  break;
21656  }
21657 
21658  case value_t::boolean:
21659  {
21660  m_value.boolean = false;
21661  break;
21662  }
21663 
21664  case value_t::string:
21665  {
21666  m_value.string->clear();
21667  break;
21668  }
21669 
21670  case value_t::binary:
21671  {
21672  m_value.binary->clear();
21673  break;
21674  }
21675 
21676  case value_t::array:
21677  {
21678  m_value.array->clear();
21679  break;
21680  }
21681 
21682  case value_t::object:
21683  {
21684  m_value.object->clear();
21685  break;
21686  }
21687 
21688  default:
21689  break;
21690  }
21691  }
21692 
21713  void push_back(basic_json&& val)
21714  {
21715  // push_back only works for null objects or arrays
21716  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
21717  {
21718  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
21719  }
21720 
21721  // transform null object into an array
21722  if (is_null())
21723  {
21724  m_type = value_t::array;
21726  assert_invariant();
21727  }
21728 
21729  // add element to array (move semantics)
21730  m_value.array->push_back(std::move(val));
21731  // if val is moved from, basic_json move constructor marks it null so we do not call the destructor
21732  }
21733 
21739  {
21740  push_back(std::move(val));
21741  return *this;
21742  }
21743 
21748  void push_back(const basic_json& val)
21749  {
21750  // push_back only works for null objects or arrays
21751  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
21752  {
21753  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
21754  }
21755 
21756  // transform null object into an array
21757  if (is_null())
21758  {
21759  m_type = value_t::array;
21761  assert_invariant();
21762  }
21763 
21764  // add element to array
21765  m_value.array->push_back(val);
21766  }
21767 
21773  {
21774  push_back(val);
21775  return *this;
21776  }
21777 
21798  void push_back(const typename object_t::value_type& val)
21799  {
21800  // push_back only works for null objects or objects
21801  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
21802  {
21803  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
21804  }
21805 
21806  // transform null object into an object
21807  if (is_null())
21808  {
21809  m_type = value_t::object;
21811  assert_invariant();
21812  }
21813 
21814  // add element to array
21815  m_value.object->insert(val);
21816  }
21817 
21822  reference operator+=(const typename object_t::value_type& val)
21823  {
21824  push_back(val);
21825  return *this;
21826  }
21827 
21854  {
21855  if (is_object() && init.size() == 2 && (*init.begin())->is_string())
21856  {
21857  basic_json&& key = init.begin()->moved_or_copied();
21858  push_back(typename object_t::value_type(
21859  std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
21860  }
21861  else
21862  {
21863  push_back(basic_json(init));
21864  }
21865  }
21866 
21872  {
21873  push_back(init);
21874  return *this;
21875  }
21876 
21900  template<class... Args>
21901  reference emplace_back(Args&& ... args)
21902  {
21903  // emplace_back only works for null objects or arrays
21904  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
21905  {
21906  JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
21907  }
21908 
21909  // transform null object into an array
21910  if (is_null())
21911  {
21912  m_type = value_t::array;
21914  assert_invariant();
21915  }
21916 
21917  // add element to array (perfect forwarding)
21918 #ifdef JSON_HAS_CPP_17
21919  return m_value.array->emplace_back(std::forward<Args>(args)...);
21920 #else
21921  m_value.array->emplace_back(std::forward<Args>(args)...);
21922  return m_value.array->back();
21923 #endif
21924  }
21925 
21953  template<class... Args>
21954  std::pair<iterator, bool> emplace(Args&& ... args)
21955  {
21956  // emplace only works for null objects or arrays
21957  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
21958  {
21959  JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
21960  }
21961 
21962  // transform null object into an object
21963  if (is_null())
21964  {
21965  m_type = value_t::object;
21967  assert_invariant();
21968  }
21969 
21970  // add element to array (perfect forwarding)
21971  auto res = m_value.object->emplace(std::forward<Args>(args)...);
21972  // create result iterator and set iterator to the result of emplace
21973  auto it = begin();
21974  it.m_it.object_iterator = res.first;
21975 
21976  // return pair of iterator and boolean
21977  return {it, res.second};
21978  }
21979 
21983  template<typename... Args>
21985  {
21986  iterator result(this);
21987  JSON_ASSERT(m_value.array != nullptr);
21988 
21989  auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
21990  m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
21991  result.m_it.array_iterator = m_value.array->begin() + insert_pos;
21992 
21993  // This could have been written as:
21994  // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
21995  // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
21996 
21997  return result;
21998  }
21999 
22023  {
22024  // insert only works for arrays
22025  if (JSON_HEDLEY_LIKELY(is_array()))
22026  {
22027  // check if iterator pos fits to this JSON value
22028  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22029  {
22030  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22031  }
22032 
22033  // insert to array and return iterator
22034  return insert_iterator(pos, val);
22035  }
22036 
22037  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22038  }
22039 
22045  {
22046  return insert(pos, val);
22047  }
22048 
22074  {
22075  // insert only works for arrays
22076  if (JSON_HEDLEY_LIKELY(is_array()))
22077  {
22078  // check if iterator pos fits to this JSON value
22079  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22080  {
22081  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22082  }
22083 
22084  // insert to array and return iterator
22085  return insert_iterator(pos, cnt, val);
22086  }
22087 
22088  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22089  }
22090 
22122  {
22123  // insert only works for arrays
22124  if (JSON_HEDLEY_UNLIKELY(!is_array()))
22125  {
22126  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22127  }
22128 
22129  // check if iterator pos fits to this JSON value
22130  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22131  {
22132  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22133  }
22134 
22135  // check if range iterators belong to the same JSON object
22136  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22137  {
22138  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
22139  }
22140 
22141  if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
22142  {
22143  JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
22144  }
22145 
22146  // insert to array and return iterator
22147  return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
22148  }
22149 
22175  {
22176  // insert only works for arrays
22177  if (JSON_HEDLEY_UNLIKELY(!is_array()))
22178  {
22179  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22180  }
22181 
22182  // check if iterator pos fits to this JSON value
22183  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22184  {
22185  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22186  }
22187 
22188  // insert to array and return iterator
22189  return insert_iterator(pos, ilist.begin(), ilist.end());
22190  }
22191 
22216  {
22217  // insert only works for objects
22218  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22219  {
22220  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22221  }
22222 
22223  // check if range iterators belong to the same JSON object
22224  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22225  {
22226  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
22227  }
22228 
22229  // passed iterators must belong to objects
22230  if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
22231  {
22232  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
22233  }
22234 
22235  m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
22236  }
22237 
22258  {
22259  // implicitly convert null value to an empty object
22260  if (is_null())
22261  {
22262  m_type = value_t::object;
22263  m_value.object = create<object_t>();
22264  assert_invariant();
22265  }
22266 
22267  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22268  {
22269  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
22270  }
22271  if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
22272  {
22273  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
22274  }
22275 
22276  for (auto it = j.cbegin(); it != j.cend(); ++it)
22277  {
22278  m_value.object->operator[](it.key()) = it.value();
22279  }
22280  }
22281 
22309  {
22310  // implicitly convert null value to an empty object
22311  if (is_null())
22312  {
22313  m_type = value_t::object;
22314  m_value.object = create<object_t>();
22315  assert_invariant();
22316  }
22317 
22318  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22319  {
22320  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
22321  }
22322 
22323  // check if range iterators belong to the same JSON object
22324  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22325  {
22326  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
22327  }
22328 
22329  // passed iterators must belong to objects
22330  if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
22331  || !last.m_object->is_object()))
22332  {
22333  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
22334  }
22335 
22336  for (auto it = first; it != last; ++it)
22337  {
22338  m_value.object->operator[](it.key()) = it.value();
22339  }
22340  }
22341 
22359  void swap(reference other) noexcept (
22364  )
22365  {
22366  std::swap(m_type, other.m_type);
22367  std::swap(m_value, other.m_value);
22368  assert_invariant();
22369  }
22370 
22389  friend void swap(reference left, reference right) noexcept (
22394  )
22395  {
22396  left.swap(right);
22397  }
22398 
22419  void swap(array_t& other)
22420  {
22421  // swap only works for arrays
22422  if (JSON_HEDLEY_LIKELY(is_array()))
22423  {
22424  std::swap(*(m_value.array), other);
22425  }
22426  else
22427  {
22428  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22429  }
22430  }
22431 
22452  void swap(object_t& other)
22453  {
22454  // swap only works for objects
22455  if (JSON_HEDLEY_LIKELY(is_object()))
22456  {
22457  std::swap(*(m_value.object), other);
22458  }
22459  else
22460  {
22461  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22462  }
22463  }
22464 
22485  void swap(string_t& other)
22486  {
22487  // swap only works for strings
22488  if (JSON_HEDLEY_LIKELY(is_string()))
22489  {
22490  std::swap(*(m_value.string), other);
22491  }
22492  else
22493  {
22494  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22495  }
22496  }
22497 
22518  void swap(binary_t& other)
22519  {
22520  // swap only works for strings
22521  if (JSON_HEDLEY_LIKELY(is_binary()))
22522  {
22523  std::swap(*(m_value.binary), other);
22524  }
22525  else
22526  {
22527  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22528  }
22529  }
22530 
22532  void swap(typename binary_t::container_type& other)
22533  {
22534  // swap only works for strings
22535  if (JSON_HEDLEY_LIKELY(is_binary()))
22536  {
22537  std::swap(*(m_value.binary), other);
22538  }
22539  else
22540  {
22541  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22542  }
22543  }
22544 
22546 
22547  public:
22549  // lexicographical comparison operators //
22551 
22554 
22610  friend bool operator==(const_reference lhs, const_reference rhs) noexcept
22611  {
22612  const auto lhs_type = lhs.type();
22613  const auto rhs_type = rhs.type();
22614 
22615  if (lhs_type == rhs_type)
22616  {
22617  switch (lhs_type)
22618  {
22619  case value_t::array:
22620  return *lhs.m_value.array == *rhs.m_value.array;
22621 
22622  case value_t::object:
22623  return *lhs.m_value.object == *rhs.m_value.object;
22624 
22625  case value_t::null:
22626  return true;
22627 
22628  case value_t::string:
22629  return *lhs.m_value.string == *rhs.m_value.string;
22630 
22631  case value_t::boolean:
22632  return lhs.m_value.boolean == rhs.m_value.boolean;
22633 
22635  return lhs.m_value.number_integer == rhs.m_value.number_integer;
22636 
22638  return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
22639 
22640  case value_t::number_float:
22641  return lhs.m_value.number_float == rhs.m_value.number_float;
22642 
22643  case value_t::binary:
22644  return *lhs.m_value.binary == *rhs.m_value.binary;
22645 
22646  default:
22647  return false;
22648  }
22649  }
22650  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
22651  {
22652  return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
22653  }
22654  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
22655  {
22656  return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
22657  }
22658  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
22659  {
22660  return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
22661  }
22662  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
22663  {
22664  return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
22665  }
22666  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
22667  {
22668  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
22669  }
22670  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
22671  {
22672  return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
22673  }
22674 
22675  return false;
22676  }
22677 
22682  template<typename ScalarType, typename std::enable_if<
22684  friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
22685  {
22686  return lhs == basic_json(rhs);
22687  }
22688 
22693  template<typename ScalarType, typename std::enable_if<
22695  friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
22696  {
22697  return basic_json(lhs) == rhs;
22698  }
22699 
22718  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
22719  {
22720  return !(lhs == rhs);
22721  }
22722 
22727  template<typename ScalarType, typename std::enable_if<
22729  friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
22730  {
22731  return lhs != basic_json(rhs);
22732  }
22733 
22738  template<typename ScalarType, typename std::enable_if<
22740  friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
22741  {
22742  return basic_json(lhs) != rhs;
22743  }
22744 
22771  friend bool operator<(const_reference lhs, const_reference rhs) noexcept
22772  {
22773  const auto lhs_type = lhs.type();
22774  const auto rhs_type = rhs.type();
22775 
22776  if (lhs_type == rhs_type)
22777  {
22778  switch (lhs_type)
22779  {
22780  case value_t::array:
22781  // note parentheses are necessary, see
22782  // https://github.com/nlohmann/json/issues/1530
22783  return (*lhs.m_value.array) < (*rhs.m_value.array);
22784 
22785  case value_t::object:
22786  return (*lhs.m_value.object) < (*rhs.m_value.object);
22787 
22788  case value_t::null:
22789  return false;
22790 
22791  case value_t::string:
22792  return (*lhs.m_value.string) < (*rhs.m_value.string);
22793 
22794  case value_t::boolean:
22795  return (lhs.m_value.boolean) < (rhs.m_value.boolean);
22796 
22798  return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
22799 
22801  return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
22802 
22803  case value_t::number_float:
22804  return (lhs.m_value.number_float) < (rhs.m_value.number_float);
22805 
22806  case value_t::binary:
22807  return (*lhs.m_value.binary) < (*rhs.m_value.binary);
22808 
22809  default:
22810  return false;
22811  }
22812  }
22813  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
22814  {
22815  return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
22816  }
22817  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
22818  {
22819  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
22820  }
22821  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
22822  {
22823  return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
22824  }
22825  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
22826  {
22827  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
22828  }
22829  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
22830  {
22831  return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
22832  }
22833  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
22834  {
22835  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
22836  }
22837 
22838  // We only reach this line if we cannot compare values. In that case,
22839  // we compare types. Note we have to call the operator explicitly,
22840  // because MSVC has problems otherwise.
22841  return operator<(lhs_type, rhs_type);
22842  }
22843 
22848  template<typename ScalarType, typename std::enable_if<
22850  friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
22851  {
22852  return lhs < basic_json(rhs);
22853  }
22854 
22859  template<typename ScalarType, typename std::enable_if<
22861  friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
22862  {
22863  return basic_json(lhs) < rhs;
22864  }
22865 
22885  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
22886  {
22887  return !(rhs < lhs);
22888  }
22889 
22894  template<typename ScalarType, typename std::enable_if<
22896  friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
22897  {
22898  return lhs <= basic_json(rhs);
22899  }
22900 
22905  template<typename ScalarType, typename std::enable_if<
22907  friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
22908  {
22909  return basic_json(lhs) <= rhs;
22910  }
22911 
22931  friend bool operator>(const_reference lhs, const_reference rhs) noexcept
22932  {
22933  return !(lhs <= rhs);
22934  }
22935 
22940  template<typename ScalarType, typename std::enable_if<
22942  friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
22943  {
22944  return lhs > basic_json(rhs);
22945  }
22946 
22951  template<typename ScalarType, typename std::enable_if<
22953  friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
22954  {
22955  return basic_json(lhs) > rhs;
22956  }
22957 
22977  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
22978  {
22979  return !(lhs < rhs);
22980  }
22981 
22986  template<typename ScalarType, typename std::enable_if<
22988  friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
22989  {
22990  return lhs >= basic_json(rhs);
22991  }
22992 
22997  template<typename ScalarType, typename std::enable_if<
22999  friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
23000  {
23001  return basic_json(lhs) >= rhs;
23002  }
23003 
23005 
23007  // serialization //
23009 
23012 
23044  friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
23045  {
23046  // read width member and use it as indentation parameter if nonzero
23047  const bool pretty_print = o.width() > 0;
23048  const auto indentation = pretty_print ? o.width() : 0;
23049 
23050  // reset width to 0 for subsequent calls to this stream
23051  o.width(0);
23052 
23053  // do the actual serialization
23054  serializer s(detail::output_adapter<char>(o), o.fill());
23055  s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
23056  return o;
23057  }
23058 
23067  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
23068  friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
23069  {
23070  return o << j;
23071  }
23072 
23074 
23075 
23077  // deserialization //
23079 
23082 
23134  template<typename InputType>
23135  JSON_HEDLEY_WARN_UNUSED_RESULT
23136  static basic_json parse(InputType&& i,
23137  const parser_callback_t cb = nullptr,
23138  const bool allow_exceptions = true,
23139  const bool ignore_comments = false)
23140  {
23141  basic_json result;
23142  parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
23143  return result;
23144  }
23145 
23172  template<typename IteratorType>
23173  JSON_HEDLEY_WARN_UNUSED_RESULT
23174  static basic_json parse(IteratorType first,
23175  IteratorType last,
23176  const parser_callback_t cb = nullptr,
23177  const bool allow_exceptions = true,
23178  const bool ignore_comments = false)
23179  {
23180  basic_json result;
23181  parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
23182  return result;
23183  }
23184 
23185  JSON_HEDLEY_WARN_UNUSED_RESULT
23188  const parser_callback_t cb = nullptr,
23189  const bool allow_exceptions = true,
23190  const bool ignore_comments = false)
23191  {
23192  basic_json result;
23193  parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
23194  return result;
23195  }
23196 
23227  template<typename InputType>
23228  static bool accept(InputType&& i,
23229  const bool ignore_comments = false)
23230  {
23231  return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
23232  }
23233 
23234  template<typename IteratorType>
23235  static bool accept(IteratorType first, IteratorType last,
23236  const bool ignore_comments = false)
23237  {
23238  return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
23239  }
23240 
23241  JSON_HEDLEY_WARN_UNUSED_RESULT
23243  static bool accept(detail::span_input_adapter&& i,
23244  const bool ignore_comments = false)
23245  {
23246  return parser(i.get(), nullptr, false, ignore_comments).accept(true);
23247  }
23248 
23289  template <typename InputType, typename SAX>
23291  static bool sax_parse(InputType&& i, SAX* sax,
23293  const bool strict = true,
23294  const bool ignore_comments = false)
23295  {
23296  auto ia = detail::input_adapter(std::forward<InputType>(i));
23297  return format == input_format_t::json
23298  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23300  }
23301 
23302  template<class IteratorType, class SAX>
23304  static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
23306  const bool strict = true,
23307  const bool ignore_comments = false)
23308  {
23309  auto ia = detail::input_adapter(std::move(first), std::move(last));
23310  return format == input_format_t::json
23311  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23313  }
23314 
23315  template <typename SAX>
23316  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
23318  static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
23320  const bool strict = true,
23321  const bool ignore_comments = false)
23322  {
23323  auto ia = i.get();
23324  return format == input_format_t::json
23325  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23327  }
23328 
23337  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
23338  friend std::istream& operator<<(basic_json& j, std::istream& i)
23339  {
23340  return operator>>(i, j);
23341  }
23342 
23368  friend std::istream& operator>>(std::istream& i, basic_json& j)
23369  {
23370  parser(detail::input_adapter(i)).parse(false, j);
23371  return i;
23372  }
23373 
23375 
23377  // convenience functions //
23379 
23411  JSON_HEDLEY_RETURNS_NON_NULL
23412  const char* type_name() const noexcept
23413  {
23414  {
23415  switch (m_type)
23416  {
23417  case value_t::null:
23418  return "null";
23419  case value_t::object:
23420  return "object";
23421  case value_t::array:
23422  return "array";
23423  case value_t::string:
23424  return "string";
23425  case value_t::boolean:
23426  return "boolean";
23427  case value_t::binary:
23428  return "binary";
23429  case value_t::discarded:
23430  return "discarded";
23431  default:
23432  return "number";
23433  }
23434  }
23435  }
23436 
23437 
23438  private:
23440  // member variables //
23442 
23444  value_t m_type = value_t::null;
23445 
23448 
23450  // binary serialization/deserialization //
23452 
23455 
23456  public:
23551  static std::vector<uint8_t> to_cbor(const basic_json& j)
23552  {
23553  std::vector<uint8_t> result;
23554  to_cbor(j, result);
23555  return result;
23556  }
23557 
23559  {
23561  }
23562 
23564  {
23566  }
23567 
23646  static std::vector<uint8_t> to_msgpack(const basic_json& j)
23647  {
23648  std::vector<uint8_t> result;
23649  to_msgpack(j, result);
23650  return result;
23651  }
23652 
23654  {
23656  }
23657 
23659  {
23661  }
23662 
23749  static std::vector<uint8_t> to_ubjson(const basic_json& j,
23750  const bool use_size = false,
23751  const bool use_type = false)
23752  {
23753  std::vector<uint8_t> result;
23754  to_ubjson(j, result, use_size, use_type);
23755  return result;
23756  }
23757 
23759  const bool use_size = false, const bool use_type = false)
23760  {
23761  binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
23762  }
23763 
23765  const bool use_size = false, const bool use_type = false)
23766  {
23767  binary_writer<char>(o).write_ubjson(j, use_size, use_type);
23768  }
23769 
23770 
23827  static std::vector<uint8_t> to_bson(const basic_json& j)
23828  {
23829  std::vector<uint8_t> result;
23830  to_bson(j, result);
23831  return result;
23832  }
23833 
23843  {
23845  }
23846 
23851  {
23853  }
23854 
23855 
23958  template<typename InputType>
23959  JSON_HEDLEY_WARN_UNUSED_RESULT
23960  static basic_json from_cbor(InputType&& i,
23961  const bool strict = true,
23962  const bool allow_exceptions = true,
23963  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23964  {
23965  basic_json result;
23967  auto ia = detail::input_adapter(std::forward<InputType>(i));
23968  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23969  return res ? result : basic_json(value_t::discarded);
23970  }
23971 
23975  template<typename IteratorType>
23976  JSON_HEDLEY_WARN_UNUSED_RESULT
23977  static basic_json from_cbor(IteratorType first, IteratorType last,
23978  const bool strict = true,
23979  const bool allow_exceptions = true,
23980  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23981  {
23982  basic_json result;
23984  auto ia = detail::input_adapter(std::move(first), std::move(last));
23985  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23986  return res ? result : basic_json(value_t::discarded);
23987  }
23988 
23989  template<typename T>
23990  JSON_HEDLEY_WARN_UNUSED_RESULT
23992  static basic_json from_cbor(const T* ptr, std::size_t len,
23993  const bool strict = true,
23995  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23996  {
23997  return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
23998  }
23999 
24000 
24001  JSON_HEDLEY_WARN_UNUSED_RESULT
24002  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
24004  const bool strict = true,
24005  const bool allow_exceptions = true,
24006  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24007  {
24008  basic_json result;
24010  auto ia = i.get();
24011  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
24012  return res ? result : basic_json(value_t::discarded);
24013  }
24014 
24101  template<typename InputType>
24102  JSON_HEDLEY_WARN_UNUSED_RESULT
24103  static basic_json from_msgpack(InputType&& i,
24104  const bool strict = true,
24105  const bool allow_exceptions = true)
24106  {
24107  basic_json result;
24108  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24109  auto ia = detail::input_adapter(std::forward<InputType>(i));
24110  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24111  return res ? result : basic_json(value_t::discarded);
24112  }
24113 
24117  template<typename IteratorType>
24118  JSON_HEDLEY_WARN_UNUSED_RESULT
24119  static basic_json from_msgpack(IteratorType first, IteratorType last,
24120  const bool strict = true,
24121  const bool allow_exceptions = true)
24122  {
24123  basic_json result;
24124  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24125  auto ia = detail::input_adapter(std::move(first), std::move(last));
24126  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24127  return res ? result : basic_json(value_t::discarded);
24128  }
24129 
24130 
24131  template<typename T>
24132  JSON_HEDLEY_WARN_UNUSED_RESULT
24133  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
24134  static basic_json from_msgpack(const T* ptr, std::size_t len,
24135  const bool strict = true,
24136  const bool allow_exceptions = true)
24137  {
24138  return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
24139  }
24140 
24141  JSON_HEDLEY_WARN_UNUSED_RESULT
24142  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
24143  static basic_json from_msgpack(detail::span_input_adapter&& i,
24144  const bool strict = true,
24145  const bool allow_exceptions = true)
24146  {
24147  basic_json result;
24148  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24149  auto ia = i.get();
24150  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24151  return res ? result : basic_json(value_t::discarded);
24152  }
24153 
24154 
24217  template<typename InputType>
24218  JSON_HEDLEY_WARN_UNUSED_RESULT
24219  static basic_json from_ubjson(InputType&& i,
24220  const bool strict = true,
24221  const bool allow_exceptions = true)
24222  {
24223  basic_json result;
24224  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24225  auto ia = detail::input_adapter(std::forward<InputType>(i));
24226  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24227  return res ? result : basic_json(value_t::discarded);
24228  }
24229 
24233  template<typename IteratorType>
24234  JSON_HEDLEY_WARN_UNUSED_RESULT
24235  static basic_json from_ubjson(IteratorType first, IteratorType last,
24236  const bool strict = true,
24237  const bool allow_exceptions = true)
24238  {
24239  basic_json result;
24240  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24241  auto ia = detail::input_adapter(std::move(first), std::move(last));
24242  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24243  return res ? result : basic_json(value_t::discarded);
24244  }
24245 
24246  template<typename T>
24247  JSON_HEDLEY_WARN_UNUSED_RESULT
24248  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
24249  static basic_json from_ubjson(const T* ptr, std::size_t len,
24250  const bool strict = true,
24251  const bool allow_exceptions = true)
24252  {
24253  return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
24254  }
24255 
24256  JSON_HEDLEY_WARN_UNUSED_RESULT
24257  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
24258  static basic_json from_ubjson(detail::span_input_adapter&& i,
24259  const bool strict = true,
24260  const bool allow_exceptions = true)
24261  {
24262  basic_json result;
24263  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24264  auto ia = i.get();
24265  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24266  return res ? result : basic_json(value_t::discarded);
24267  }
24268 
24269 
24330  template<typename InputType>
24331  JSON_HEDLEY_WARN_UNUSED_RESULT
24332  static basic_json from_bson(InputType&& i,
24333  const bool strict = true,
24334  const bool allow_exceptions = true)
24335  {
24336  basic_json result;
24337  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24338  auto ia = detail::input_adapter(std::forward<InputType>(i));
24339  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24340  return res ? result : basic_json(value_t::discarded);
24341  }
24342 
24346  template<typename IteratorType>
24347  JSON_HEDLEY_WARN_UNUSED_RESULT
24348  static basic_json from_bson(IteratorType first, IteratorType last,
24349  const bool strict = true,
24350  const bool allow_exceptions = true)
24351  {
24352  basic_json result;
24353  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24354  auto ia = detail::input_adapter(std::move(first), std::move(last));
24355  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24356  return res ? result : basic_json(value_t::discarded);
24357  }
24358 
24359  template<typename T>
24360  JSON_HEDLEY_WARN_UNUSED_RESULT
24361  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
24362  static basic_json from_bson(const T* ptr, std::size_t len,
24363  const bool strict = true,
24364  const bool allow_exceptions = true)
24365  {
24366  return from_bson(ptr, ptr + len, strict, allow_exceptions);
24367  }
24368 
24369  JSON_HEDLEY_WARN_UNUSED_RESULT
24370  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
24371  static basic_json from_bson(detail::span_input_adapter&& i,
24372  const bool strict = true,
24373  const bool allow_exceptions = true)
24374  {
24375  basic_json result;
24376  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24377  auto ia = i.get();
24378  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24379  return res ? result : basic_json(value_t::discarded);
24380  }
24382 
24384  // JSON Pointer support //
24386 
24389 
24423  reference operator[](const json_pointer& ptr)
24424  {
24425  return ptr.get_unchecked(this);
24426  }
24427 
24451  const_reference operator[](const json_pointer& ptr) const
24452  {
24453  return ptr.get_unchecked(this);
24454  }
24455 
24494  reference at(const json_pointer& ptr)
24495  {
24496  return ptr.get_checked(this);
24497  }
24498 
24537  const_reference at(const json_pointer& ptr) const
24538  {
24539  return ptr.get_checked(this);
24540  }
24541 
24564  basic_json flatten() const
24565  {
24566  basic_json result(value_t::object);
24567  json_pointer::flatten("", *this, result);
24568  return result;
24569  }
24570 
24601  basic_json unflatten() const
24602  {
24603  return json_pointer::unflatten(*this);
24604  }
24605 
24607 
24609  // JSON Patch functions //
24611 
24614 
24662  basic_json patch(const basic_json& json_patch) const
24663  {
24664  // make a working copy to apply the patch to
24665  basic_json result = *this;
24666 
24667  // the valid JSON Patch operations
24668  enum class patch_operations {add, remove, replace, move, copy, test, invalid};
24669 
24670  const auto get_op = [](const std::string & op)
24671  {
24672  if (op == "add")
24673  {
24674  return patch_operations::add;
24675  }
24676  if (op == "remove")
24677  {
24678  return patch_operations::remove;
24679  }
24680  if (op == "replace")
24681  {
24682  return patch_operations::replace;
24683  }
24684  if (op == "move")
24685  {
24686  return patch_operations::move;
24687  }
24688  if (op == "copy")
24689  {
24690  return patch_operations::copy;
24691  }
24692  if (op == "test")
24693  {
24694  return patch_operations::test;
24695  }
24696 
24697  return patch_operations::invalid;
24698  };
24699 
24700  // wrapper for "add" operation; add value at ptr
24701  const auto operation_add = [&result](json_pointer & ptr, basic_json val)
24702  {
24703  // adding to the root of the target document means replacing it
24704  if (ptr.empty())
24705  {
24706  result = val;
24707  return;
24708  }
24709 
24710  // make sure the top element of the pointer exists
24711  json_pointer top_pointer = ptr.top();
24712  if (top_pointer != ptr)
24713  {
24714  result.at(top_pointer);
24715  }
24716 
24717  // get reference to parent of JSON pointer ptr
24718  const auto last_path = ptr.back();
24719  ptr.pop_back();
24720  basic_json& parent = result[ptr];
24721 
24722  switch (parent.m_type)
24723  {
24724  case value_t::null:
24725  case value_t::object:
24726  {
24727  // use operator[] to add value
24728  parent[last_path] = val;
24729  break;
24730  }
24731 
24732  case value_t::array:
24733  {
24734  if (last_path == "-")
24735  {
24736  // special case: append to back
24737  parent.push_back(val);
24738  }
24739  else
24740  {
24741  const auto idx = json_pointer::array_index(last_path);
24742  if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
24743  {
24744  // avoid undefined behavior
24745  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
24746  }
24747 
24748  // default case: insert add offset
24749  parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
24750  }
24751  break;
24752  }
24753 
24754  // if there exists a parent it cannot be primitive
24755  default: // LCOV_EXCL_LINE
24756  JSON_ASSERT(false); // LCOV_EXCL_LINE
24757  }
24758  };
24759 
24760  // wrapper for "remove" operation; remove value at ptr
24761  const auto operation_remove = [&result](json_pointer & ptr)
24762  {
24763  // get reference to parent of JSON pointer ptr
24764  const auto last_path = ptr.back();
24765  ptr.pop_back();
24766  basic_json& parent = result.at(ptr);
24767 
24768  // remove child
24769  if (parent.is_object())
24770  {
24771  // perform range check
24772  auto it = parent.find(last_path);
24773  if (JSON_HEDLEY_LIKELY(it != parent.end()))
24774  {
24775  parent.erase(it);
24776  }
24777  else
24778  {
24779  JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
24780  }
24781  }
24782  else if (parent.is_array())
24783  {
24784  // note erase performs range check
24785  parent.erase(json_pointer::array_index(last_path));
24786  }
24787  };
24788 
24789  // type check: top level value must be an array
24790  if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
24791  {
24792  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
24793  }
24794 
24795  // iterate and apply the operations
24796  for (const auto& val : json_patch)
24797  {
24798  // wrapper to get a value for an operation
24799  const auto get_value = [&val](const std::string & op,
24800  const std::string & member,
24801  bool string_type) -> basic_json &
24802  {
24803  // find value
24804  auto it = val.m_value.object->find(member);
24805 
24806  // context-sensitive error message
24807  const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
24808 
24809  // check if desired value is present
24810  if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
24811  {
24812  JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
24813  }
24814 
24815  // check if result is of type string
24816  if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
24817  {
24818  JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
24819  }
24820 
24821  // no error: return value
24822  return it->second;
24823  };
24824 
24825  // type check: every element of the array must be an object
24826  if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
24827  {
24828  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
24829  }
24830 
24831  // collect mandatory members
24832  const auto op = get_value("op", "op", true).template get<std::string>();
24833  const auto path = get_value(op, "path", true).template get<std::string>();
24834  json_pointer ptr(path);
24835 
24836  switch (get_op(op))
24837  {
24838  case patch_operations::add:
24839  {
24840  operation_add(ptr, get_value("add", "value", false));
24841  break;
24842  }
24843 
24844  case patch_operations::remove:
24845  {
24846  operation_remove(ptr);
24847  break;
24848  }
24849 
24850  case patch_operations::replace:
24851  {
24852  // the "path" location must exist - use at()
24853  result.at(ptr) = get_value("replace", "value", false);
24854  break;
24855  }
24856 
24857  case patch_operations::move:
24858  {
24859  const auto from_path = get_value("move", "from", true).template get<std::string>();
24860  json_pointer from_ptr(from_path);
24861 
24862  // the "from" location must exist - use at()
24863  basic_json v = result.at(from_ptr);
24864 
24865  // The move operation is functionally identical to a
24866  // "remove" operation on the "from" location, followed
24867  // immediately by an "add" operation at the target
24868  // location with the value that was just removed.
24869  operation_remove(from_ptr);
24870  operation_add(ptr, v);
24871  break;
24872  }
24873 
24874  case patch_operations::copy:
24875  {
24876  const auto from_path = get_value("copy", "from", true).template get<std::string>();
24877  const json_pointer from_ptr(from_path);
24878 
24879  // the "from" location must exist - use at()
24880  basic_json v = result.at(from_ptr);
24881 
24882  // The copy is functionally identical to an "add"
24883  // operation at the target location using the value
24884  // specified in the "from" member.
24885  operation_add(ptr, v);
24886  break;
24887  }
24888 
24889  case patch_operations::test:
24890  {
24891  bool success = false;
24892  JSON_TRY
24893  {
24894  // check if "value" matches the one at "path"
24895  // the "path" location must exist - use at()
24896  success = (result.at(ptr) == get_value("test", "value", false));
24897  }
24898  JSON_INTERNAL_CATCH (out_of_range&)
24899  {
24900  // ignore out of range errors: success remains false
24901  }
24902 
24903  // throw an exception if test fails
24904  if (JSON_HEDLEY_UNLIKELY(!success))
24905  {
24906  JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
24907  }
24908 
24909  break;
24910  }
24911 
24912  default:
24913  {
24914  // op must be "add", "remove", "replace", "move", "copy", or
24915  // "test"
24916  JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
24917  }
24918  }
24919  }
24920 
24921  return result;
24922  }
24923 
24957  JSON_HEDLEY_WARN_UNUSED_RESULT
24958  static basic_json diff(const basic_json& source, const basic_json& target,
24959  const std::string& path = "")
24960  {
24961  // the patch
24962  basic_json result(value_t::array);
24963 
24964  // if the values are the same, return empty patch
24965  if (source == target)
24966  {
24967  return result;
24968  }
24969 
24970  if (source.type() != target.type())
24971  {
24972  // different types: replace value
24973  result.push_back(
24974  {
24975  {"op", "replace"}, {"path", path}, {"value", target}
24976  });
24977  return result;
24978  }
24979 
24980  switch (source.type())
24981  {
24982  case value_t::array:
24983  {
24984  // first pass: traverse common elements
24985  std::size_t i = 0;
24986  while (i < source.size() && i < target.size())
24987  {
24988  // recursive call to compare array values at index i
24989  auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
24990  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24991  ++i;
24992  }
24993 
24994  // i now reached the end of at least one array
24995  // in a second pass, traverse the remaining elements
24996 
24997  // remove my remaining elements
24998  const auto end_index = static_cast<difference_type>(result.size());
24999  while (i < source.size())
25000  {
25001  // add operations in reverse order to avoid invalid
25002  // indices
25003  result.insert(result.begin() + end_index, object(
25004  {
25005  {"op", "remove"},
25006  {"path", path + "/" + std::to_string(i)}
25007  }));
25008  ++i;
25009  }
25010 
25011  // add other remaining elements
25012  while (i < target.size())
25013  {
25014  result.push_back(
25015  {
25016  {"op", "add"},
25017  {"path", path + "/-"},
25018  {"value", target[i]}
25019  });
25020  ++i;
25021  }
25022 
25023  break;
25024  }
25025 
25026  case value_t::object:
25027  {
25028  // first pass: traverse this object's elements
25029  for (auto it = source.cbegin(); it != source.cend(); ++it)
25030  {
25031  // escape the key name to be used in a JSON patch
25032  const auto key = json_pointer::escape(it.key());
25033 
25034  if (target.find(it.key()) != target.end())
25035  {
25036  // recursive call to compare object values at key it
25037  auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
25038  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
25039  }
25040  else
25041  {
25042  // found a key that is not in o -> remove it
25043  result.push_back(object(
25044  {
25045  {"op", "remove"}, {"path", path + "/" + key}
25046  }));
25047  }
25048  }
25049 
25050  // second pass: traverse other object's elements
25051  for (auto it = target.cbegin(); it != target.cend(); ++it)
25052  {
25053  if (source.find(it.key()) == source.end())
25054  {
25055  // found a key that is not in this -> add it
25056  const auto key = json_pointer::escape(it.key());
25057  result.push_back(
25058  {
25059  {"op", "add"}, {"path", path + "/" + key},
25060  {"value", it.value()}
25061  });
25062  }
25063  }
25064 
25065  break;
25066  }
25067 
25068  default:
25069  {
25070  // both primitive type: replace value
25071  result.push_back(
25072  {
25073  {"op", "replace"}, {"path", path}, {"value", target}
25074  });
25075  break;
25076  }
25077  }
25078 
25079  return result;
25080  }
25081 
25083 
25085  // JSON Merge Patch functions //
25087 
25090 
25133  void merge_patch(const basic_json& apply_patch)
25134  {
25135  if (apply_patch.is_object())
25136  {
25137  if (!is_object())
25138  {
25139  *this = object();
25140  }
25141  for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
25142  {
25143  if (it.value().is_null())
25144  {
25145  erase(it.key());
25146  }
25147  else
25148  {
25149  operator[](it.key()).merge_patch(it.value());
25150  }
25151  }
25152  }
25153  else
25154  {
25155  *this = apply_patch;
25156  }
25157  }
25158 
25160 };
25161 
25171 NLOHMANN_BASIC_JSON_TPL_DECLARATION
25172 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
25173 {
25174  return j.dump();
25175 }
25176 } // namespace nlohmann
25177 
25179 // nonmember support //
25181 
25182 // specialization of std::swap, and std::hash
25183 namespace std
25184 {
25185 
25187 template<>
25189 {
25195  std::size_t operator()(const nlohmann::json& j) const
25196  {
25197  return nlohmann::detail::hash(j);
25198  }
25199 };
25200 
25204 template<>
25206 {
25212  nlohmann::detail::value_t rhs) const noexcept
25213  {
25214  return nlohmann::detail::operator<(lhs, rhs);
25215  }
25216 };
25217 
25218 // C++20 prohibit function specialization in the std namespace.
25219 #ifndef JSON_HAS_CPP_20
25220 
25226 template<>
25227 inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
25230  )
25231 {
25232  j1.swap(j2);
25233 }
25234 
25235 #endif
25236 
25237 } // namespace std
25238 
25253 inline nlohmann::json operator "" _json(const char* s, std::size_t n)
25254 {
25255  return nlohmann::json::parse(s, s + n);
25256 }
25257 
25272 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
25273 {
25274  return nlohmann::json::json_pointer(std::string(s, n));
25275 }
25276 
25277 // #include <nlohmann/detail/macro_unscope.hpp>
25278 
25279 
25280 // restore GCC/clang diagnostic settings
25281 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
25282  #pragma GCC diagnostic pop
25283 #endif
25284 #if defined(__clang__)
25285  #pragma GCC diagnostic pop
25286 #endif
25287 
25288 // clean up
25289 #undef JSON_ASSERT
25290 #undef JSON_INTERNAL_CATCH
25291 #undef JSON_CATCH
25292 #undef JSON_THROW
25293 #undef JSON_TRY
25294 #undef JSON_HAS_CPP_14
25295 #undef JSON_HAS_CPP_17
25296 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
25297 #undef NLOHMANN_BASIC_JSON_TPL
25298 #undef JSON_EXPLICIT
25299 
25300 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
25301 #undef JSON_HEDLEY_ALWAYS_INLINE
25302 #undef JSON_HEDLEY_ARM_VERSION
25303 #undef JSON_HEDLEY_ARM_VERSION_CHECK
25304 #undef JSON_HEDLEY_ARRAY_PARAM
25305 #undef JSON_HEDLEY_ASSUME
25306 #undef JSON_HEDLEY_BEGIN_C_DECLS
25307 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
25308 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
25309 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
25310 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
25311 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
25312 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
25313 #undef JSON_HEDLEY_CLANG_HAS_WARNING
25314 #undef JSON_HEDLEY_COMPCERT_VERSION
25315 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
25316 #undef JSON_HEDLEY_CONCAT
25317 #undef JSON_HEDLEY_CONCAT3
25318 #undef JSON_HEDLEY_CONCAT3_EX
25319 #undef JSON_HEDLEY_CONCAT_EX
25320 #undef JSON_HEDLEY_CONST
25321 #undef JSON_HEDLEY_CONSTEXPR
25322 #undef JSON_HEDLEY_CONST_CAST
25323 #undef JSON_HEDLEY_CPP_CAST
25324 #undef JSON_HEDLEY_CRAY_VERSION
25325 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
25326 #undef JSON_HEDLEY_C_DECL
25327 #undef JSON_HEDLEY_DEPRECATED
25328 #undef JSON_HEDLEY_DEPRECATED_FOR
25329 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
25330 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
25331 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
25332 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
25333 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
25334 #undef JSON_HEDLEY_DIAGNOSTIC_POP
25335 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
25336 #undef JSON_HEDLEY_DMC_VERSION
25337 #undef JSON_HEDLEY_DMC_VERSION_CHECK
25338 #undef JSON_HEDLEY_EMPTY_BASES
25339 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
25340 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
25341 #undef JSON_HEDLEY_END_C_DECLS
25342 #undef JSON_HEDLEY_FLAGS
25343 #undef JSON_HEDLEY_FLAGS_CAST
25344 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
25345 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
25346 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
25347 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
25348 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
25349 #undef JSON_HEDLEY_GCC_HAS_FEATURE
25350 #undef JSON_HEDLEY_GCC_HAS_WARNING
25351 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
25352 #undef JSON_HEDLEY_GCC_VERSION
25353 #undef JSON_HEDLEY_GCC_VERSION_CHECK
25354 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
25355 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
25356 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
25357 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
25358 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
25359 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
25360 #undef JSON_HEDLEY_GNUC_HAS_WARNING
25361 #undef JSON_HEDLEY_GNUC_VERSION
25362 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
25363 #undef JSON_HEDLEY_HAS_ATTRIBUTE
25364 #undef JSON_HEDLEY_HAS_BUILTIN
25365 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
25366 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
25367 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
25368 #undef JSON_HEDLEY_HAS_EXTENSION
25369 #undef JSON_HEDLEY_HAS_FEATURE
25370 #undef JSON_HEDLEY_HAS_WARNING
25371 #undef JSON_HEDLEY_IAR_VERSION
25372 #undef JSON_HEDLEY_IAR_VERSION_CHECK
25373 #undef JSON_HEDLEY_IBM_VERSION
25374 #undef JSON_HEDLEY_IBM_VERSION_CHECK
25375 #undef JSON_HEDLEY_IMPORT
25376 #undef JSON_HEDLEY_INLINE
25377 #undef JSON_HEDLEY_INTEL_VERSION
25378 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
25379 #undef JSON_HEDLEY_IS_CONSTANT
25380 #undef JSON_HEDLEY_IS_CONSTEXPR_
25381 #undef JSON_HEDLEY_LIKELY
25382 #undef JSON_HEDLEY_MALLOC
25383 #undef JSON_HEDLEY_MESSAGE
25384 #undef JSON_HEDLEY_MSVC_VERSION
25385 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
25386 #undef JSON_HEDLEY_NEVER_INLINE
25387 #undef JSON_HEDLEY_NON_NULL
25388 #undef JSON_HEDLEY_NO_ESCAPE
25389 #undef JSON_HEDLEY_NO_RETURN
25390 #undef JSON_HEDLEY_NO_THROW
25391 #undef JSON_HEDLEY_NULL
25392 #undef JSON_HEDLEY_PELLES_VERSION
25393 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
25394 #undef JSON_HEDLEY_PGI_VERSION
25395 #undef JSON_HEDLEY_PGI_VERSION_CHECK
25396 #undef JSON_HEDLEY_PREDICT
25397 #undef JSON_HEDLEY_PRINTF_FORMAT
25398 #undef JSON_HEDLEY_PRIVATE
25399 #undef JSON_HEDLEY_PUBLIC
25400 #undef JSON_HEDLEY_PURE
25401 #undef JSON_HEDLEY_REINTERPRET_CAST
25402 #undef JSON_HEDLEY_REQUIRE
25403 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
25404 #undef JSON_HEDLEY_REQUIRE_MSG
25405 #undef JSON_HEDLEY_RESTRICT
25406 #undef JSON_HEDLEY_RETURNS_NON_NULL
25407 #undef JSON_HEDLEY_SENTINEL
25408 #undef JSON_HEDLEY_STATIC_ASSERT
25409 #undef JSON_HEDLEY_STATIC_CAST
25410 #undef JSON_HEDLEY_STRINGIFY
25411 #undef JSON_HEDLEY_STRINGIFY_EX
25412 #undef JSON_HEDLEY_SUNPRO_VERSION
25413 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
25414 #undef JSON_HEDLEY_TINYC_VERSION
25415 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
25416 #undef JSON_HEDLEY_TI_ARMCL_VERSION
25417 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
25418 #undef JSON_HEDLEY_TI_CL2000_VERSION
25419 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
25420 #undef JSON_HEDLEY_TI_CL430_VERSION
25421 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
25422 #undef JSON_HEDLEY_TI_CL6X_VERSION
25423 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
25424 #undef JSON_HEDLEY_TI_CL7X_VERSION
25425 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
25426 #undef JSON_HEDLEY_TI_CLPRU_VERSION
25427 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
25428 #undef JSON_HEDLEY_TI_VERSION
25429 #undef JSON_HEDLEY_TI_VERSION_CHECK
25430 #undef JSON_HEDLEY_UNAVAILABLE
25431 #undef JSON_HEDLEY_UNLIKELY
25432 #undef JSON_HEDLEY_UNPREDICTABLE
25433 #undef JSON_HEDLEY_UNREACHABLE
25434 #undef JSON_HEDLEY_UNREACHABLE_RETURN
25435 #undef JSON_HEDLEY_VERSION
25436 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
25437 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
25438 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
25439 #undef JSON_HEDLEY_VERSION_ENCODE
25440 #undef JSON_HEDLEY_WARNING
25441 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
25442 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
25443 #undef JSON_HEDLEY_FALL_THROUGH
25444 
25445 
25446 
25447 #endif // INCLUDE_NLOHMANN_JSON_HPP_
a class to store JSON values
Definition: json.h:16658
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init, std::uint8_t subtype)
explicitly create a binary array (with subtype)
Definition: json.h:18224
constexpr auto get() const noexcept -> decltype(std::declval< const basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
Definition: json.h:19627
void insert(const_iterator first, const_iterator last)
inserts elements
Definition: json.h:22215
detail::parser_callback_t< basic_json > parser_callback_t
per-element parser callback type
Definition: json.h:17789
bool contains(KeyT &&key) const
check the existence of an element in a JSON object
Definition: json.h:20896
const_reverse_iterator crbegin() const noexcept
returns a const reverse iterator to the last element
Definition: json.h:21181
SAX input_format_t const bool const bool ignore_comments
Definition: json.h:23294
JSON_HEDLEY_NON_NULL(2) reference operator[](T *key)
access specified object element
Definition: json.h:20161
basic_json get() const
get special-case overload
Definition: json.h:19336
JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy< iterator > iterator_wrapper(reference ref) noexcept
wrapper to access iterator member functions in range-based for
Definition: json.h:21273
JSON_HEDLEY_WARN_UNUSED_RESULT std::size_t len
Definition: json.h:23992
ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const
access specified object element with default value
Definition: json.h:20279
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
Definition: json.h:19029
NumberIntegerType number_integer_t
a type for a number (integer)
Definition: json.h:17188
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
comparison: equal
Definition: json.h:22610
friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
comparison: greater than
Definition: json.h:22953
NLOHMANN_BASIC_JSON_TPL basic_json_t
workaround type for MSVC
Definition: json.h:16678
constexpr const number_integer_t * get_impl_ptr(const number_integer_t *) const noexcept
get a pointer to the value (integer number)
Definition: json.h:19248
ReferenceType get_ref()
get a reference value (implicit)
Definition: json.h:19661
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json parse(InputType &&i, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a compatible input
Definition: json.h:23136
reference emplace_back(Args &&... args)
add an object to an array
Definition: json.h:21901
const_iterator find(KeyT &&key) const
find an element in a JSON object
Definition: json.h:20829
basic_json(const value_t v)
create an empty value with a given type
Definition: json.h:17830
static void to_ubjson(const basic_json &j, detail::output_adapter< uint8_t > o, const bool use_size=false, const bool use_type=false)
Definition: json.h:23758
basic_json & operator=(basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
copy assignment
Definition: json.h:18662
size_type max_size() const noexcept
returns the maximum possible number of elements
Definition: json.h:21565
basic_json(CompatibleType &&val) noexcept(noexcept(JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
create a JSON value
Definition: json.h:17927
detail::input_format_t input_format_t
Definition: json.h:16726
value_type & reference
the type of an element reference
Definition: json.h:16767
void erase(const size_type idx)
remove element from a JSON array given an index
Definition: json.h:20759
const_reverse_iterator crend() const noexcept
returns a const reverse iterator to one before the first
Definition: json.h:21210
detail::out_of_range out_of_range
exception indicating access out of the defined range
Definition: json.h:16747
const_reference at(const typename object_t::key_type &key) const
access specified object element with bounds checking
Definition: json.h:19942
reference at(const typename object_t::key_type &key)
access specified object element with bounds checking
Definition: json.h:19891
iterator begin() noexcept
returns an iterator to the first element
Definition: json.h:20966
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
Definition: json.h:18406
static std::vector< uint8_t > to_ubjson(const basic_json &j, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
Definition: json.h:23749
boolean_t * get_impl_ptr(boolean_t *) noexcept
get a pointer to the value (boolean)
Definition: json.h:19230
basic_json(const JsonRef &ref)
Definition: json.h:18509
static void to_cbor(const basic_json &j, detail::output_adapter< uint8_t > o)
Definition: json.h:23558
string_t * get_impl_ptr(string_t *) noexcept
get a pointer to the value (string)
Definition: json.h:19218
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json array(initializer_list_t init={})
explicitly create an array from an initializer list
Definition: json.h:18270
const_reverse_iterator rend() const noexcept
returns a const reverse iterator to one before the first
Definition: json.h:21152
const_iterator cend() const noexcept
returns a const iterator to one past the last element
Definition: json.h:21077
reference back()
access the last element
Definition: json.h:20449
static bool accept(InputType &&i, const bool ignore_comments=false)
check if the input is valid JSON
Definition: json.h:23228
StringType string_t
a type for a string
Definition: json.h:17090
size_type size() const noexcept
returns the number of elements
Definition: json.h:21494
void push_back(const basic_json &val)
add an object to an array
Definition: json.h:21748
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json meta()
returns version information on the library
Definition: json.h:16831
ValueType value(const json_pointer &ptr, const ValueType &default_value) const
access specified object element via JSON Pointer with default value
Definition: json.h:20351
void update(const_reference j)
updates a JSON object from another object, overwriting existing keys
Definition: json.h:22257
constexpr const binary_t * get_impl_ptr(const binary_t *) const noexcept
get a pointer to the value (binary)
Definition: json.h:19284
std::size_t size_type
a type to represent container sizes
Definition: json.h:16774
array_t * get_impl_ptr(array_t *) noexcept
get a pointer to the value (array)
Definition: json.h:19206
std::ptrdiff_t difference_type
a type to represent differences between iterators
Definition: json.h:16772
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init)
explicitly create a binary array (without subtype)
Definition: json.h:18167
reference operator[](const typename object_t::key_type &key)
access specified object element
Definition: json.h:20072
number_float_t * get_impl_ptr(number_float_t *) noexcept
get a pointer to the value (floating-point number)
Definition: json.h:19266
reference operator+=(basic_json &&val)
add an object to an array
Definition: json.h:21738
basic_json(const BasicJsonType &val)
create a JSON value from an existing one
Definition: json.h:17964
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
Definition: json.h:16782
friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
comparison: greater than
Definition: json.h:22942
SAX input_format_t const bool const bool class SAX IteratorType last
Definition: json.h:23304
typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
Definition: json.h:16780
JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr+len)) static basic_json parse(detail
Definition: json.h:23186
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(InputType &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
create a JSON value from an input in CBOR format
Definition: json.h:23960
BooleanType boolean_t
a type for a boolean
Definition: json.h:17116
void push_back(initializer_list_t init)
add an object to an object
Definition: json.h:21853
JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream &, const basic_json &)) friend std
serialize to stream
Definition: json.h:23067
boolean_t get_impl(boolean_t *) const
get a boolean (explicit)
Definition: json.h:19183
string_t dump(const int indent=-1, const char indent_char=' ', const bool ensure_ascii=false, const error_handler_t error_handler=error_handler_t::strict) const
serialization
Definition: json.h:18759
static bool accept(IteratorType first, IteratorType last, const bool ignore_comments=false)
Definition: json.h:23235
IteratorType erase(IteratorType pos)
remove element given an iterator
Definition: json.h:20516
constexpr bool is_structured() const noexcept
return whether type is structured
Definition: json.h:18870
const_iterator begin() const noexcept
returns a const iterator to the first element
Definition: json.h:20976
iteration_proxy< const_iterator > items() const noexcept
helper to access iterator member functions in range-based for
Definition: json.h:21364
reference at(size_type idx)
access specified array element with bounds checking
Definition: json.h:19793
JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr+len)) static bool accept(detail
Definition: json.h:23242
reference front()
access the first element
Definition: json.h:20405
constexpr bool is_primitive() const noexcept
return whether type is primitive
Definition: json.h:18843
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
Definition: json.h:19001
detail::cbor_tag_handler_t cbor_tag_handler_t
how to treat CBOR tags
Definition: json.h:16722
static void to_cbor(const basic_json &j, detail::output_adapter< char > o)
Definition: json.h:23563
void swap(object_t &other)
exchanges the values
Definition: json.h:22452
constexpr bool is_object() const noexcept
return whether value is an object
Definition: json.h:19051
const_reference front() const
access the first element
Definition: json.h:20413
binary_t * get_impl_ptr(binary_t *) noexcept
get a pointer to the value (binary)
Definition: json.h:19278
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
Definition: json.h:18812
NumberFloatType number_float_t
a type for a number (floating-point)
Definition: json.h:17327
json_reverse_iterator< typename basic_json::iterator > reverse_iterator
a reverse iterator for a basic_json container
Definition: json.h:16789
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
comparison: less than or equal
Definition: json.h:22885
bool empty() const noexcept
checks whether the container is empty.
Definition: json.h:21421
constexpr const number_unsigned_t * get_impl_ptr(const number_unsigned_t *) const noexcept
get a pointer to the value (unsigned number)
Definition: json.h:19260
friend std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
Definition: json.h:23044
friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
comparison: greater than or equal
Definition: json.h:22999
basic_json(const basic_json &other)
copy constructor
Definition: json.h:18536
constexpr const boolean_t * get_impl_ptr(const boolean_t *) const noexcept
get a pointer to the value (boolean)
Definition: json.h:19236
~basic_json() noexcept
destructor
Definition: json.h:18695
BasicJsonType get() const
get special-case overload
Definition: json.h:19359
basic_json(basic_json &&other) noexcept
move constructor
Definition: json.h:18625
static void to_bson(const basic_json &j, detail::output_adapter< uint8_t > o)
Serializes the given JSON object j to BSON and forwards the corresponding BSON-representation to the ...
Definition: json.h:23842
friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
comparison: greater than or equal
Definition: json.h:22988
const char *default_value const
Definition: json.h:20376
JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr+len)) static basic_json from_cbor(const T *ptr
static void to_ubjson(const basic_json &j, detail::output_adapter< char > o, const bool use_size=false, const bool use_type=false)
Definition: json.h:23764
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
comparison: not equal
Definition: json.h:22718
iterator insert(const_iterator pos, size_type cnt, const basic_json &val)
inserts elements
Definition: json.h:22073
json_value m_value
the value of the current element
Definition: json.h:23447
void swap(typename binary_t::container_type &other)
Definition: json.h:22532
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
comparison: greater than or equal
Definition: json.h:22977
constexpr const object_t * get_impl_ptr(const object_t *) const noexcept
get a pointer to the value (object)
Definition: json.h:19200
void swap(array_t &other)
exchanges the values
Definition: json.h:22419
friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
comparison: less than
Definition: json.h:22850
reverse_iterator rend() noexcept
returns an iterator to the reverse-end
Definition: json.h:21144
friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
comparison: less than or equal
Definition: json.h:22896
ReferenceType get_ref() const
get a reference value (implicit)
Definition: json.h:19674
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
inserts elements
Definition: json.h:22121
auto get() noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
Definition: json.h:19615
const_iterator end() const noexcept
returns a const iterator to one past the last element
Definition: json.h:21047
auto get_ptr() noexcept -> decltype(std::declval< basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
Definition: json.h:19567
iterator insert(const_iterator pos, initializer_list_t ilist)
inserts elements
Definition: json.h:22174
ArrayType< basic_json, AllocatorType< basic_json > > array_t
a type for an array
Definition: json.h:17037
Array get_to(T(&v)[N]) const noexcept(noexcept(JSONSerializer< Array >::from_json(std::declval< const basic_json_t & >(), v)))
Definition: json.h:19530
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
comparison: greater than
Definition: json.h:22931
IteratorType erase(IteratorType first, IteratorType last)
remove elements given an iterator range
Definition: json.h:20629
object_t * get_impl_ptr(object_t *) noexcept
get a pointer to the value (object)
Definition: json.h:19194
JSON_HEDLEY_NON_NULL(2) const _reference operator[](T *key) const
read-only access specified object element
Definition: json.h:20212
ValueType get() const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), std::declval< ValueType & >())))
get a value (explicit)
Definition: json.h:19409
constexpr bool is_boolean() const noexcept
return whether value is a boolean
Definition: json.h:18914
iteration_proxy< iterator > items() noexcept
helper to access iterator member functions in range-based for
Definition: json.h:21356
iterator end() noexcept
returns an iterator to one past the last element
Definition: json.h:21037
void swap(reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
Definition: json.h:22359
void clear() noexcept
clears the contents
Definition: json.h:21636
constexpr bool is_binary() const noexcept
return whether value is a binary array
Definition: json.h:19117
static std::vector< uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
Definition: json.h:23646
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json object(initializer_list_t init={})
explicitly create an object from an initializer list
Definition: json.h:18314
constexpr const number_float_t * get_impl_ptr(const number_float_t *) const noexcept
get a pointer to the value (floating-point number)
Definition: json.h:19272
iterator insert(const_iterator pos, basic_json &&val)
inserts element
Definition: json.h:22044
reference operator[](size_type idx)
access specified array element
Definition: json.h:19988
static void to_bson(const basic_json &j, detail::output_adapter< char > o)
Serializes the given JSON object j to BSON and forwards the corresponding BSON-representation to the ...
Definition: json.h:23850
void update(const_iterator first, const_iterator last)
updates a JSON object from another object, overwriting existing keys
Definition: json.h:22308
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
Definition: json.h:19506
void swap(binary_t &other)
exchanges the values
Definition: json.h:22518
static std::vector< uint8_t > to_bson(const basic_json &j)
Serializes the given JSON object j to BSON and returns a vector containing the corresponding BSON-rep...
Definition: json.h:23827
json_reverse_iterator< typename basic_json::const_iterator > const_reverse_iterator
a const reverse iterator for a basic_json container
Definition: json.h:16791
void assert_invariant() const noexcept
checks the class invariants
Definition: json.h:17710
::nlohmann::json_pointer< basic_json > json_pointer
JSON Pointer, see nlohmann::json_pointer.
Definition: json.h:16716
static void to_msgpack(const basic_json &j, detail::output_adapter< uint8_t > o)
Definition: json.h:23653
static ::nlohmann::detail::parser< basic_json, InputAdapterType > parser(InputAdapterType adapter, detail::parser_callback_t< basic_json >cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
Definition: json.h:16684
number_unsigned_t * get_impl_ptr(number_unsigned_t *) noexcept
get a pointer to the value (unsigned number)
Definition: json.h:19254
const_reverse_iterator rbegin() const noexcept
returns a const reverse iterator to the last element
Definition: json.h:21115
binary_t & get_binary()
Definition: json.h:19735
void swap(string_t &other)
exchanges the values
Definition: json.h:22485
const_reference back() const
access the last element
Definition: json.h:20459
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
comparison: less than
Definition: json.h:22771
SAX input_format_t const bool strict
Definition: json.h:23293
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init)
explicitly create a binary array (without subtype)
Definition: json.h:18214
friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
comparison: not equal
Definition: json.h:22740
constexpr bool is_string() const noexcept
return whether value is a string
Definition: json.h:19095
number_integer_t * get_impl_ptr(number_integer_t *) noexcept
get a pointer to the value (integer number)
Definition: json.h:19242
constexpr bool is_array() const noexcept
return whether value is an array
Definition: json.h:19073
iterator insert_iterator(const_iterator pos, Args &&... args)
Definition: json.h:21984
const value_type & const_reference
the type of an element const reference
Definition: json.h:16769
void push_back(basic_json &&val)
add an object to an array
Definition: json.h:21713
friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
comparison: equal
Definition: json.h:22684
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
Definition: json.h:23977
size_type count(KeyT &&key) const
returns the number of occurrences of a key in a JSON object
Definition: json.h:20863
const binary_t & get_binary() const
Definition: json.h:19746
constexpr bool is_number() const noexcept
return whether value is a number
Definition: json.h:18944
friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
comparison: less than
Definition: json.h:22861
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
Definition: json.h:21954
reference operator+=(initializer_list_t init)
add an object to an object
Definition: json.h:21871
::nlohmann::detail::output_adapter_t< CharType > output_adapter_t
Definition: json.h:16705
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
Definition: json.h:18973
static JSON_HEDLEY_RETURNS_NON_NULL T * create(Args &&... args)
helper for exception-safe object creation
Definition: json.h:17406
std::initializer_list< detail::json_ref< basic_json > > initializer_list_t
helper type for initializer lists of basic_json values
Definition: json.h:16724
constexpr const array_t * get_impl_ptr(const array_t *) const noexcept
get a pointer to the value (array)
Definition: json.h:19212
detail::value_t value_t
Definition: json.h:16714
ValueType & get_to(ValueType &v) const
Definition: json.h:19519
static void to_msgpack(const basic_json &j, detail::output_adapter< char > o)
Definition: json.h:23658
const_reference operator[](const typename object_t::key_type &key) const
read-only access specified object element
Definition: json.h:20121
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init, std::uint8_t subtype)
explicitly create a binary array (with subtype)
Definition: json.h:18204
iterator find(KeyT &&key)
find an element in a JSON object
Definition: json.h:20812
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
Definition: json.h:17854
const_reference operator[](size_type idx) const
access specified array element
Definition: json.h:20034
AllocatorType< basic_json > allocator_type
the allocator type
Definition: json.h:16777
nlohmann::byte_container_with_subtype< BinaryType > binary_t
a type for a packed binary type
Definition: json.h:17398
JSONSerializer< T, SFINAE > json_serializer
Definition: json.h:16718
void push_back(const typename object_t::value_type &val)
add an object to an object
Definition: json.h:21798
friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
comparison: less than or equal
Definition: json.h:22907
std::less<> object_comparator_t
Definition: json.h:16899
ValueType get() const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >())))
get a value (explicit); special case
Definition: json.h:19460
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a pair of character iterators
Definition: json.h:23174
JSON_HEDLEY_NON_NULL(3) string_t value(const json_pointer &ptr
overload for a default value of type const char*
constexpr const string_t * get_impl_ptr(const string_t *) const noexcept
get a pointer to the value (string)
Definition: json.h:19224
static std::vector< uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
Definition: json.h:23551
bool contains(const json_pointer &ptr) const
check the existence of an element in a JSON object given a JSON pointer
Definition: json.h:20927
string_t value(const typename object_t::key_type &key, const char *default_value) const
overload for a default value of type const char*
Definition: json.h:20301
SAX input_format_t format
Definition: json.h:23292
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
Definition: json.h:17259
reference operator+=(const typename object_t::value_type &val)
add an object to an object
Definition: json.h:21822
const_iterator cbegin() const noexcept
returns a const iterator to the first element
Definition: json.h:21006
JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) static iteration_proxy< const_iterator > iterator_wrapper(const_reference ref) noexcept
Definition: json.h:21282
JSON_HEDLEY_NON_NULL(2) static bool sax_parse(InputType &&i
generate SAX events
basic_json(initializer_list_t init, bool type_deduction=true, value_t manual_type=value_t::array)
create a container (array or object) from an initializer list
Definition: json.h:18087
const_reference at(size_type idx) const
access specified array element with bounds checking
Definition: json.h:19840
iterator insert(const_iterator pos, const basic_json &val)
inserts element
Definition: json.h:22022
constexpr bool is_discarded() const noexcept
return whether value is discarded
Definition: json.h:19144
constexpr bool is_null() const noexcept
return whether value is null
Definition: json.h:18892
friend void swap(reference left, reference right) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
Definition: json.h:22389
friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
comparison: equal
Definition: json.h:22695
ObjectType< StringType, basic_json, object_comparator_t, AllocatorType< std::pair< const StringType, basic_json > >> object_t
a type for an object
Definition: json.h:16991
reference operator+=(const basic_json &val)
add an object to an array
Definition: json.h:21772
size_type erase(const typename object_t::key_type &key)
remove element from a JSON object given a key
Definition: json.h:20724
static ReferenceType get_ref_impl(ThisType &obj)
helper function to implement get_ref()
Definition: json.h:19301
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
Definition: json.h:18341
static allocator_type get_allocator()
returns the allocator associated with the container
Definition: json.h:16799
constexpr auto get_ptr() const noexcept -> decltype(std::declval< const basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
Definition: json.h:19580
friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
comparison: not equal
Definition: json.h:22729
JSON_HEDLEY_WARN_UNUSED_RESULT std::size_t const bool const bool allow_exceptions
Definition: json.h:23994
reverse_iterator rbegin() noexcept
returns an iterator to the reverse-beginning
Definition: json.h:21107
an internal type for a backed binary type
Definition: json.h:4434
BinaryType container_type
the type of the underlying container
Definition: json.h:4437
byte_container_with_subtype(const container_type &b) noexcept(noexcept(container_type(b)))
Definition: json.h:4443
byte_container_with_subtype(container_type &&b) noexcept(noexcept(container_type(std::move(b))))
Definition: json.h:4447
bool operator!=(const byte_container_with_subtype &rhs) const
Definition: json.h:4469
void clear_subtype() noexcept
clears the binary subtype
Definition: json.h:4564
byte_container_with_subtype(container_type &&b, std::uint8_t subtype) noexcept(noexcept(container_type(std::move(b))))
Definition: json.h:4457
byte_container_with_subtype() noexcept(noexcept(container_type()))
Definition: json.h:4439
constexpr bool has_subtype() const noexcept
return whether the value has a subtype
Definition: json.h:4540
void set_subtype(std::uint8_t subtype) noexcept
sets the binary subtype
Definition: json.h:4492
byte_container_with_subtype(const container_type &b, std::uint8_t subtype) noexcept(noexcept(container_type(b)))
Definition: json.h:4451
constexpr std::uint8_t subtype() const noexcept
return the binary subtype
Definition: json.h:4519
bool operator==(const byte_container_with_subtype &rhs) const
Definition: json.h:4463
deserialization of CBOR, MessagePack, and UBJSON values
Definition: json.h:7696
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:7698
JSON_HEDLEY_NON_NULL(3) bool sax_parse(const input_format_t format
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:7697
binary_reader & operator=(const binary_reader &)=delete
json_sax_t const bool const cbor_tag_handler_t bool InputIsLittleEndian
Definition: json.h:9923
typename BasicJsonType::string_t string_t
Definition: json.h:7700
json_sax_t const bool strict
Definition: json.h:7735
std::size_t chars_read
the number of characters read
Definition: json.h:10089
typename std::char_traits< char_type >::int_type char_int_type
Definition: json.h:7704
binary_reader(const binary_reader &)=delete
char_int_type current
the current character
Definition: json.h:10086
json_sax_t * sax
the SAX parser
Definition: json.h:10095
typename InputAdapterType::char_type char_type
Definition: json.h:7703
binary_reader(binary_reader &&)=default
typename BasicJsonType::binary_t binary_t
Definition: json.h:7701
binary_reader & operator=(binary_reader &&)=default
const bool is_little_endian
whether we can assume little endianess
Definition: json.h:10092
binary_reader(InputAdapterType &&adapter)
create a binary reader
Definition: json.h:7712
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:7699
json_sax_t const bool const cbor_tag_handler_t tag_handler
Definition: json.h:7736
serialization to CBOR and MessagePack values
Definition: json.h:12753
void write_bson_array(const string_t &name, const typename BasicJsonType::array_t &value)
Writes a BSON element with key name and array value.
Definition: json.h:13799
const bool is_little_endian
whether we can assume little endianess
Definition: json.h:14314
void write_number_with_ubjson_prefix(const NumberType n, const bool add_prefix)
Definition: json.h:13989
void write_ubjson(const BasicJsonType &j, const bool use_count, const bool use_type, const bool add_prefix=true)
Definition: json.h:13422
static constexpr CharType get_ubjson_float_prefix(double)
Definition: json.h:14214
void write_bson_entry_header(const string_t &name, const std::uint8_t element_type)
Writes the given element_type and name to the output adapter.
Definition: json.h:13644
static std::size_t calc_bson_element_size(const string_t &name, const BasicJsonType &j)
Calculates the size necessary to serialize the JSON value j with its name.
Definition: json.h:13833
void write_bson_double(const string_t &name, const double value)
Writes a BSON element with key name and double value value.
Definition: json.h:13666
void write_bson_object(const typename BasicJsonType::object_t &value)
Definition: json.h:13942
typename BasicJsonType::string_t string_t
Definition: json.h:12754
static constexpr CharType get_cbor_float_prefix(float)
Definition: json.h:13958
static constexpr CharType to_char_type(InputCharType x) noexcept
Definition: json.h:14307
typename BasicJsonType::binary_t binary_t
Definition: json.h:12755
binary_writer(output_adapter_t< CharType > adapter)
create a binary writer
Definition: json.h:12764
static constexpr CharType get_msgpack_float_prefix(double)
Definition: json.h:13977
CharType ubjson_prefix(const BasicJsonType &j) const noexcept
determine the type prefix of container values
Definition: json.h:14129
void write_bson_integer(const string_t &name, const std::int64_t value)
Writes a BSON element with key name and integer value.
Definition: json.h:13716
static std::size_t calc_bson_entry_header_size(const string_t &name)
Definition: json.h:13629
void write_bson_unsigned(const string_t &name, const std::uint64_t value)
Writes a BSON element with key name and unsigned value.
Definition: json.h:13744
static CharType to_char_type(std::uint8_t x) noexcept
Definition: json.h:14285
void write_bson_string(const string_t &name, const string_t &value)
Writes a BSON element with key name and string value value.
Definition: json.h:13684
void write_bson_object_entry(const string_t &name, const typename BasicJsonType::object_t &value)
Writes a BSON element with key name and object value.
Definition: json.h:13766
static constexpr CharType get_ubjson_float_prefix(float)
Definition: json.h:14209
void write_number(const NumberType n)
Definition: json.h:14235
output_adapter_t< CharType > oa
the output
Definition: json.h:14317
void write_bson_element(const string_t &name, const BasicJsonType &j)
Serializes the JSON value j to BSON and associates it with the key name.
Definition: json.h:13881
void write_bson_binary(const string_t &name, const binary_t &value)
Writes a BSON element with key name and binary value value.
Definition: json.h:13818
void write_bson_null(const string_t &name)
Writes a BSON element with key name and null value.
Definition: json.h:13698
static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t &value)
Definition: json.h:13791
void write_bson(const BasicJsonType &j)
Definition: json.h:12773
void write_cbor(const BasicJsonType &j)
Definition: json.h:12793
static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
Definition: json.h:13734
static constexpr CharType to_char_type(std::uint8_t x) noexcept
Definition: json.h:14278
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:12756
static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t &value)
Calculates the size of the BSON serialization of the given JSON-object j.
Definition: json.h:13927
static constexpr CharType get_msgpack_float_prefix(float)
Definition: json.h:13972
void write_bson_boolean(const string_t &name, const bool value)
Writes a BSON element with key name and boolean value value.
Definition: json.h:13656
void write_msgpack(const BasicJsonType &j)
Definition: json.h:13098
void write_compact_float(const number_float_t n, detail::input_format_t format)
Definition: json.h:14251
static std::size_t calc_bson_string_size(const string_t &value)
Definition: json.h:13676
static std::size_t calc_bson_integer_size(const std::int64_t value)
Definition: json.h:13706
static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t &value)
Definition: json.h:13776
static constexpr CharType get_cbor_float_prefix(double)
Definition: json.h:13963
general exception of the basic_json class
Definition: json.h:2353
const int id
the id of the exception
Definition: json.h:2363
JSON_HEDLEY_RETURNS_NON_NULL const char * what() const noexcept override
returns the explanatory string
Definition: json.h:2357
JSON_HEDLEY_NON_NULL(3) exception(int id_
const char * what_arg
Definition: json.h:2367
static std::string name(const std::string &ename, int id_)
Definition: json.h:2369
std::runtime_error m
an exception object as storage for error messages
Definition: json.h:2376
file_input_adapter(file_input_adapter &&)=default
std::FILE * m_file
the file pointer to read from
Definition: json.h:4777
JSON_HEDLEY_NON_NULL(2) explicit file_input_adapter(std
Definition: json.h:4759
std::char_traits< char >::int_type get_character() noexcept
Definition: json.h:4770
file_input_adapter(const file_input_adapter &)=delete
file_input_adapter & operator=(file_input_adapter &&)=delete
file_input_adapter & operator=(const file_input_adapter &)=delete
input_stream_adapter & operator=(input_stream_adapter &&rhs)=delete
input_stream_adapter(input_stream_adapter &&rhs) noexcept
Definition: json.h:4814
input_stream_adapter(const input_stream_adapter &)=delete
std::istream * is
the associated input stream
Definition: json.h:4836
std::char_traits< char >::int_type get_character()
Definition: json.h:4823
input_stream_adapter & operator=(input_stream_adapter &)=delete
input_stream_adapter(std::istream &i)
Definition: json.h:4805
exception indicating errors with iterators
Definition: json.h:2511
JSON_HEDLEY_NON_NULL(3) invalid_iterator(int id_
static invalid_iterator create(int id_, const std::string &what_arg)
Definition: json.h:2513
a template for a bidirectional iterator for the basic_json class This class implements a both iterato...
Definition: json.h:10809
bool operator<(const iter_impl &other) const
comparison: smaller
Definition: json.h:11201
iter_impl operator-(difference_type i) const
subtract from iterator
Definition: json.h:11315
const object_t::key_type & key() const
return the key of an object iterator
Definition: json.h:11378
iter_impl()=default
default constructor
Definition: json.h:10811
iter_impl const operator--(int)
post-decrement (it–)
Definition: json.h:11122
void set_end() noexcept
set the iterator past the last value
Definition: json.h:10977
bool operator==(const iter_impl &other) const
comparison: equal
Definition: json.h:11165
typename BasicJsonType::difference_type difference_type
a type to represent differences between iterators
Definition: json.h:10834
iter_impl & operator+=(difference_type i)
add to iterator
Definition: json.h:11255
difference_type operator-(const iter_impl &other) const
return difference
Definition: json.h:11326
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_reference, typename BasicJsonType::reference >::type reference
defines a reference to the type iterated over (value_type)
Definition: json.h:10843
reference operator*() const
return a reference to the value pointed to by the iterator
Definition: json.h:11008
void set_begin() noexcept
set the iterator to the first value
Definition: json.h:10940
bool operator>=(const iter_impl &other) const
comparison: greater than or equal
Definition: json.h:11246
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_pointer, typename BasicJsonType::pointer >::type pointer
defines a pointer to the type iterated over (value_type)
Definition: json.h:10838
pointer operator->() const
dereference the iterator
Definition: json.h:11045
iter_impl & operator=(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting assignment
Definition: json.h:10928
iter_impl(const iter_impl< const BasicJsonType > &other) noexcept
const copy constructor
Definition: json.h:10896
iter_impl const operator++(int)
post-increment (it++)
Definition: json.h:11079
iter_impl & operator--()
pre-decrement (–it)
Definition: json.h:11133
iter_impl(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting constructor
Definition: json.h:10918
iter_impl(pointer object) noexcept
constructor for a given JSON instance
Definition: json.h:10854
internal_iterator< typename std::remove_const< BasicJsonType >::type > m_it
the actual iterator of the associated instance
Definition: json.h:11403
iter_impl operator+(difference_type i) const
add to iterator
Definition: json.h:11293
friend iter_impl operator+(difference_type i, const iter_impl &it)
addition of distance and iterator
Definition: json.h:11304
iter_impl & operator=(const iter_impl< const BasicJsonType > &other) noexcept
converting assignment
Definition: json.h:10906
bool operator>(const iter_impl &other) const
comparison: greater than
Definition: json.h:11237
typename BasicJsonType::value_type value_type
the type of the values when the iterator is dereferenced
Definition: json.h:10832
reference value() const
return the value of an iterator
Definition: json.h:11394
typename BasicJsonType::object_t object_t
Definition: json.h:10816
iter_impl & operator-=(difference_type i)
subtract from iterator
Definition: json.h:11284
iter_impl & operator++()
pre-increment (++it)
Definition: json.h:11090
reference operator[](difference_type n) const
access to successor
Definition: json.h:11347
bool operator<=(const iter_impl &other) const
comparison: less than or equal
Definition: json.h:11228
pointer m_object
associated JSON instance
Definition: json.h:11401
std::bidirectional_iterator_tag iterator_category
Definition: json.h:10829
bool operator!=(const iter_impl &other) const
comparison: not equal
Definition: json.h:11192
typename BasicJsonType::array_t array_t
Definition: json.h:10817
IteratorType anchor
the iterator
Definition: json.h:3853
iteration_proxy_value & operator*()
dereference operator (needed for range-based for)
Definition: json.h:3867
std::input_iterator_tag iterator_category
Definition: json.h:3848
typename std::remove_cv< typename std::remove_reference< decltype(std::declval< IteratorType >().key()) >::type >::type string_type
Definition: json.h:3849
const string_type empty_str
an empty string (to return a reference for primitive values)
Definition: json.h:3861
iteration_proxy_value(IteratorType it) noexcept
Definition: json.h:3864
bool operator!=(const iteration_proxy_value &o) const
inequality operator (needed for range-based for)
Definition: json.h:3888
std::size_t array_index_last
last stringified array index
Definition: json.h:3857
string_type array_index_str
a string representation of the array index
Definition: json.h:3859
IteratorType::reference value() const
return value of the iterator
Definition: json.h:3922
std::size_t array_index
an index for arrays (used to create key names)
Definition: json.h:3855
iteration_proxy_value & operator++()
increment operator (needed for range-based for)
Definition: json.h:3873
const string_type & key() const
return key of the iterator
Definition: json.h:3894
bool operator==(const iteration_proxy_value &o) const
equality operator (needed for InputIterator)
Definition: json.h:3882
proxy class for the items() function
Definition: json.h:3930
iteration_proxy_value< IteratorType > begin() noexcept
return iterator begin (needed for range-based for)
Definition: json.h:3941
IteratorType::reference container
the container to iterate
Definition: json.h:3933
iteration_proxy_value< IteratorType > end() noexcept
return iterator end (needed for range-based for)
Definition: json.h:3947
iteration_proxy(typename IteratorType::reference cont) noexcept
construct iteration proxy from a container
Definition: json.h:3937
std::char_traits< char_type >::int_type get_character()
Definition: json.h:4851
typename std::iterator_traits< IteratorType >::value_type char_type
Definition: json.h:4846
iterator_input_adapter(IteratorType first, IteratorType last)
Definition: json.h:4848
value_type * value_ref
Definition: json.h:12586
json_ref(const json_ref &)=delete
json_ref(json_ref &&)=default
value_type owned_value
Definition: json.h:12585
BasicJsonType value_type
Definition: json.h:12530
json_ref(Args &&... args)
Definition: json.h:12552
json_ref(const value_type &value)
Definition: json.h:12538
json_ref & operator=(const json_ref &)=delete
json_ref & operator=(json_ref &&)=delete
value_type const & operator*() const
Definition: json.h:12574
value_type const * operator->() const
Definition: json.h:12579
json_ref(std::initializer_list< json_ref > init)
Definition: json.h:12543
json_ref(value_type &&value)
Definition: json.h:12532
value_type moved_or_copied() const
Definition: json.h:12565
a template for a reverse iterator class
Definition: json.h:11445
json_reverse_iterator(const typename base_iterator::iterator_type &it) noexcept
create reverse iterator from iterator
Definition: json.h:11454
json_reverse_iterator & operator--()
pre-decrement (–it)
Definition: json.h:11479
json_reverse_iterator & operator++()
pre-increment (++it)
Definition: json.h:11467
json_reverse_iterator const operator--(int)
post-decrement (it–)
Definition: json.h:11473
typename Base::reference reference
the reference type for the pointed-to element
Definition: json.h:11451
json_reverse_iterator & operator+=(difference_type i)
add to iterator
Definition: json.h:11485
json_reverse_iterator operator-(difference_type i) const
subtract from iterator
Definition: json.h:11497
std::reverse_iterator< Base > base_iterator
shortcut to the reverse iterator adapter
Definition: json.h:11449
json_reverse_iterator(const base_iterator &it) noexcept
create reverse iterator from base class
Definition: json.h:11458
reference operator[](difference_type n) const
access to successor
Definition: json.h:11509
difference_type operator-(const json_reverse_iterator &other) const
return difference
Definition: json.h:11503
json_reverse_iterator operator+(difference_type i) const
add to iterator
Definition: json.h:11491
json_reverse_iterator const operator++(int)
post-increment (it++)
Definition: json.h:11461
auto key() const -> decltype(std::declval< Base >().key())
return the key of an object iterator
Definition: json.h:11515
reference value() const
return the value of an iterator
Definition: json.h:11522
typename BasicJsonType::string_t string_t
Definition: json.h:5804
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:5801
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:5803
typename BasicJsonType::binary_t binary_t
Definition: json.h:5805
bool start_object(std::size_t=std::size_t(-1))
Definition: json.h:5842
bool start_array(std::size_t=std::size_t(-1))
Definition: json.h:5857
bool parse_error(std::size_t, const std::string &, const detail::exception &)
Definition: json.h:5867
bool number_integer(number_integer_t)
Definition: json.h:5817
bool number_unsigned(number_unsigned_t)
Definition: json.h:5822
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:5802
bool number_float(number_float_t, const string_t &)
Definition: json.h:5827
typename BasicJsonType::string_t string_t
Definition: json.h:5508
const bool allow_exceptions
whether to throw exceptions in case of errors
Definition: json.h:5792
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:5506
BasicJsonType * object_element
helper to hold the reference for the next object element
Definition: json.h:5786
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:5505
const parser_callback_t callback
callback function
Definition: json.h:5790
typename BasicJsonType::parser_callback_t parser_callback_t
Definition: json.h:5510
json_sax_dom_callback_parser(const json_sax_dom_callback_parser &)=delete
typename BasicJsonType::binary_t binary_t
Definition: json.h:5509
json_sax_dom_callback_parser & operator=(const json_sax_dom_callback_parser &)=delete
json_sax_dom_callback_parser & operator=(json_sax_dom_callback_parser &&)=default
bool number_integer(number_integer_t val)
Definition: json.h:5540
BasicJsonType & root
the parsed JSON value
Definition: json.h:5778
std::vector< BasicJsonType * > ref_stack
stack to model hierarchy of values
Definition: json.h:5780
std::pair< bool, BasicJsonType * > handle_value(Value &&v, const bool skip_callback=false)
Definition: json.h:5714
BasicJsonType discarded
a discarded value for the callback
Definition: json.h:5794
std::vector< bool > key_keep_stack
stack to manage which object keys to keep
Definition: json.h:5784
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:5507
typename BasicJsonType::parse_event_t parse_event_t
Definition: json.h:5511
bool errored
whether a syntax error occurred
Definition: json.h:5788
std::vector< bool > keep_stack
stack to manage which values to keep
Definition: json.h:5782
bool number_unsigned(number_unsigned_t val)
Definition: json.h:5546
bool number_float(number_float_t val, const string_t &)
Definition: json.h:5552
json_sax_dom_callback_parser(json_sax_dom_callback_parser &&)=default
bool parse_error(std::size_t, const std::string &, const Exception &ex)
Definition: json.h:5680
json_sax_dom_callback_parser(BasicJsonType &r, const parser_callback_t cb, const bool allow_exceptions_=true)
Definition: json.h:5513
SAX implementation to create a JSON value from SAX events.
Definition: json.h:5329
bool start_array(std::size_t len)
Definition: json.h:5421
json_sax_dom_parser(const json_sax_dom_parser &)=delete
typename BasicJsonType::binary_t binary_t
Definition: json.h:5335
bool number_unsigned(number_unsigned_t val)
Definition: json.h:5371
bool errored
whether a syntax error occurred
Definition: json.h:5496
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:5331
bool parse_error(std::size_t, const std::string &, const Exception &ex)
Definition: json.h:5441
bool string(string_t &val)
Definition: json.h:5383
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:5332
json_sax_dom_parser & operator=(const json_sax_dom_parser &)=delete
bool start_object(std::size_t len)
Definition: json.h:5395
BasicJsonType * object_element
helper to hold the reference for the next object element
Definition: json.h:5494
JSON_HEDLEY_RETURNS_NON_NULL BasicJsonType * handle_value(Value &&v)
Definition: json.h:5467
std::vector< BasicJsonType * > ref_stack
stack to model hierarchy of values
Definition: json.h:5492
bool binary(binary_t &val)
Definition: json.h:5389
const bool allow_exceptions
whether to throw exceptions in case of errors
Definition: json.h:5498
constexpr bool is_errored() const
Definition: json.h:5453
json_sax_dom_parser(json_sax_dom_parser &&)=default
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:5333
BasicJsonType & root
the parsed JSON value
Definition: json.h:5490
bool number_float(number_float_t val, const string_t &)
Definition: json.h:5377
json_sax_dom_parser(BasicJsonType &r, const bool allow_exceptions_=true)
Definition: json.h:5342
typename BasicJsonType::string_t string_t
Definition: json.h:5334
bool number_integer(number_integer_t val)
Definition: json.h:5365
json_sax_dom_parser & operator=(json_sax_dom_parser &&)=default
token_type
token types for the parser
Definition: json.h:5910
@ value_float
an floating point number – use get_number_float() for actual value
@ begin_array
the character for array begin [
@ value_string
a string – use get_string() for actual value
@ end_array
the character for array end ]
@ uninitialized
indicating the scanner is uninitialized
@ parse_error
indicating a parse error
@ value_integer
a signed integer – use get_number_integer() for actual value
@ value_separator
the value separator ,
@ end_object
the character for object end }
@ begin_object
the character for object begin {
@ value_unsigned
an unsigned integer – use get_number_unsigned() for actual value
@ end_of_input
indicating the end of the input buffer
@ literal_or_value
a literal or the begin of a value (only for diagnostics)
JSON_HEDLEY_RETURNS_NON_NULL static JSON_HEDLEY_CONST const char * token_type_name(const token_type t) noexcept
return name of values of type token_type (only used for errors)
Definition: json.h:5933
lexical analysis
Definition: json.h:5983
const char char **endptr noexcept
Definition: json.h:6784
number_float_t value_float
Definition: json.h:7496
const bool ignore_comments
whether comments should be ignored (true) or signaled as errors (false)
Definition: json.h:7473
lexer & operator=(lexer &&)=default
void add(char_int_type c)
add a character to token_buffer
Definition: json.h:7272
void reset() noexcept
reset token_buffer; current character is beginning of token
Definition: json.h:7191
token_type scan()
Definition: json.h:7380
bool next_unget
whether the next get() call should just return current
Definition: json.h:7479
char_int_type current
the current character
Definition: json.h:7476
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:5986
void skip_whitespace()
Definition: json.h:7371
typename std::char_traits< char_type >::int_type char_int_type
Definition: json.h:5989
static JSON_HEDLEY_PURE char get_decimal_point() noexcept
return the locale-dependent decimal point
Definition: json.h:6014
number_integer_t value_integer
Definition: json.h:7494
JSON_HEDLEY_NON_NULL(2) static void strtof(float &f
InputAdapterType ia
input adapter
Definition: json.h:7470
const std::size_t token_type return_type
Definition: json.h:7173
lexer(InputAdapterType &&adapter, bool ignore_comments_=false)
Definition: json.h:5994
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:5984
const char_int_type decimal_point_char
the decimal point
Definition: json.h:7499
const std::size_t length
Definition: json.h:7171
string_t & get_string()
return current string value (implicitly resets the token; useful only once)
Definition: json.h:7301
bool skip_bom()
skip the UTF-8 byte order mark
Definition: json.h:7357
const char * error_message
a description of occurred lexer errors
Definition: json.h:7491
JSON_HEDLEY_NON_NULL(2) token_type scan_literal(const char_type *literal_text
position_t position
the start position of the current token
Definition: json.h:7482
constexpr position_t get_position() const noexcept
return position of last read token
Definition: json.h:7311
std::vector< char_type > token_string
raw input token string (for error messages)
Definition: json.h:7485
constexpr number_integer_t get_number_integer() const noexcept
return integer value
Definition: json.h:7283
constexpr JSON_HEDLEY_RETURNS_NON_NULL const char * get_error_message() const noexcept
return syntax error message
Definition: json.h:7344
typename lexer_base< BasicJsonType >::token_type token_type
Definition: json.h:5992
typename InputAdapterType::char_type char_type
Definition: json.h:5988
char_int_type get()
Definition: json.h:7208
const char * str
Definition: json.h:6783
token_type scan_number()
scan a number literal
Definition: json.h:6840
void unget()
unget current character (read it again on next get)
Definition: json.h:7245
token_type scan_string()
scan a string literal
Definition: json.h:6125
lexer(const lexer &)=delete
constexpr number_unsigned_t get_number_unsigned() const noexcept
return unsigned integer value
Definition: json.h:7289
string_t token_buffer
buffer for variable-length tokens (numbers, strings)
Definition: json.h:7488
JSON_HEDLEY_NON_NULL(2) static void strtof(long double &f
JSON_HEDLEY_NON_NULL(2) static void strtof(double &f
constexpr number_float_t get_number_float() const noexcept
return floating-point value
Definition: json.h:7295
int get_codepoint()
get codepoint from 4 hex characters following \u
Definition: json.h:6040
std::string get_token_string() const
Definition: json.h:7319
number_unsigned_t value_unsigned
Definition: json.h:7495
lexer(lexer &&)=default
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:5985
bool next_byte_in_range(std::initializer_list< char_int_type > ranges)
check if the next byte(s) are inside a given range
Definition: json.h:6088
lexer & operator=(lexer &)=delete
typename BasicJsonType::string_t string_t
Definition: json.h:5987
bool scan_comment()
scan a comment
Definition: json.h:6715
exception indicating other library errors
Definition: json.h:2650
JSON_HEDLEY_NON_NULL(3) other_error(int id_
static other_error create(int id_, const std::string &what_arg)
Definition: json.h:2652
exception indicating access out of the defined range
Definition: json.h:2612
static out_of_range create(int id_, const std::string &what_arg)
Definition: json.h:2614
JSON_HEDLEY_NON_NULL(3) out_of_range(int id_
output_adapter(std::vector< CharType > &vec)
Definition: json.h:12719
output_adapter(std::basic_ostream< CharType > &s)
Definition: json.h:12722
output_adapter(StringType &s)
Definition: json.h:12725
output adapter for output streams
Definition: json.h:12670
JSON_HEDLEY_NON_NULL(2) void write_characters(const CharType *s
void write_character(CharType c) override
Definition: json.h:12676
std::basic_ostream< CharType > & stream
Definition: json.h:12688
output_stream_adapter(std::basic_ostream< CharType > &s) noexcept
Definition: json.h:12672
output adapter for basic_string
Definition: json.h:12694
void write_character(CharType c) override
Definition: json.h:12700
JSON_HEDLEY_NON_NULL(2) void write_characters(const CharType *s
output_string_adapter(StringType &s) noexcept
Definition: json.h:12696
output adapter for byte vectors
Definition: json.h:12646
JSON_HEDLEY_NON_NULL(2) void write_characters(const CharType *s
std::vector< CharType > & v
Definition: json.h:12664
output_vector_adapter(std::vector< CharType > &vec) noexcept
Definition: json.h:12648
void write_character(CharType c) override
Definition: json.h:12652
exception indicating a parse error
Definition: json.h:2425
parse_error(int id_, std::size_t byte_, const char *what_arg)
Definition: json.h:2463
static parse_error create(int id_, const position_t &pos, const std::string &what_arg)
create a parse error exception
Definition: json.h:2436
const std::size_t byte
byte index of the parse error
Definition: json.h:2460
static parse_error create(int id_, std::size_t byte_, const std::string &what_arg)
Definition: json.h:2443
static std::string position_string(const position_t &pos)
Definition: json.h:2466
syntax analysis
Definition: json.h:10164
lexer_t m_lexer
the lexer
Definition: json.h:10607
token_type last_token
the type of the last read token
Definition: json.h:10605
parser(InputAdapterType &&adapter, const parser_callback_t< BasicJsonType > cb=nullptr, const bool allow_exceptions_=true, const bool skip_comments=false)
a parser reading from an input adapter
Definition: json.h:10174
bool accept(const bool strict=true)
public accept interface
Definition: json.h:10257
typename BasicJsonType::string_t string_t
Definition: json.h:10168
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:10166
typename lexer_t::token_type token_type
Definition: json.h:10170
void parse(const bool strict, BasicJsonType &result)
public parser interface
Definition: json.h:10196
JSON_HEDLEY_NON_NULL(2) bool sax_parse(SAX *sax
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:10167
const bool allow_exceptions
whether to throw exceptions in case of errors
Definition: json.h:10609
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:10165
primitive_iterator_t operator+(difference_type n) noexcept
Definition: json.h:10686
primitive_iterator_t & operator-=(difference_type n) noexcept
Definition: json.h:10730
difference_type m_it
iterator as signed integer type
Definition: json.h:10644
constexpr bool is_end() const noexcept
return whether the iterator is at end
Definition: json.h:10671
constexpr friend bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition: json.h:10681
constexpr friend difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition: json.h:10693
constexpr bool is_begin() const noexcept
return whether the iterator can be dereferenced
Definition: json.h:10665
void set_begin() noexcept
set iterator to a defined beginning
Definition: json.h:10653
primitive_iterator_t const operator++(int) noexcept
Definition: json.h:10704
static constexpr difference_type end_value
Definition: json.h:10641
primitive_iterator_t & operator--() noexcept
Definition: json.h:10711
primitive_iterator_t & operator++() noexcept
Definition: json.h:10698
void set_end() noexcept
set iterator to a defined past the end
Definition: json.h:10659
constexpr difference_type get_value() const noexcept
Definition: json.h:10647
primitive_iterator_t & operator+=(difference_type n) noexcept
Definition: json.h:10724
primitive_iterator_t const operator--(int) noexcept
Definition: json.h:10717
constexpr friend bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
Definition: json.h:10676
static constexpr difference_type begin_value
Definition: json.h:10640
const error_handler_t error_handler
error_handler how to react on decoding errors
Definition: json.h:16381
unsigned int count_digits(number_unsigned_t x) noexcept
count digits
Definition: json.h:16073
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:15482
const std::lconv * loc
the locale
Definition: json.h:16366
std::array< char, 64 > number_buffer
a (hopefully) large enough character buffer
Definition: json.h:16363
static constexpr std::uint8_t UTF8_ACCEPT
Definition: json.h:15484
void dump_float(number_float_t x, std::true_type)
Definition: json.h:16220
serializer(serializer &&)=delete
const char decimal_point
the locale's decimal point character
Definition: json.h:16370
void dump_float(number_float_t x, std::false_type)
Definition: json.h:16228
number_unsigned_t remove_sign(number_unsigned_t x)
Definition: json.h:16337
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:15480
serializer & operator=(const serializer &)=delete
void dump_float(number_float_t x)
dump a floating-point number
Definition: json.h:16199
const char thousands_sep
the locale's thousand separator character
Definition: json.h:16368
static constexpr std::uint8_t UTF8_REJECT
Definition: json.h:15485
void dump_integer(NumberType x)
dump an integer
Definition: json.h:16113
void dump(const BasicJsonType &val, const bool pretty_print, const bool ensure_ascii, const unsigned int indent_step, const unsigned int current_indent=0)
internal implementation of the serialization function
Definition: json.h:15533
const char indent_char
the indentation character
Definition: json.h:16376
std::array< char, 512 > string_buffer
string buffer
Definition: json.h:16373
typename BasicJsonType::binary_t::value_type binary_char_t
Definition: json.h:15483
static std::uint8_t decode(std::uint8_t &state, std::uint32_t &codep, const std::uint8_t byte) noexcept
check whether a string is UTF-8 encoded
Definition: json.h:16298
serializer(output_adapter_t< char > s, const char ichar, error_handler_t error_handler_=error_handler_t::strict)
Definition: json.h:15493
void dump_escaped(const string_t &s, const bool ensure_ascii)
dump escaped string
Definition: json.h:15817
serializer & operator=(serializer &&)=delete
output_adapter_t< char > o
the output of the serializer
Definition: json.h:16360
typename BasicJsonType::string_t string_t
Definition: json.h:15479
serializer(const serializer &)=delete
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:15481
string_t indent_string
the indentation string
Definition: json.h:16378
number_unsigned_t remove_sign(number_integer_t x) noexcept
Definition: json.h:16352
span_input_adapter(CharT b, std::size_t l)
Definition: json.h:5156
contiguous_bytes_input_adapter ia
Definition: json.h:5172
contiguous_bytes_input_adapter && get()
Definition: json.h:5166
span_input_adapter(IteratorType first, IteratorType last)
Definition: json.h:5163
exception indicating executing a member function with a wrong type
Definition: json.h:2565
const char * what_arg
Definition: json.h:2575
JSON_HEDLEY_NON_NULL(3) type_error(int id_
static type_error create(int id_, const std::string &what_arg)
Definition: json.h:2567
std::size_t utf8_bytes_index
index to the utf8_codes array for the next valid byte
Definition: json.h:5043
std::char_traits< char >::int_type get_character() noexcept
Definition: json.h:5013
std::size_t utf8_bytes_filled
number of valid bytes in the utf8_codes array
Definition: json.h:5045
wide_string_input_adapter(BaseInputAdapter base)
Definition: json.h:5010
std::array< std::char_traits< char >::int_type, 4 > utf8_bytes
a buffer for UTF-8 bytes
Definition: json.h:5040
JSON Pointer.
Definition: json.h:11555
json_pointer top() const
Definition: json.h:11914
std::vector< std::string > reference_tokens
the reference tokens
Definition: json.h:12509
const std::string & back() const
return last reference token
Definition: json.h:11806
BasicJsonType & get_checked(BasicJsonType *ptr) const
Definition: json.h:12065
std::string to_string() const
return a string representation of the JSON pointer
Definition: json.h:11600
friend bool operator==(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for equality
Definition: json.h:12485
void pop_back()
remove last reference token
Definition: json.h:11782
const BasicJsonType & get_checked(const BasicJsonType *ptr) const
Definition: json.h:12156
BasicJsonType & get_unchecked(BasicJsonType *ptr) const
return a reference to the pointed to value
Definition: json.h:12006
BasicJsonType & get_and_create(BasicJsonType &j) const
create and return a reference to the pointed to value
Definition: json.h:11934
bool empty() const noexcept
return whether pointer points to the root document
Definition: json.h:11853
friend bool operator!=(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for inequality
Definition: json.h:12502
void push_back(const std::string &token)
append an unescaped token at the end of the reference pointer
Definition: json.h:11828
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
Definition: json.h:11632
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON pointer
Definition: json.h:11678
json_pointer(const std::string &s="")
create JSON pointer
Definition: json.h:11582
static std::string escape(std::string s)
escape "~" to "~0" and "/" to "~1"
Definition: json.h:12363
friend json_pointer operator/(const json_pointer &lhs, const json_pointer &rhs)
create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
Definition: json.h:11698
bool contains(const BasicJsonType *ptr) const
Definition: json.h:12196
static BasicJsonType unflatten(const BasicJsonType &value)
Definition: json.h:12447
friend json_pointer operator/(const json_pointer &ptr, std::string token)
create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
Definition: json.h:11719
static void replace_substring(std::string &s, const std::string &f, const std::string &t)
replace all occurrences of a substring by another string
Definition: json.h:12351
static void flatten(const std::string &reference_string, const BasicJsonType &value, BasicJsonType &result)
Definition: json.h:12384
static void unescape(std::string &s)
unescape "~1" to tilde and "~0" to slash (order is important!)
Definition: json.h:12371
json_pointer & operator/=(std::string token)
append an unescaped reference token at the end of this JSON pointer
Definition: json.h:11656
void push_back(std::string &&token)
append an unescaped token at the end of the reference pointer
Definition: json.h:11834
const BasicJsonType & get_unchecked(const BasicJsonType *ptr) const
return a const reference to the pointed to value
Definition: json.h:12114
static std::vector< std::string > split(const std::string &reference_string)
split the string input to reference tokens
Definition: json.h:12276
static BasicJsonType::size_type array_index(const std::string &s)
Definition: json.h:11869
friend json_pointer operator/(const json_pointer &ptr, std::size_t array_idx)
create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
Definition: json.h:11739
json_pointer parent_pointer() const
returns the parent of this JSON pointer
Definition: json.h:11757
decltype(get< N >(std::declval< ::nlohmann::detail::iteration_proxy_value< IteratorType > >())) type
Definition: json.h:3992
JSON_HEDLEY_NON_NULL(1) inline nlohmann
user-defined string literal for JSON values
Definition: json.h:25252
SumMean operator+(MeanType1 const &mu1, MeanType2 const &mu2)
std::shared_ptr< MultiIndexSet > operator+=(std::shared_ptr< MultiIndexSet > x, std::shared_ptr< MultiIndexSet > y)
int int diyfp diyfp diyfp m_plus
Definition: json.h:15164
int int FloatType value
Definition: json.h:15223
Target reinterpret_bits(const Source source)
Definition: json.h:14380
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus)
boundaries compute_boundaries(FloatType value)
Definition: json.h:14521
const diyfp c_minus_k(cached.f, cached.e)
int find_largest_pow10(const std::uint32_t n, std::uint32_t &pow10)
Definition: json.h:14824
constexpr int kGamma
Definition: json.h:14644
void grisu2_round(char *buf, int len, std::uint64_t dist, std::uint64_t delta, std::uint64_t rest, std::uint64_t ten_k)
Definition: json.h:14880
int int diyfp diyfp v
Definition: json.h:15163
JSON_HEDLEY_NON_NULL(1) inline void grisu2(char *buf
appends a decimal representation of e to buf
int int diyfp m_minus
Definition: json.h:15163
int int & decimal_exponent
Definition: json.h:15162
void grisu2_digit_gen(char *buffer, int &length, int &decimal_exponent, diyfp M_minus, diyfp w, diyfp M_plus)
Definition: json.h:14921
return append_exponent(buf, n - 1)
constexpr int kAlpha
Definition: json.h:14643
const cached_power cached
Definition: json.h:15177
cached_power get_cached_power_for_binary_exponent(int e)
Definition: json.h:14660
int int int int max_exp
Definition: json.h:15316
const diyfp M_minus(w_minus.f+1, w_minus.e)
const diyfp M_plus(w_plus.f - 1, w_plus.e)
typename std::enable_if< B, T >::type enable_if_t
Definition: json.h:2679
typename T::reference reference_t
Definition: json.h:3015
bool operator<(const value_t lhs, const value_t rhs) noexcept
comparison operator for JSON types
Definition: json.h:3404
decltype(T::from_json(std::declval< Args >()...)) from_json_function
Definition: json.h:3027
void to_json(BasicJsonType &j, T b) noexcept
Definition: json.h:4213
value_t
the JSON type enumeration
Definition: json.h:3378
@ number_integer
number value (signed integer)
@ discarded
discarded by the parser callback function
@ binary
binary array (ordered collection of bytes)
@ object
object (unordered set of name/value pairs)
@ number_float
number value (floating-point)
@ number_unsigned
number value (unsigned integer)
@ array
array (ordered collection of values)
void from_json(const BasicJsonType &j, typename std::nullptr_t &n)
Definition: json.h:3426
decltype(std::declval< T & >().parse_error(std::declval< std::size_t >(), std::declval< const std::string & >(), std::declval< const Exception & >())) parse_error_function_t
Definition: json.h:7570
typename T::pointer pointer_t
Definition: json.h:3012
decltype(std::declval< T & >().string(std::declval< String & >())) string_function_t
Definition: json.h:7543
void from_json_tuple_impl(const BasicJsonType &j, Tuple &t, index_sequence< Idx... >)
Definition: json.h:3733
@ value
the parser finished reading a JSON value
@ key
the parser read a key of a value in an object
@ array_end
the parser read ] and finished processing a JSON array
@ array_start
the parser read [ and started to process a JSON array
@ object_start
the parser read { and started to process a JSON object
@ object_end
the parser read } and finished processing a JSON object
typename T::difference_type difference_type_t
Definition: json.h:3009
typename detector< nonesuch, void, Op, Args... >::type detected_t
Definition: json.h:2854
void int_to_string(string_type &target, std::size_t value)
Definition: json.h:3835
void from_json_array_impl(const BasicJsonType &j, typename BasicJsonType::array_t &arr, priority_tag< 3 >)
Definition: json.h:3574
decltype(std::declval< T & >().key(std::declval< String & >())) key_function_t
Definition: json.h:7555
constexpr int kMaxExp
Definition: json.h:15435
decltype(std::declval< T & >().boolean(std::declval< bool >())) boolean_function_t
Definition: json.h:7527
decltype(std::declval< T & >().binary(std::declval< Binary & >())) binary_function_t
Definition: json.h:7547
decltype(std::declval< T & >().number_integer(std::declval< Integer >())) number_integer_function_t
Definition: json.h:7531
void to_json_tuple_impl(BasicJsonType &j, const Tuple &t, index_sequence< Idx... >)
Definition: json.h:4336
std::is_convertible< detected_t< Op, Args... >, To > is_detected_convertible
Definition: json.h:2867
typename std::remove_cv< typename std::remove_reference< T >::type >::type uncvref_t
Definition: json.h:2682
cbor_tag_handler_t
how to treat CBOR tags
Definition: json.h:7669
@ error
throw a parse_error exception in case of a tag
error_handler_t
how to treat decoding errors
Definition: json.h:15470
@ strict
throw a type_error exception in case of invalid UTF-8
@ ignore
ignore invalid UTF-8 sequences
@ replace
replace invalid UTF-8 sequences with U+FFFD
decltype(std::declval< T & >().start_object(std::declval< std::size_t >())) start_object_function_t
Definition: json.h:7551
int decimal_exponent
Definition: json.h:15427
typename T::key_type key_type_t
Definition: json.h:3003
std::size_t combine(std::size_t seed, std::size_t h) noexcept
Definition: json.h:4595
std::size_t hash(const BasicJsonType &j)
hash a JSON value
Definition: json.h:4613
decltype(std::declval< T & >().number_unsigned(std::declval< Unsigned >())) number_unsigned_function_t
Definition: json.h:7535
std::is_same< Expected, detected_t< Op, Args... > > is_detected_exact
Definition: json.h:2863
typename detected_or< Default, Op, Args... >::type detected_or_t
Definition: json.h:2860
decltype(std::declval< T & >().start_array(std::declval< std::size_t >())) start_array_function_t
Definition: json.h:7562
void get_arithmetic_value(const BasicJsonType &j, ArithmeticType &val)
Definition: json.h:3440
typename detector< nonesuch, void, Op, Args... >::value_t is_detected
Definition: json.h:2851
typename make_void< Ts... >::type void_t
Definition: json.h:2754
std::function< bool(int depth, parse_event_t event, BasicJsonType &parsed)> parser_callback_t
Definition: json.h:10155
std::shared_ptr< output_adapter_protocol< CharType > > output_adapter_t
a type to simplify interfaces
Definition: json.h:12641
typename T::mapped_type mapped_type_t
Definition: json.h:3000
typename T::iterator iterator_t
Definition: json.h:3021
input_format_t
the supported input formats
Definition: json.h:4744
void to_json(BasicJsonType &j, const T &b)
Definition: json.h:4330
decltype(std::declval< T >().template get< U >()) get_template_function
Definition: json.h:3030
decltype(input_adapter(std::declval< const char * >(), std::declval< const char * >())) contiguous_bytes_input_adapter
Definition: json.h:5121
const char FloatType value
Definition: json.h:15400
decltype(std::declval< T & >().null()) null_function_t
Definition: json.h:7523
const char * last
Definition: json.h:15399
auto get(const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())
Definition: json.h:3956
iterator_input_adapter_factory< IteratorType >::adapter_type input_adapter(IteratorType first, IteratorType last)
Definition: json.h:5088
typename T::iterator_category iterator_category_t
Definition: json.h:3018
static bool little_endianess(int num=1) noexcept
determine system byte order
Definition: json.h:7681
decltype(std::declval< T & >().number_float(std::declval< Float >(), std::declval< const String & >())) number_float_function_t
Definition: json.h:7539
JSON_ASSERT(std::isfinite(value))
constexpr int kMinExp
Definition: json.h:15433
decltype(std::declval< T & >().end_array()) end_array_function_t
Definition: json.h:7565
void from_json(const BasicJsonType &j, std::unordered_map< Key, Value, Hash, KeyEqual, Allocator > &m)
Definition: json.h:3767
decltype(std::declval< T & >().end_object()) end_object_function_t
Definition: json.h:7558
decltype(T::to_json(std::declval< Args >()...)) to_json_function
Definition: json.h:3024
JSON_HEDLEY_NON_NULL(1, 2) JSON_HEDLEY_RETURNS_NON_NULL char *to_chars(char *first
generates a decimal representation of the floating-point number value in [first, last).
JSON_ASSERT(last - first >=std::numeric_limits< FloatType >::max_digits10+6)
typename T::value_type value_type_t
Definition: json.h:3006
namespace for Niels Lohmann
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
Definition: json.h:25172
default JSONSerializer template argument
Definition: json.h:4371
static auto to_json(BasicJsonType &j, ValueType &&val) noexcept(noexcept(::nlohmann::to_json(j, std::forward< ValueType >(val)))) -> decltype(::nlohmann::to_json(j, std::forward< ValueType >(val)), void())
convert any value type to a JSON value
Definition: json.h:4399
static auto from_json(BasicJsonType &&j, ValueType &val) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), val))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), val), void())
convert a JSON value to any value type
Definition: json.h:4382
std::false_type value_t
Definition: json.h:2839
static constexpr int kPrecision
Definition: json.h:14391
static diyfp normalize(diyfp x) noexcept
normalize x such that the significand is >= 2^(q-1)
Definition: json.h:14479
static diyfp normalize_to(const diyfp &x, const int target_exponent) noexcept
normalize x such that the result has the exponent E
Definition: json.h:14496
static diyfp mul(const diyfp &x, const diyfp &y) noexcept
returns x * y
Definition: json.h:14414
constexpr diyfp(std::uint64_t f_, int e_) noexcept
Definition: json.h:14396
static diyfp sub(const diyfp &x, const diyfp &y) noexcept
returns x - y
Definition: json.h:14402
static void construct(BasicJsonType &j, const CompatibleArrayType &arr)
Definition: json.h:4138
static void construct(BasicJsonType &j, const std::valarray< T > &arr)
Definition: json.h:4162
static void construct(BasicJsonType &j, const std::vector< bool > &arr)
Definition: json.h:4148
static void construct(BasicJsonType &j, typename BasicJsonType::array_t &&arr)
Definition: json.h:4128
static void construct(BasicJsonType &j, const typename BasicJsonType::array_t &arr)
Definition: json.h:4120
static void construct(BasicJsonType &j, const typename BasicJsonType::binary_t &b)
Definition: json.h:4062
static void construct(BasicJsonType &j, typename BasicJsonType::binary_t &&b)
Definition: json.h:4071
static void construct(BasicJsonType &j, typename BasicJsonType::boolean_t b) noexcept
Definition: json.h:4020
static void construct(BasicJsonType &j, typename BasicJsonType::number_float_t val) noexcept
Definition: json.h:4084
static void construct(BasicJsonType &j, typename BasicJsonType::number_integer_t val) noexcept
Definition: json.h:4108
static void construct(BasicJsonType &j, typename BasicJsonType::number_unsigned_t val) noexcept
Definition: json.h:4096
static void construct(BasicJsonType &j, typename BasicJsonType::object_t &&obj)
Definition: json.h:4187
static void construct(BasicJsonType &j, const typename BasicJsonType::object_t &obj)
Definition: json.h:4179
static void construct(BasicJsonType &j, const CompatibleObjectType &obj)
Definition: json.h:4196
static void construct(BasicJsonType &j, typename BasicJsonType::string_t &&s)
Definition: json.h:4040
static void construct(BasicJsonType &j, const CompatibleStringType &str)
Definition: json.h:4050
static void construct(BasicJsonType &j, const typename BasicJsonType::string_t &s)
Definition: json.h:4032
auto operator()(const BasicJsonType &j, T &val) const noexcept(noexcept(from_json(j, val))) -> decltype(from_json(j, val), void())
Definition: json.h:3787
typename BasicJsonType::template json_serializer< T, void > serializer
Definition: json.h:3050
typename BasicJsonType::template json_serializer< T, void > serializer
Definition: json.h:3080
static constexpr std::size_t size() noexcept
Definition: json.h:2691
primitive_iterator_t primitive_iterator
generic iterator for all other types
Definition: json.h:10757
BasicJsonType::array_t::iterator array_iterator
iterator for JSON arrays
Definition: json.h:10755
BasicJsonType::object_t::iterator object_iterator
iterator for JSON objects
Definition: json.h:10753
static constexpr bool value
Definition: json.h:3043
typename std::iterator_traits< T >::value_type value_type
Definition: json.h:5065
typename BasicJsonType::string_t string_t
Definition: json.h:7613
typename BasicJsonType::exception exception_t
Definition: json.h:7615
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:7610
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:7612
typename BasicJsonType::binary_t binary_t
Definition: json.h:7614
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:7611
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:7581
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:7580
typename BasicJsonType::exception exception_t
Definition: json.h:7584
static constexpr bool value
Definition: json.h:7587
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:7579
typename BasicJsonType::string_t string_t
Definition: json.h:7582
typename BasicJsonType::binary_t binary_t
Definition: json.h:7583
typename std::iterator_traits< iterator_type >::value_type char_type
Definition: json.h:5053
static adapter_type create(IteratorType first, IteratorType last)
Definition: json.h:5056
iterator_input_adapter< iterator_type > adapter_type
Definition: json.h:5054
nonesuch(nonesuch const &)=delete
void operator=(nonesuch &&)=delete
nonesuch(nonesuch const &&)=delete
void operator=(nonesuch const &)=delete
abstract output adapter interface
Definition: json.h:12633
virtual void write_characters(const CharType *s, std::size_t length)=0
virtual void write_character(CharType c)=0
struct to capture the start position of the current token
Definition: json.h:87
std::size_t lines_read
the number of lines read
Definition: json.h:93
std::size_t chars_read_current_line
the number of characters read in the current line
Definition: json.h:91
std::size_t chars_read_total
the total number of characters read
Definition: json.h:89
static constexpr T value
Definition: json.h:2723
auto operator()(BasicJsonType &j, T &&val) const noexcept(noexcept(to_json(j, std::forward< T >(val)))) -> decltype(to_json(j, std::forward< T >(val)), void())
Definition: json.h:4350
static void fill_buffer(BaseInputAdapter &input, std::array< std::char_traits< char >::int_type, 4 > &utf8_bytes, size_t &utf8_bytes_index, size_t &utf8_bytes_filled)
Definition: json.h:4945
static void fill_buffer(BaseInputAdapter &input, std::array< std::char_traits< char >::int_type, 4 > &utf8_bytes, size_t &utf8_bytes_index, size_t &utf8_bytes_filled)
Definition: json.h:4887
SAX interface.
Definition: json.h:5203
virtual bool start_object(std::size_t elements)=0
the beginning of an object was read
virtual bool string(string_t &val)=0
a string was read
typename BasicJsonType::number_integer_t number_integer_t
Definition: json.h:5204
typename BasicJsonType::binary_t binary_t
Definition: json.h:5208
virtual bool end_array()=0
the end of an array was read
virtual bool key(string_t &val)=0
an object key was read
typename BasicJsonType::number_unsigned_t number_unsigned_t
Definition: json.h:5205
virtual bool binary(binary_t &val)=0
a binary string was read
typename BasicJsonType::number_float_t number_float_t
Definition: json.h:5206
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
virtual bool boolean(bool val)=0
a boolean value was read
virtual bool end_object()=0
the end of an object was read
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
typename BasicJsonType::string_t string_t
Definition: json.h:5207
virtual bool number_float(number_float_t val, const string_t &s)=0
an floating-point number was read
virtual ~json_sax()=default
virtual bool number_integer(number_integer_t val)=0
an integer number was read
std::pair< iterator, bool > insert(const value_type &value)
Definition: json.h:16547
ordered_map(std::initializer_list< T > init, const Allocator &alloc=Allocator())
Definition: json.h:16421
std::vector< std::pair< const Key, T >, Allocator > Container
Definition: json.h:16409
iterator find(const Key &key)
Definition: json.h:16518
iterator erase(iterator pos)
Definition: json.h:16492
std::pair< iterator, bool > emplace(const key_type &key, T &&t)
Definition: json.h:16424
const_iterator find(const Key &key) const
Definition: json.h:16530
std::pair< iterator, bool > insert(value_type &&value)
Definition: json.h:16542
size_type erase(const Key &key)
Definition: json.h:16473
const T & operator[](const Key &key) const
Definition: json.h:16442
ordered_map(const Allocator &alloc=Allocator())
Definition: json.h:16417
const T & at(const Key &key) const
Definition: json.h:16460
ordered_map(It first, It last, const Allocator &alloc=Allocator())
Definition: json.h:16419
T & at(const Key &key)
Definition: json.h:16447
T & operator[](const Key &key)
Definition: json.h:16437
size_type count(const Key &key) const
Definition: json.h:16506
std::size_t operator()(const nlohmann::json &j) const
return a hash value for a JSON object
Definition: json.h:25195
bool operator()(nlohmann::detail::value_t lhs, nlohmann::detail::value_t rhs) const noexcept
compare two value_t enum values
Definition: json.h:25211
nlohmann::json json
Definition: umbridge.h:15
json_value(array_t &&value)
constructor for rvalue arrays
Definition: json.h:17581
boolean_t boolean
boolean
Definition: json.h:17461
number_integer_t number_integer
number (integer)
Definition: json.h:17463
binary_t * binary
binary (stored with pointer to save storage)
Definition: json.h:17459
json_value(number_integer_t v) noexcept
constructor for numbers (integer)
Definition: json.h:17474
json_value(const array_t &value)
constructor for arrays
Definition: json.h:17575
void destroy(value_t t) noexcept
Definition: json.h:17610
object_t * object
object (stored with pointer to save storage)
Definition: json.h:17453
json_value(binary_t &&value)
constructor for rvalue binary arrays (internal type)
Definition: json.h:17605
number_float_t number_float
number (floating-point)
Definition: json.h:17467
json_value(string_t &&value)
constructor for rvalue strings
Definition: json.h:17557
number_unsigned_t number_unsigned
number (unsigned integer)
Definition: json.h:17465
json_value(const object_t &value)
constructor for objects
Definition: json.h:17563
json_value(const typename binary_t::container_type &value)
constructor for binary arrays
Definition: json.h:17587
json_value(value_t t)
constructor for empty values of a given type
Definition: json.h:17480
json_value(boolean_t v) noexcept
constructor for booleans
Definition: json.h:17472
array_t * array
array (stored with pointer to save storage)
Definition: json.h:17455
string_t * string
string (stored with pointer to save storage)
Definition: json.h:17457
json_value(const binary_t &value)
constructor for binary arrays (internal type)
Definition: json.h:17599
json_value(object_t &&value)
constructor for rvalue objects
Definition: json.h:17569
json_value()=default
default constructor (for null values)
json_value(typename binary_t::container_type &&value)
constructor for rvalue binary arrays
Definition: json.h:17593
json_value(const string_t &value)
constructor for strings
Definition: json.h:17551
json_value(number_float_t v) noexcept
constructor for numbers (floating-point)
Definition: json.h:17478
json_value(number_unsigned_t v) noexcept
constructor for numbers (unsigned)
Definition: json.h:17476