ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
json.hpp
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file json.hpp
1 /*
2  __ _____ _____ _____
3  __| | __| | | | JSON for Modern C++
4 | | |__ | | | | | | version 3.7.3
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 7
35 #define NLOHMANN_JSON_VERSION_PATCH 3
36 
37 #include <algorithm> // all_of, find, for_each
38 #include <cassert> // assert
39 #include <ciso646> // and, not, or
40 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
41 #include <functional> // hash, less
42 #include <initializer_list> // initializer_list
43 #include <iosfwd> // istream, ostream
44 #include <iterator> // random_access_iterator_tag
45 #include <memory> // unique_ptr
46 #include <numeric> // accumulate
47 #include <string> // string, stoi, to_string
48 #include <utility> // declval, forward, move, pair, swap
49 #include <vector> // vector
50 
51 // #include <nlohmann/adl_serializer.hpp>
52 
53 
54 #include <utility>
55 
56 // #include <nlohmann/detail/conversions/from_json.hpp>
57 
58 
59 #include <algorithm> // transform
60 #include <array> // array
61 #include <ciso646> // and, not
62 #include <forward_list> // forward_list
63 #include <iterator> // inserter, front_inserter, end
64 #include <map> // map
65 #include <string> // string
66 #include <tuple> // tuple, make_tuple
67 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
68 #include <unordered_map> // unordered_map
69 #include <utility> // pair, declval
70 #include <valarray> // valarray
71 
72 // #include <nlohmann/detail/exceptions.hpp>
73 
74 
75 #include <exception> // exception
76 #include <stdexcept> // runtime_error
77 #include <string> // to_string
78 
79 // #include <nlohmann/detail/input/position_t.hpp>
80 
81 
82 #include <cstddef> // size_t
83 
84 namespace nlohmann
85 {
86 namespace detail
87 {
89 struct position_t
90 {
92  std::size_t chars_read_total = 0;
94  std::size_t chars_read_current_line = 0;
96  std::size_t lines_read = 0;
97 
99  constexpr operator size_t() const
100  {
101  return chars_read_total;
102  }
103 };
104 
105 } // namespace detail
106 } // namespace nlohmann
107 
108 // #include <nlohmann/detail/macro_scope.hpp>
109 
110 
111 #include <utility> // pair
112 // #include <nlohmann/thirdparty/hedley/hedley.hpp>
113 /* Hedley - https://nemequ.github.io/hedley
114  * Created by Evan Nemerson <evan@nemerson.com>
115  *
116  * To the extent possible under law, the author(s) have dedicated all
117  * copyright and related and neighboring rights to this software to
118  * the public domain worldwide. This software is distributed without
119  * any warranty.
120  *
121  * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
122  * SPDX-License-Identifier: CC0-1.0
123  */
124 
125 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 11)
126 #if defined(JSON_HEDLEY_VERSION)
127  #undef JSON_HEDLEY_VERSION
128 #endif
129 #define JSON_HEDLEY_VERSION 11
130 
131 #if defined(JSON_HEDLEY_STRINGIFY_EX)
132  #undef JSON_HEDLEY_STRINGIFY_EX
133 #endif
134 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
135 
136 #if defined(JSON_HEDLEY_STRINGIFY)
137  #undef JSON_HEDLEY_STRINGIFY
138 #endif
139 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
140 
141 #if defined(JSON_HEDLEY_CONCAT_EX)
142  #undef JSON_HEDLEY_CONCAT_EX
143 #endif
144 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
145 
146 #if defined(JSON_HEDLEY_CONCAT)
147  #undef JSON_HEDLEY_CONCAT
148 #endif
149 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
150 
151 #if defined(JSON_HEDLEY_VERSION_ENCODE)
152  #undef JSON_HEDLEY_VERSION_ENCODE
153 #endif
154 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
155 
156 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
157  #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
158 #endif
159 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
160 
161 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
162  #undef JSON_HEDLEY_VERSION_DECODE_MINOR
163 #endif
164 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
165 
166 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
167  #undef JSON_HEDLEY_VERSION_DECODE_REVISION
168 #endif
169 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
170 
171 #if defined(JSON_HEDLEY_GNUC_VERSION)
172  #undef JSON_HEDLEY_GNUC_VERSION
173 #endif
174 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
175  #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
176 #elif defined(__GNUC__)
177  #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
178 #endif
179 
180 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
181  #undef JSON_HEDLEY_GNUC_VERSION_CHECK
182 #endif
183 #if defined(JSON_HEDLEY_GNUC_VERSION)
184  #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
185 #else
186  #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
187 #endif
188 
189 #if defined(JSON_HEDLEY_MSVC_VERSION)
190  #undef JSON_HEDLEY_MSVC_VERSION
191 #endif
192 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
193  #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
194 #elif defined(_MSC_FULL_VER)
195  #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
196 #elif defined(_MSC_VER)
197  #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
198 #endif
199 
200 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
201  #undef JSON_HEDLEY_MSVC_VERSION_CHECK
202 #endif
203 #if !defined(_MSC_VER)
204  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
205 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
206  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
207 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
208  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
209 #else
210  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
211 #endif
212 
213 #if defined(JSON_HEDLEY_INTEL_VERSION)
214  #undef JSON_HEDLEY_INTEL_VERSION
215 #endif
216 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
217  #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
218 #elif defined(__INTEL_COMPILER)
219  #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
220 #endif
221 
222 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
223  #undef JSON_HEDLEY_INTEL_VERSION_CHECK
224 #endif
225 #if defined(JSON_HEDLEY_INTEL_VERSION)
226  #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
227 #else
228  #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
229 #endif
230 
231 #if defined(JSON_HEDLEY_PGI_VERSION)
232  #undef JSON_HEDLEY_PGI_VERSION
233 #endif
234 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
235  #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
236 #endif
237 
238 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
239  #undef JSON_HEDLEY_PGI_VERSION_CHECK
240 #endif
241 #if defined(JSON_HEDLEY_PGI_VERSION)
242  #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
243 #else
244  #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
245 #endif
246 
247 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
248  #undef JSON_HEDLEY_SUNPRO_VERSION
249 #endif
250 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
251  #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)
252 #elif defined(__SUNPRO_C)
253  #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
254 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
255  #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)
256 #elif defined(__SUNPRO_CC)
257  #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
258 #endif
259 
260 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
261  #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
262 #endif
263 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
264  #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
265 #else
266  #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
267 #endif
268 
269 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
270  #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
271 #endif
272 #if defined(__EMSCRIPTEN__)
273  #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
274 #endif
275 
276 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
277  #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
278 #endif
279 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
280  #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
281 #else
282  #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
283 #endif
284 
285 #if defined(JSON_HEDLEY_ARM_VERSION)
286  #undef JSON_HEDLEY_ARM_VERSION
287 #endif
288 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
289  #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
290 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
291  #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
292 #endif
293 
294 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
295  #undef JSON_HEDLEY_ARM_VERSION_CHECK
296 #endif
297 #if defined(JSON_HEDLEY_ARM_VERSION)
298  #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
299 #else
300  #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
301 #endif
302 
303 #if defined(JSON_HEDLEY_IBM_VERSION)
304  #undef JSON_HEDLEY_IBM_VERSION
305 #endif
306 #if defined(__ibmxl__)
307  #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
308 #elif defined(__xlC__) && defined(__xlC_ver__)
309  #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
310 #elif defined(__xlC__)
311  #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
312 #endif
313 
314 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
315  #undef JSON_HEDLEY_IBM_VERSION_CHECK
316 #endif
317 #if defined(JSON_HEDLEY_IBM_VERSION)
318  #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
319 #else
320  #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
321 #endif
322 
323 #if defined(JSON_HEDLEY_TI_VERSION)
324  #undef JSON_HEDLEY_TI_VERSION
325 #endif
326 #if defined(__TI_COMPILER_VERSION__)
327  #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
328 #endif
329 
330 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
331  #undef JSON_HEDLEY_TI_VERSION_CHECK
332 #endif
333 #if defined(JSON_HEDLEY_TI_VERSION)
334  #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
335 #else
336  #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
337 #endif
338 
339 #if defined(JSON_HEDLEY_CRAY_VERSION)
340  #undef JSON_HEDLEY_CRAY_VERSION
341 #endif
342 #if defined(_CRAYC)
343  #if defined(_RELEASE_PATCHLEVEL)
344  #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
345  #else
346  #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
347  #endif
348 #endif
349 
350 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
351  #undef JSON_HEDLEY_CRAY_VERSION_CHECK
352 #endif
353 #if defined(JSON_HEDLEY_CRAY_VERSION)
354  #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
355 #else
356  #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
357 #endif
358 
359 #if defined(JSON_HEDLEY_IAR_VERSION)
360  #undef JSON_HEDLEY_IAR_VERSION
361 #endif
362 #if defined(__IAR_SYSTEMS_ICC__)
363  #if __VER__ > 1000
364  #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
365  #else
366  #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
367  #endif
368 #endif
369 
370 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
371  #undef JSON_HEDLEY_IAR_VERSION_CHECK
372 #endif
373 #if defined(JSON_HEDLEY_IAR_VERSION)
374  #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
375 #else
376  #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
377 #endif
378 
379 #if defined(JSON_HEDLEY_TINYC_VERSION)
380  #undef JSON_HEDLEY_TINYC_VERSION
381 #endif
382 #if defined(__TINYC__)
383  #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
384 #endif
385 
386 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
387  #undef JSON_HEDLEY_TINYC_VERSION_CHECK
388 #endif
389 #if defined(JSON_HEDLEY_TINYC_VERSION)
390  #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
391 #else
392  #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
393 #endif
394 
395 #if defined(JSON_HEDLEY_DMC_VERSION)
396  #undef JSON_HEDLEY_DMC_VERSION
397 #endif
398 #if defined(__DMC__)
399  #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
400 #endif
401 
402 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
403  #undef JSON_HEDLEY_DMC_VERSION_CHECK
404 #endif
405 #if defined(JSON_HEDLEY_DMC_VERSION)
406  #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
407 #else
408  #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
409 #endif
410 
411 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
412  #undef JSON_HEDLEY_COMPCERT_VERSION
413 #endif
414 #if defined(__COMPCERT_VERSION__)
415  #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
416 #endif
417 
418 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
419  #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
420 #endif
421 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
422  #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
423 #else
424  #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
425 #endif
426 
427 #if defined(JSON_HEDLEY_PELLES_VERSION)
428  #undef JSON_HEDLEY_PELLES_VERSION
429 #endif
430 #if defined(__POCC__)
431  #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
432 #endif
433 
434 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
435  #undef JSON_HEDLEY_PELLES_VERSION_CHECK
436 #endif
437 #if defined(JSON_HEDLEY_PELLES_VERSION)
438  #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
439 #else
440  #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
441 #endif
442 
443 #if defined(JSON_HEDLEY_GCC_VERSION)
444  #undef JSON_HEDLEY_GCC_VERSION
445 #endif
446 #if \
447  defined(JSON_HEDLEY_GNUC_VERSION) && \
448  !defined(__clang__) && \
449  !defined(JSON_HEDLEY_INTEL_VERSION) && \
450  !defined(JSON_HEDLEY_PGI_VERSION) && \
451  !defined(JSON_HEDLEY_ARM_VERSION) && \
452  !defined(JSON_HEDLEY_TI_VERSION) && \
453  !defined(__COMPCERT__)
454  #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
455 #endif
456 
457 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
458  #undef JSON_HEDLEY_GCC_VERSION_CHECK
459 #endif
460 #if defined(JSON_HEDLEY_GCC_VERSION)
461  #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
462 #else
463  #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
464 #endif
465 
466 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
467  #undef JSON_HEDLEY_HAS_ATTRIBUTE
468 #endif
469 #if defined(__has_attribute)
470  #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
471 #else
472  #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
473 #endif
474 
475 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
476  #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
477 #endif
478 #if defined(__has_attribute)
479  #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
480 #else
481  #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
482 #endif
483 
484 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
485  #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
486 #endif
487 #if defined(__has_attribute)
488  #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
489 #else
490  #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
491 #endif
492 
493 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
494  #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
495 #endif
496 #if \
497  defined(__has_cpp_attribute) && \
498  defined(__cplusplus) && \
499  (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
500  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
501 #else
502  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
503 #endif
504 
505 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
506  #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
507 #endif
508 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
509  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
510 #elif \
511  !defined(JSON_HEDLEY_PGI_VERSION) && \
512  (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
513  (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
514  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
515 #else
516  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
517 #endif
518 
519 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
520  #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
521 #endif
522 #if defined(__has_cpp_attribute) && defined(__cplusplus)
523  #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
524 #else
525  #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
526 #endif
527 
528 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
529  #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
530 #endif
531 #if defined(__has_cpp_attribute) && defined(__cplusplus)
532  #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
533 #else
534  #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
535 #endif
536 
537 #if defined(JSON_HEDLEY_HAS_BUILTIN)
538  #undef JSON_HEDLEY_HAS_BUILTIN
539 #endif
540 #if defined(__has_builtin)
541  #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
542 #else
543  #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
544 #endif
545 
546 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
547  #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
548 #endif
549 #if defined(__has_builtin)
550  #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
551 #else
552  #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
553 #endif
554 
555 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
556  #undef JSON_HEDLEY_GCC_HAS_BUILTIN
557 #endif
558 #if defined(__has_builtin)
559  #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
560 #else
561  #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
562 #endif
563 
564 #if defined(JSON_HEDLEY_HAS_FEATURE)
565  #undef JSON_HEDLEY_HAS_FEATURE
566 #endif
567 #if defined(__has_feature)
568  #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
569 #else
570  #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
571 #endif
572 
573 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
574  #undef JSON_HEDLEY_GNUC_HAS_FEATURE
575 #endif
576 #if defined(__has_feature)
577  #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
578 #else
579  #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
580 #endif
581 
582 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
583  #undef JSON_HEDLEY_GCC_HAS_FEATURE
584 #endif
585 #if defined(__has_feature)
586  #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
587 #else
588  #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
589 #endif
590 
591 #if defined(JSON_HEDLEY_HAS_EXTENSION)
592  #undef JSON_HEDLEY_HAS_EXTENSION
593 #endif
594 #if defined(__has_extension)
595  #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
596 #else
597  #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
598 #endif
599 
600 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
601  #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
602 #endif
603 #if defined(__has_extension)
604  #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
605 #else
606  #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
607 #endif
608 
609 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
610  #undef JSON_HEDLEY_GCC_HAS_EXTENSION
611 #endif
612 #if defined(__has_extension)
613  #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
614 #else
615  #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
616 #endif
617 
618 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
619  #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
620 #endif
621 #if defined(__has_declspec_attribute)
622  #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
623 #else
624  #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
625 #endif
626 
627 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
628  #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
629 #endif
630 #if defined(__has_declspec_attribute)
631  #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
632 #else
633  #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
634 #endif
635 
636 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
637  #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
638 #endif
639 #if defined(__has_declspec_attribute)
640  #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
641 #else
642  #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
643 #endif
644 
645 #if defined(JSON_HEDLEY_HAS_WARNING)
646  #undef JSON_HEDLEY_HAS_WARNING
647 #endif
648 #if defined(__has_warning)
649  #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
650 #else
651  #define JSON_HEDLEY_HAS_WARNING(warning) (0)
652 #endif
653 
654 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
655  #undef JSON_HEDLEY_GNUC_HAS_WARNING
656 #endif
657 #if defined(__has_warning)
658  #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
659 #else
660  #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
661 #endif
662 
663 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
664  #undef JSON_HEDLEY_GCC_HAS_WARNING
665 #endif
666 #if defined(__has_warning)
667  #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
668 #else
669  #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
670 #endif
671 
672 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
673  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
674 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
675  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
676 #endif
677 #if defined(__cplusplus) && JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
678 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
679  JSON_HEDLEY_DIAGNOSTIC_PUSH \
680  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
681  xpr \
682  JSON_HEDLEY_DIAGNOSTIC_POP
683 #else
684 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
685 #endif
686 
687 #if \
688  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
689  defined(__clang__) || \
690  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
691  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
692  JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
693  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
694  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
695  JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) || \
696  JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
697  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
698  JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
699  (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
700  #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
701 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
702  #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
703 #else
704  #define JSON_HEDLEY_PRAGMA(value)
705 #endif
706 
707 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
708  #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
709 #endif
710 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
711  #undef JSON_HEDLEY_DIAGNOSTIC_POP
712 #endif
713 #if defined(__clang__)
714  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
715  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
716 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
717  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
718  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
719 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
720  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
721  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
722 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
723  #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
724  #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
725 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
726  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
727  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
728 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,1,0)
729  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
730  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
731 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
732  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
733  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
734 #else
735  #define JSON_HEDLEY_DIAGNOSTIC_PUSH
736  #define JSON_HEDLEY_DIAGNOSTIC_POP
737 #endif
738 
739 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
740  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
741 #endif
742 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
743  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
744 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
745  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
746 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
747  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
748 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
749  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
750 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
751  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
752 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
753  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
754 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
755  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
756 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
757  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
758 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
759  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
760 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
761  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
762 #else
763  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
764 #endif
765 
766 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
767  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
768 #endif
769 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
770  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
771 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
772  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
773 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
774  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
775 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
776  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
777 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
778  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
779 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
780  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
781 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
782  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
783 #else
784  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
785 #endif
786 
787 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
788  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
789 #endif
790 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
791  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
792 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
793  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
794 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
795  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
796 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
797  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
798 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
799  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
800 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
801  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
802 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
803  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
804 #else
805  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
806 #endif
807 
808 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
809  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
810 #endif
811 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
812  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
813 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
814  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
815 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
816  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
817 #else
818  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
819 #endif
820 
821 #if defined(JSON_HEDLEY_DEPRECATED)
822  #undef JSON_HEDLEY_DEPRECATED
823 #endif
824 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
825  #undef JSON_HEDLEY_DEPRECATED_FOR
826 #endif
827 #if defined(__cplusplus) && (__cplusplus >= 201402L)
828  #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
829  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
830 #elif \
831  JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
832  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
833  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
834  JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
835  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
836  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
837  JSON_HEDLEY_TI_VERSION_CHECK(8,3,0)
838  #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
839  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
840 #elif \
841  JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
842  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
843  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
844  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
845  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
846  #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
847  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
848 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
849  #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
850  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
851 #elif \
852  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
853  JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
854  #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
855  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
856 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
857  #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
858  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
859 #else
860  #define JSON_HEDLEY_DEPRECATED(since)
861  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
862 #endif
863 
864 #if defined(JSON_HEDLEY_UNAVAILABLE)
865  #undef JSON_HEDLEY_UNAVAILABLE
866 #endif
867 #if \
868  JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
869  JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
870  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
871  #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
872 #else
873  #define JSON_HEDLEY_UNAVAILABLE(available_since)
874 #endif
875 
876 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
877  #undef JSON_HEDLEY_WARN_UNUSED_RESULT
878 #endif
879 #if defined(__cplusplus) && (__cplusplus >= 201703L)
880  #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
881 #elif \
882  JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
883  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
884  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
885  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
886  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
887  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
888  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
889  #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
890 #elif defined(_Check_return_) /* SAL */
891  #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
892 #else
893  #define JSON_HEDLEY_WARN_UNUSED_RESULT
894 #endif
895 
896 #if defined(JSON_HEDLEY_SENTINEL)
897  #undef JSON_HEDLEY_SENTINEL
898 #endif
899 #if \
900  JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
901  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
902  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
903  JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
904  #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
905 #else
906  #define JSON_HEDLEY_SENTINEL(position)
907 #endif
908 
909 #if defined(JSON_HEDLEY_NO_RETURN)
910  #undef JSON_HEDLEY_NO_RETURN
911 #endif
912 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
913  #define JSON_HEDLEY_NO_RETURN __noreturn
914 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
915  #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
916 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
917  #define JSON_HEDLEY_NO_RETURN _Noreturn
918 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
919  #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
920 #elif \
921  JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
922  JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
923  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
924  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
925  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
926  JSON_HEDLEY_TI_VERSION_CHECK(18,0,0) || \
927  (JSON_HEDLEY_TI_VERSION_CHECK(17,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
928  #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
929 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
930  #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
931 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
932  #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
933 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
934  #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
935 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
936  #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
937 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
938  #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
939 #else
940  #define JSON_HEDLEY_NO_RETURN
941 #endif
942 
943 #if defined(JSON_HEDLEY_NO_ESCAPE)
944  #undef JSON_HEDLEY_NO_ESCAPE
945 #endif
946 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
947  #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
948 #else
949  #define JSON_HEDLEY_NO_ESCAPE
950 #endif
951 
952 #if defined(JSON_HEDLEY_UNREACHABLE)
953  #undef JSON_HEDLEY_UNREACHABLE
954 #endif
955 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
956  #undef JSON_HEDLEY_UNREACHABLE_RETURN
957 #endif
958 #if \
959  (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
960  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
961  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
962  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
963  #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
964 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
965  #define JSON_HEDLEY_UNREACHABLE() __assume(0)
966 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
967  #if defined(__cplusplus)
968  #define JSON_HEDLEY_UNREACHABLE() std::_nassert(0)
969  #else
970  #define JSON_HEDLEY_UNREACHABLE() _nassert(0)
971  #endif
972  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
973 #elif defined(EXIT_FAILURE)
974  #define JSON_HEDLEY_UNREACHABLE() abort()
975 #else
976  #define JSON_HEDLEY_UNREACHABLE()
977  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
978 #endif
979 #if !defined(JSON_HEDLEY_UNREACHABLE_RETURN)
980  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
981 #endif
982 
983 #if defined(JSON_HEDLEY_ASSUME)
984  #undef JSON_HEDLEY_ASSUME
985 #endif
986 #if \
987  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
988  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
989  #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
990 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
991  #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
992 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
993  #if defined(__cplusplus)
994  #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
995  #else
996  #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
997  #endif
998 #elif \
999  (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && !defined(JSON_HEDLEY_ARM_VERSION)) || \
1000  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1001  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1002  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
1003  #define JSON_HEDLEY_ASSUME(expr) ((void) ((expr) ? 1 : (__builtin_unreachable(), 1)))
1004 #else
1005  #define JSON_HEDLEY_ASSUME(expr) ((void) (expr))
1006 #endif
1007 
1009 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1010  #pragma clang diagnostic ignored "-Wpedantic"
1011 #endif
1012 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1013  #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1014 #endif
1015 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1016  #if defined(__clang__)
1017  #pragma clang diagnostic ignored "-Wvariadic-macros"
1018  #elif defined(JSON_HEDLEY_GCC_VERSION)
1019  #pragma GCC diagnostic ignored "-Wvariadic-macros"
1020  #endif
1021 #endif
1022 #if defined(JSON_HEDLEY_NON_NULL)
1023  #undef JSON_HEDLEY_NON_NULL
1024 #endif
1025 #if \
1026  JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1027  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1028  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1029  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1030  #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1031 #else
1032  #define JSON_HEDLEY_NON_NULL(...)
1033 #endif
1035 
1036 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1037  #undef JSON_HEDLEY_PRINTF_FORMAT
1038 #endif
1039 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1040  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1041 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1042  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1043 #elif \
1044  JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1045  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1046  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1047  JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1048  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1049  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1050  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1051  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1052 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1053  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1054 #else
1055  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1056 #endif
1057 
1058 #if defined(JSON_HEDLEY_CONSTEXPR)
1059  #undef JSON_HEDLEY_CONSTEXPR
1060 #endif
1061 #if defined(__cplusplus)
1062  #if __cplusplus >= 201103L
1063  #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1064  #endif
1065 #endif
1066 #if !defined(JSON_HEDLEY_CONSTEXPR)
1067  #define JSON_HEDLEY_CONSTEXPR
1068 #endif
1069 
1070 #if defined(JSON_HEDLEY_PREDICT)
1071  #undef JSON_HEDLEY_PREDICT
1072 #endif
1073 #if defined(JSON_HEDLEY_LIKELY)
1074  #undef JSON_HEDLEY_LIKELY
1075 #endif
1076 #if defined(JSON_HEDLEY_UNLIKELY)
1077  #undef JSON_HEDLEY_UNLIKELY
1078 #endif
1079 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1080  #undef JSON_HEDLEY_UNPREDICTABLE
1081 #endif
1082 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1083  #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable(!!(expr))
1084 #endif
1085 #if \
1086  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
1087  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
1088 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(expr, value, probability)
1089 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1, probability)
1090 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0, probability)
1091 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1092 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1093 #if !defined(JSON_HEDLEY_BUILTIN_UNPREDICTABLE)
1094  #define JSON_HEDLEY_BUILTIN_UNPREDICTABLE(expr) __builtin_expect_with_probability(!!(expr), 1, 0.5)
1095 #endif
1096 #elif \
1097  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
1098  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1099  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1100  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1101  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1102  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1103  JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
1104  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27)
1105 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1106  (((probability) >= 0.9) ? __builtin_expect(!!(expr), (expected)) : (((void) (expected)), !!(expr)))
1107 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1108  (__extension__ ({ \
1109  JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
1110  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1111  }))
1112 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1113  (__extension__ ({ \
1114  JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
1115  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1116  }))
1117 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1118 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1119 #else
1120 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (((void) (expected)), !!(expr))
1121 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1122 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1123 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1124 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1125 #endif
1126 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1127  #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1128 #endif
1129 
1130 #if defined(JSON_HEDLEY_MALLOC)
1131  #undef JSON_HEDLEY_MALLOC
1132 #endif
1133 #if \
1134  JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1135  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1136  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1137  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1138  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1139  JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1140  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1141  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1142  #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1143 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1144  #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1145 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
1146  #define JSON_HEDLEY_MALLOC __declspec(restrict)
1147 #else
1148  #define JSON_HEDLEY_MALLOC
1149 #endif
1150 
1151 #if defined(JSON_HEDLEY_PURE)
1152  #undef JSON_HEDLEY_PURE
1153 #endif
1154 #if \
1155  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1156  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1157  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1158  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1159  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1160  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1161  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1162  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1163  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1164  #define JSON_HEDLEY_PURE __attribute__((__pure__))
1165 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1166  #define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1167 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1168  #define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1169 #else
1170  #define JSON_HEDLEY_PURE
1171 #endif
1172 
1173 #if defined(JSON_HEDLEY_CONST)
1174  #undef JSON_HEDLEY_CONST
1175 #endif
1176 #if \
1177  JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1178  JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1179  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1180  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1181  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1182  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1183  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1184  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1185  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1186  #define JSON_HEDLEY_CONST __attribute__((__const__))
1187 #elif \
1188  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1189  #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1190 #else
1191  #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1192 #endif
1193 
1194 #if defined(JSON_HEDLEY_RESTRICT)
1195  #undef JSON_HEDLEY_RESTRICT
1196 #endif
1197 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1198  #define JSON_HEDLEY_RESTRICT restrict
1199 #elif \
1200  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1201  JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1202  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1203  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1204  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1205  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1206  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1207  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1208  JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1209  defined(__clang__)
1210  #define JSON_HEDLEY_RESTRICT __restrict
1211 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1212  #define JSON_HEDLEY_RESTRICT _Restrict
1213 #else
1214  #define JSON_HEDLEY_RESTRICT
1215 #endif
1216 
1217 #if defined(JSON_HEDLEY_INLINE)
1218  #undef JSON_HEDLEY_INLINE
1219 #endif
1220 #if \
1221  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1222  (defined(__cplusplus) && (__cplusplus >= 199711L))
1223  #define JSON_HEDLEY_INLINE inline
1224 #elif \
1225  defined(JSON_HEDLEY_GCC_VERSION) || \
1226  JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1227  #define JSON_HEDLEY_INLINE __inline__
1228 #elif \
1229  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1230  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1231  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
1232  #define JSON_HEDLEY_INLINE __inline
1233 #else
1234  #define JSON_HEDLEY_INLINE
1235 #endif
1236 
1237 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1238  #undef JSON_HEDLEY_ALWAYS_INLINE
1239 #endif
1240 #if \
1241  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1242  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1243  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1244  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1245  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1246  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1247  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1248  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1249  #define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1250 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
1251  #define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1252 #elif JSON_HEDLEY_TI_VERSION_CHECK(7,0,0) && defined(__cplusplus)
1253  #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1254 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1255  #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1256 #else
1257  #define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1258 #endif
1259 
1260 #if defined(JSON_HEDLEY_NEVER_INLINE)
1261  #undef JSON_HEDLEY_NEVER_INLINE
1262 #endif
1263 #if \
1264  JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1265  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1266  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1267  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1268  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1269  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1270  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1271  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1272  #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1273 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1274  #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1275 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1276  #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1277 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1278  #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1279 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1280  #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1281 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1282  #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1283 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1284  #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1285 #else
1286  #define JSON_HEDLEY_NEVER_INLINE
1287 #endif
1288 
1289 #if defined(JSON_HEDLEY_PRIVATE)
1290  #undef JSON_HEDLEY_PRIVATE
1291 #endif
1292 #if defined(JSON_HEDLEY_PUBLIC)
1293  #undef JSON_HEDLEY_PUBLIC
1294 #endif
1295 #if defined(JSON_HEDLEY_IMPORT)
1296  #undef JSON_HEDLEY_IMPORT
1297 #endif
1298 #if defined(_WIN32) || defined(__CYGWIN__)
1299  #define JSON_HEDLEY_PRIVATE
1300  #define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1301  #define JSON_HEDLEY_IMPORT __declspec(dllimport)
1302 #else
1303  #if \
1304  JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1305  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1306  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1307  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1308  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1309  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1310  JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1311  (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_EABI__) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1312  #define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1313  #define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1314  #else
1315  #define JSON_HEDLEY_PRIVATE
1316  #define JSON_HEDLEY_PUBLIC
1317  #endif
1318  #define JSON_HEDLEY_IMPORT extern
1319 #endif
1320 
1321 #if defined(JSON_HEDLEY_NO_THROW)
1322  #undef JSON_HEDLEY_NO_THROW
1323 #endif
1324 #if \
1325  JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1326  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1327  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1328  #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1329 #elif \
1330  JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1331  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1332  #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1333 #else
1334  #define JSON_HEDLEY_NO_THROW
1335 #endif
1336 
1337 #if defined(JSON_HEDLEY_FALL_THROUGH)
1338  #undef JSON_HEDLEY_FALL_THROUGH
1339 #endif
1340 #if JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(fallthrough,7,0,0) && !defined(JSON_HEDLEY_PGI_VERSION)
1341  #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1342 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1343  #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1344 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1345  #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1346 #elif defined(__fallthrough) /* SAL */
1347  #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1348 #else
1349  #define JSON_HEDLEY_FALL_THROUGH
1350 #endif
1351 
1352 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1353  #undef JSON_HEDLEY_RETURNS_NON_NULL
1354 #endif
1355 #if \
1356  JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1357  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
1358  #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1359 #elif defined(_Ret_notnull_) /* SAL */
1360  #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1361 #else
1362  #define JSON_HEDLEY_RETURNS_NON_NULL
1363 #endif
1364 
1365 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1366  #undef JSON_HEDLEY_ARRAY_PARAM
1367 #endif
1368 #if \
1369  defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1370  !defined(__STDC_NO_VLA__) && \
1371  !defined(__cplusplus) && \
1372  !defined(JSON_HEDLEY_PGI_VERSION) && \
1373  !defined(JSON_HEDLEY_TINYC_VERSION)
1374  #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1375 #else
1376  #define JSON_HEDLEY_ARRAY_PARAM(name)
1377 #endif
1378 
1379 #if defined(JSON_HEDLEY_IS_CONSTANT)
1380  #undef JSON_HEDLEY_IS_CONSTANT
1381 #endif
1382 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1383  #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1384 #endif
1385 /* JSON_HEDLEY_IS_CONSTEXPR_ is for
1386  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
1387 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1388  #undef JSON_HEDLEY_IS_CONSTEXPR_
1389 #endif
1390 #if \
1391  JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1392  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1393  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1394  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1395  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1396  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1397  JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
1398  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1399  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1400  #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1401 #endif
1402 #if !defined(__cplusplus)
1403 # if \
1404  JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1405  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1406  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1407  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1408  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1409  JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1410  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1411 #if defined(__INTPTR_TYPE__)
1412  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1413 #else
1414  #include <stdint.h>
1415  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1416 #endif
1417 # elif \
1418  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(JSON_HEDLEY_SUNPRO_VERSION) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1419  JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
1420  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1421  JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1422  JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1423  JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1424 #if defined(__INTPTR_TYPE__)
1425  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1426 #else
1427  #include <stdint.h>
1428  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1429 #endif
1430 # elif \
1431  defined(JSON_HEDLEY_GCC_VERSION) || \
1432  defined(JSON_HEDLEY_INTEL_VERSION) || \
1433  defined(JSON_HEDLEY_TINYC_VERSION) || \
1434  defined(JSON_HEDLEY_TI_VERSION) || \
1435  defined(__clang__)
1436 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1437  sizeof(void) != \
1438  sizeof(*( \
1439  1 ? \
1440  ((void*) ((expr) * 0L) ) : \
1441 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1442  ) \
1443  ) \
1444  )
1445 # endif
1446 #endif
1447 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1448  #if !defined(JSON_HEDLEY_IS_CONSTANT)
1449  #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1450  #endif
1451  #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1452 #else
1453  #if !defined(JSON_HEDLEY_IS_CONSTANT)
1454  #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1455  #endif
1456  #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1457 #endif
1458 
1459 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1460  #undef JSON_HEDLEY_BEGIN_C_DECLS
1461 #endif
1462 #if defined(JSON_HEDLEY_END_C_DECLS)
1463  #undef JSON_HEDLEY_END_C_DECLS
1464 #endif
1465 #if defined(JSON_HEDLEY_C_DECL)
1466  #undef JSON_HEDLEY_C_DECL
1467 #endif
1468 #if defined(__cplusplus)
1469  #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1470  #define JSON_HEDLEY_END_C_DECLS }
1471  #define JSON_HEDLEY_C_DECL extern "C"
1472 #else
1473  #define JSON_HEDLEY_BEGIN_C_DECLS
1474  #define JSON_HEDLEY_END_C_DECLS
1475  #define JSON_HEDLEY_C_DECL
1476 #endif
1477 
1478 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1479  #undef JSON_HEDLEY_STATIC_ASSERT
1480 #endif
1481 #if \
1482  !defined(__cplusplus) && ( \
1483  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1484  JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
1485  JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1486  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1487  defined(_Static_assert) \
1488  )
1489 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1490 #elif \
1491  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1492  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
1493  (defined(__cplusplus) && JSON_HEDLEY_TI_VERSION_CHECK(8,3,0))
1494 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1495 #else
1496 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1497 #endif
1498 
1499 #if defined(JSON_HEDLEY_CONST_CAST)
1500  #undef JSON_HEDLEY_CONST_CAST
1501 #endif
1502 #if defined(__cplusplus)
1503 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1504 #elif \
1505  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1506  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1507  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1508 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1509  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1510  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1511  ((T) (expr)); \
1512  JSON_HEDLEY_DIAGNOSTIC_POP \
1513  }))
1514 #else
1515 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1516 #endif
1517 
1518 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
1519  #undef JSON_HEDLEY_REINTERPRET_CAST
1520 #endif
1521 #if defined(__cplusplus)
1522  #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1523 #else
1524  #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (*((T*) &(expr)))
1525 #endif
1526 
1527 #if defined(JSON_HEDLEY_STATIC_CAST)
1528  #undef JSON_HEDLEY_STATIC_CAST
1529 #endif
1530 #if defined(__cplusplus)
1531  #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1532 #else
1533  #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1534 #endif
1535 
1536 #if defined(JSON_HEDLEY_CPP_CAST)
1537  #undef JSON_HEDLEY_CPP_CAST
1538 #endif
1539 #if defined(__cplusplus)
1540  #define JSON_HEDLEY_CPP_CAST(T, expr) static_cast<T>(expr)
1541 #else
1542  #define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1543 #endif
1544 
1545 #if defined(JSON_HEDLEY_NULL)
1546  #undef JSON_HEDLEY_NULL
1547 #endif
1548 #if defined(__cplusplus)
1549  #if __cplusplus >= 201103L
1550  #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1551  #elif defined(NULL)
1552  #define JSON_HEDLEY_NULL NULL
1553  #else
1554  #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1555  #endif
1556 #elif defined(NULL)
1557  #define JSON_HEDLEY_NULL NULL
1558 #else
1559  #define JSON_HEDLEY_NULL ((void*) 0)
1560 #endif
1561 
1562 #if defined(JSON_HEDLEY_MESSAGE)
1563  #undef JSON_HEDLEY_MESSAGE
1564 #endif
1565 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1566 # define JSON_HEDLEY_MESSAGE(msg) \
1567  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1568  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1569  JSON_HEDLEY_PRAGMA(message msg) \
1570  JSON_HEDLEY_DIAGNOSTIC_POP
1571 #elif \
1572  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1573  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1574 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1575 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1576 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1577 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1578 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1579 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1580 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1581 #else
1582 # define JSON_HEDLEY_MESSAGE(msg)
1583 #endif
1584 
1585 #if defined(JSON_HEDLEY_WARNING)
1586  #undef JSON_HEDLEY_WARNING
1587 #endif
1588 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1589 # define JSON_HEDLEY_WARNING(msg) \
1590  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1591  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1592  JSON_HEDLEY_PRAGMA(clang warning msg) \
1593  JSON_HEDLEY_DIAGNOSTIC_POP
1594 #elif \
1595  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1596  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0)
1597 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1598 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1599 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1600 #else
1601 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1602 #endif
1603 
1604 #if defined(JSON_HEDLEY_REQUIRE)
1605  #undef JSON_HEDLEY_REQUIRE
1606 #endif
1607 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1608  #undef JSON_HEDLEY_REQUIRE_MSG
1609 #endif
1610 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1611 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1612 # define JSON_HEDLEY_REQUIRE(expr) \
1613  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1614  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1615  __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1616  JSON_HEDLEY_DIAGNOSTIC_POP
1617 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1618  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1619  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1620  __attribute__((diagnose_if(!(expr), msg, "error"))) \
1621  JSON_HEDLEY_DIAGNOSTIC_POP
1622 # else
1623 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1624 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1625 # endif
1626 #else
1627 # define JSON_HEDLEY_REQUIRE(expr)
1628 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1629 #endif
1630 
1631 #if defined(JSON_HEDLEY_FLAGS)
1632  #undef JSON_HEDLEY_FLAGS
1633 #endif
1634 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1635  #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1636 #endif
1637 
1638 #if defined(JSON_HEDLEY_FLAGS_CAST)
1639  #undef JSON_HEDLEY_FLAGS_CAST
1640 #endif
1641 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1642 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1643  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1644  _Pragma("warning(disable:188)") \
1645  ((T) (expr)); \
1646  JSON_HEDLEY_DIAGNOSTIC_POP \
1647  }))
1648 #else
1649 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1650 #endif
1651 
1652 #if defined(JSON_HEDLEY_EMPTY_BASES)
1653  #undef JSON_HEDLEY_EMPTY_BASES
1654 #endif
1655 #if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
1656  #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1657 #else
1658  #define JSON_HEDLEY_EMPTY_BASES
1659 #endif
1660 
1661 /* Remaining macros are deprecated. */
1662 
1663 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1664  #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1665 #endif
1666 #if defined(__clang__)
1667  #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1668 #else
1669  #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1670 #endif
1671 
1672 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1673  #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1674 #endif
1675 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1676 
1677 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1678  #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1679 #endif
1680 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1681 
1682 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1683  #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1684 #endif
1685 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
1686 
1687 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
1688  #undef JSON_HEDLEY_CLANG_HAS_FEATURE
1689 #endif
1690 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
1691 
1692 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
1693  #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
1694 #endif
1695 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
1696 
1697 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
1698  #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
1699 #endif
1700 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
1701 
1702 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
1703  #undef JSON_HEDLEY_CLANG_HAS_WARNING
1704 #endif
1705 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
1706 
1707 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
1708 
1709 
1710 // This file contains all internal macro definitions
1711 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
1712 
1713 // exclude unsupported compilers
1714 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
1715  #if defined(__clang__)
1716  #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
1717  #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
1718  #endif
1719  #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
1720  #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
1721  #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
1722  #endif
1723  #endif
1724 #endif
1725 
1726 // C++ language standard detection
1727 #if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
1728  #define JSON_HAS_CPP_17
1729  #define JSON_HAS_CPP_14
1730 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
1731  #define JSON_HAS_CPP_14
1732 #endif
1733 
1734 // disable float-equal warnings on GCC/clang
1735 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
1736  #pragma GCC diagnostic push
1737  #pragma GCC diagnostic ignored "-Wfloat-equal"
1738 #endif
1739 
1740 // disable documentation warnings on clang
1741 #if defined(__clang__)
1742  #pragma GCC diagnostic push
1743  #pragma GCC diagnostic ignored "-Wdocumentation"
1744 #endif
1745 
1746 // allow to disable exceptions
1747 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
1748  #define JSON_THROW(exception) throw exception
1749  #define JSON_TRY try
1750  #define JSON_CATCH(exception) catch(exception)
1751  #define JSON_INTERNAL_CATCH(exception) catch(exception)
1752 #else
1753  #include <cstdlib>
1754  #define JSON_THROW(exception) std::abort()
1755  #define JSON_TRY if(true)
1756  #define JSON_CATCH(exception) if(false)
1757  #define JSON_INTERNAL_CATCH(exception) if(false)
1758 #endif
1759 
1760 // override exception macros
1761 #if defined(JSON_THROW_USER)
1762  #undef JSON_THROW
1763  #define JSON_THROW JSON_THROW_USER
1764 #endif
1765 #if defined(JSON_TRY_USER)
1766  #undef JSON_TRY
1767  #define JSON_TRY JSON_TRY_USER
1768 #endif
1769 #if defined(JSON_CATCH_USER)
1770  #undef JSON_CATCH
1771  #define JSON_CATCH JSON_CATCH_USER
1772  #undef JSON_INTERNAL_CATCH
1773  #define JSON_INTERNAL_CATCH JSON_CATCH_USER
1774 #endif
1775 #if defined(JSON_INTERNAL_CATCH_USER)
1776  #undef JSON_INTERNAL_CATCH
1777  #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
1778 #endif
1779 
1785 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
1786  template<typename BasicJsonType> \
1787  inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
1788  { \
1789  static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
1790  static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
1791  auto it = std::find_if(std::begin(m), std::end(m), \
1792  [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
1793  { \
1794  return ej_pair.first == e; \
1795  }); \
1796  j = ((it != std::end(m)) ? it : std::begin(m))->second; \
1797  } \
1798  template<typename BasicJsonType> \
1799  inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
1800  { \
1801  static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
1802  static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
1803  auto it = std::find_if(std::begin(m), std::end(m), \
1804  [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
1805  { \
1806  return ej_pair.second == j; \
1807  }); \
1808  e = ((it != std::end(m)) ? it : std::begin(m))->first; \
1809  }
1810 
1811 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
1812 // may be removed in the future once the class is split.
1813 
1814 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
1815  template<template<typename, typename, typename...> class ObjectType, \
1816  template<typename, typename...> class ArrayType, \
1817  class StringType, class BooleanType, class NumberIntegerType, \
1818  class NumberUnsignedType, class NumberFloatType, \
1819  template<typename> class AllocatorType, \
1820  template<typename, typename = void> class JSONSerializer>
1821 
1822 #define NLOHMANN_BASIC_JSON_TPL \
1823  basic_json<ObjectType, ArrayType, StringType, BooleanType, \
1824  NumberIntegerType, NumberUnsignedType, NumberFloatType, \
1825  AllocatorType, JSONSerializer>
1826 
1827 
1828 namespace nlohmann
1829 {
1830 namespace detail
1831 {
1833 // exceptions //
1835 
1864 class exception : public std::exception
1865 {
1866  public:
1869  const char* what() const noexcept override
1870  {
1871  return m.what();
1872  }
1873 
1875  const int id;
1876 
1877  protected:
1879  exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
1880 
1881  static std::string name(const std::string& ename, int id_)
1882  {
1883  return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
1884  }
1885 
1886  private:
1888  std::runtime_error m;
1889 };
1890 
1935 class parse_error : public exception
1936 {
1937  public:
1947  static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
1948  {
1949  std::string w = exception::name("parse_error", id_) + "parse error" +
1950  position_string(pos) + ": " + what_arg;
1951  return parse_error(id_, pos.chars_read_total, w.c_str());
1952  }
1953 
1954  static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
1955  {
1956  std::string w = exception::name("parse_error", id_) + "parse error" +
1957  (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
1958  ": " + what_arg;
1959  return parse_error(id_, byte_, w.c_str());
1960  }
1961 
1971  const std::size_t byte;
1972 
1973  private:
1974  parse_error(int id_, std::size_t byte_, const char* what_arg)
1975  : exception(id_, what_arg), byte(byte_) {}
1976 
1977  static std::string position_string(const position_t& pos)
1978  {
1979  return " at line " + std::to_string(pos.lines_read + 1) +
1980  ", column " + std::to_string(pos.chars_read_current_line);
1981  }
1982 };
1983 
2022 {
2023  public:
2024  static invalid_iterator create(int id_, const std::string& what_arg)
2025  {
2026  std::string w = exception::name("invalid_iterator", id_) + what_arg;
2027  return invalid_iterator(id_, w.c_str());
2028  }
2029 
2030  private:
2032  invalid_iterator(int id_, const char* what_arg)
2033  : exception(id_, what_arg) {}
2034 };
2035 
2075 class type_error : public exception
2076 {
2077  public:
2078  static type_error create(int id_, const std::string& what_arg)
2079  {
2080  std::string w = exception::name("type_error", id_) + what_arg;
2081  return type_error(id_, w.c_str());
2082  }
2083 
2084  private:
2086  type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2087 };
2088 
2122 class out_of_range : public exception
2123 {
2124  public:
2125  static out_of_range create(int id_, const std::string& what_arg)
2126  {
2127  std::string w = exception::name("out_of_range", id_) + what_arg;
2128  return out_of_range(id_, w.c_str());
2129  }
2130 
2131  private:
2133  out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
2134 };
2135 
2160 class other_error : public exception
2161 {
2162  public:
2163  static other_error create(int id_, const std::string& what_arg)
2164  {
2165  std::string w = exception::name("other_error", id_) + what_arg;
2166  return other_error(id_, w.c_str());
2167  }
2168 
2169  private:
2171  other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2172 };
2173 } // namespace detail
2174 } // namespace nlohmann
2175 
2176 // #include <nlohmann/detail/macro_scope.hpp>
2177 
2178 // #include <nlohmann/detail/meta/cpp_future.hpp>
2179 
2180 
2181 #include <ciso646> // not
2182 #include <cstddef> // size_t
2183 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
2184 
2185 namespace nlohmann
2186 {
2187 namespace detail
2188 {
2189 // alias templates to reduce boilerplate
2190 template<bool B, typename T = void>
2191 using enable_if_t = typename std::enable_if<B, T>::type;
2192 
2193 template<typename T>
2194 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
2195 
2196 // implementation of C++14 index_sequence and affiliates
2197 // source: https://stackoverflow.com/a/32223343
2198 template<std::size_t... Ints>
2200 {
2202  using value_type = std::size_t;
2203  static constexpr std::size_t size() noexcept
2204  {
2205  return sizeof...(Ints);
2206  }
2207 };
2208 
2209 template<class Sequence1, class Sequence2>
2211 
2212 template<std::size_t... I1, std::size_t... I2>
2214  : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
2215 
2216 template<std::size_t N>
2218  : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
2219  typename make_index_sequence < N - N / 2 >::type > {};
2220 
2221 template<> struct make_index_sequence<0> : index_sequence<> {};
2222 template<> struct make_index_sequence<1> : index_sequence<0> {};
2223 
2224 template<typename... Ts>
2226 
2227 // dispatch utility (taken from ranges-v3)
2228 template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
2229 template<> struct priority_tag<0> {};
2230 
2231 // taken from ranges-v3
2232 template<typename T>
2234 {
2235  static constexpr T value{};
2236 };
2237 
2238 template<typename T>
2239 constexpr T static_const<T>::value;
2240 } // namespace detail
2241 } // namespace nlohmann
2242 
2243 // #include <nlohmann/detail/meta/type_traits.hpp>
2244 
2245 
2246 #include <ciso646> // not
2247 #include <limits> // numeric_limits
2248 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
2249 #include <utility> // declval
2250 
2251 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
2252 
2253 
2254 #include <iterator> // random_access_iterator_tag
2255 
2256 // #include <nlohmann/detail/meta/void_t.hpp>
2257 
2258 
2259 namespace nlohmann
2260 {
2261 namespace detail
2262 {
2263 template <typename ...Ts> struct make_void
2264 {
2265  using type = void;
2266 };
2267 template <typename ...Ts> using void_t = typename make_void<Ts...>::type;
2268 } // namespace detail
2269 } // namespace nlohmann
2270 
2271 // #include <nlohmann/detail/meta/cpp_future.hpp>
2272 
2273 
2274 namespace nlohmann
2275 {
2276 namespace detail
2277 {
2278 template <typename It, typename = void>
2279 struct iterator_types {};
2280 
2281 template <typename It>
2283  It,
2284  void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
2285  typename It::reference, typename It::iterator_category >>
2286 {
2287  using difference_type = typename It::difference_type;
2288  using value_type = typename It::value_type;
2289  using pointer = typename It::pointer;
2290  using reference = typename It::reference;
2291  using iterator_category = typename It::iterator_category;
2292 };
2293 
2294 // This is required as some compilers implement std::iterator_traits in a way that
2295 // doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
2296 template <typename T, typename = void>
2298 {
2299 };
2300 
2301 template <typename T>
2302 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
2303  : iterator_types<T>
2304 {
2305 };
2306 
2307 template <typename T>
2309 {
2310  using iterator_category = std::random_access_iterator_tag;
2311  using value_type = T;
2312  using difference_type = ptrdiff_t;
2313  using pointer = T*;
2314  using reference = T&;
2315 };
2316 } // namespace detail
2317 } // namespace nlohmann
2318 
2319 // #include <nlohmann/detail/macro_scope.hpp>
2320 
2321 // #include <nlohmann/detail/meta/cpp_future.hpp>
2322 
2323 // #include <nlohmann/detail/meta/detected.hpp>
2324 
2325 
2326 #include <type_traits>
2327 
2328 // #include <nlohmann/detail/meta/void_t.hpp>
2329 
2330 
2331 // http://en.cppreference.com/w/cpp/experimental/is_detected
2332 namespace nlohmann
2333 {
2334 namespace detail
2335 {
2336 struct nonesuch
2337 {
2338  nonesuch() = delete;
2339  ~nonesuch() = delete;
2340  nonesuch(nonesuch const&) = delete;
2341  nonesuch(nonesuch const&&) = delete;
2342  void operator=(nonesuch const&) = delete;
2343  void operator=(nonesuch&&) = delete;
2344 };
2345 
2346 template <class Default,
2347  class AlwaysVoid,
2348  template <class...> class Op,
2349  class... Args>
2350 struct detector
2351 {
2352  using value_t = std::false_type;
2353  using type = Default;
2354 };
2355 
2356 template <class Default, template <class...> class Op, class... Args>
2357 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2358 {
2359  using value_t = std::true_type;
2360  using type = Op<Args...>;
2361 };
2362 
2363 template <template <class...> class Op, class... Args>
2364 using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
2365 
2366 template <template <class...> class Op, class... Args>
2367 using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
2368 
2369 template <class Default, template <class...> class Op, class... Args>
2370 using detected_or = detector<Default, void, Op, Args...>;
2371 
2372 template <class Default, template <class...> class Op, class... Args>
2373 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
2374 
2375 template <class Expected, template <class...> class Op, class... Args>
2376 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2377 
2378 template <class To, template <class...> class Op, class... Args>
2380  std::is_convertible<detected_t<Op, Args...>, To>;
2381 } // namespace detail
2382 } // namespace nlohmann
2383 
2384 // #include <nlohmann/json_fwd.hpp>
2385 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
2386 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
2387 
2388 #include <cstdint> // int64_t, uint64_t
2389 #include <map> // map
2390 #include <memory> // allocator
2391 #include <string> // string
2392 #include <vector> // vector
2393 
2399 namespace nlohmann
2400 {
2408 template<typename T = void, typename SFINAE = void>
2410 
2411 template<template<typename U, typename V, typename... Args> class ObjectType =
2412  std::map,
2413  template<typename U, typename... Args> class ArrayType = std::vector,
2414  class StringType = std::string, class BooleanType = bool,
2415  class NumberIntegerType = std::int64_t,
2416  class NumberUnsignedType = std::uint64_t,
2417  class NumberFloatType = double,
2418  template<typename U> class AllocatorType = std::allocator,
2419  template<typename T, typename SFINAE = void> class JSONSerializer =
2422 
2434 template<typename BasicJsonType>
2436 
2446 } // namespace nlohmann
2447 
2448 #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
2449 
2450 
2451 namespace nlohmann
2452 {
2461 namespace detail
2462 {
2464 // helpers //
2466 
2467 // Note to maintainers:
2468 //
2469 // Every trait in this file expects a non CV-qualified type.
2470 // The only exceptions are in the 'aliases for detected' section
2471 // (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
2472 //
2473 // In this case, T has to be properly CV-qualified to constraint the function arguments
2474 // (e.g. to_json(BasicJsonType&, const T&))
2475 
2476 template<typename> struct is_basic_json : std::false_type {};
2477 
2479 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
2480 
2482 // aliases for detected //
2484 
2485 template <typename T>
2486 using mapped_type_t = typename T::mapped_type;
2487 
2488 template <typename T>
2489 using key_type_t = typename T::key_type;
2490 
2491 template <typename T>
2492 using value_type_t = typename T::value_type;
2493 
2494 template <typename T>
2495 using difference_type_t = typename T::difference_type;
2496 
2497 template <typename T>
2498 using pointer_t = typename T::pointer;
2499 
2500 template <typename T>
2501 using reference_t = typename T::reference;
2502 
2503 template <typename T>
2504 using iterator_category_t = typename T::iterator_category;
2505 
2506 template <typename T>
2507 using iterator_t = typename T::iterator;
2508 
2509 template <typename T, typename... Args>
2510 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
2511 
2512 template <typename T, typename... Args>
2513 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
2514 
2515 template <typename T, typename U>
2516 using get_template_function = decltype(std::declval<T>().template get<U>());
2517 
2518 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
2519 template <typename BasicJsonType, typename T, typename = void>
2520 struct has_from_json : std::false_type {};
2521 
2522 template <typename BasicJsonType, typename T>
2523 struct has_from_json<BasicJsonType, T,
2525 {
2526  using serializer = typename BasicJsonType::template json_serializer<T, void>;
2527 
2528  static constexpr bool value =
2530  const BasicJsonType&, T&>::value;
2531 };
2532 
2533 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
2534 // this overload is used for non-default-constructible user-defined-types
2535 template <typename BasicJsonType, typename T, typename = void>
2536 struct has_non_default_from_json : std::false_type {};
2537 
2538 template<typename BasicJsonType, typename T>
2540 {
2541  using serializer = typename BasicJsonType::template json_serializer<T, void>;
2542 
2543  static constexpr bool value =
2545  const BasicJsonType&>::value;
2546 };
2547 
2548 // This trait checks if BasicJsonType::json_serializer<T>::to_json exists
2549 // Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
2550 template <typename BasicJsonType, typename T, typename = void>
2551 struct has_to_json : std::false_type {};
2552 
2553 template <typename BasicJsonType, typename T>
2554 struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
2555 {
2556  using serializer = typename BasicJsonType::template json_serializer<T, void>;
2557 
2558  static constexpr bool value =
2560  T>::value;
2561 };
2562 
2563 
2565 // is_ functions //
2567 
2568 template <typename T, typename = void>
2569 struct is_iterator_traits : std::false_type {};
2570 
2571 template <typename T>
2573 {
2574  private:
2576 
2577  public:
2578  static constexpr auto value =
2584 };
2585 
2586 // source: https://stackoverflow.com/a/37193089/4116453
2587 
2588 template <typename T, typename = void>
2589 struct is_complete_type : std::false_type {};
2590 
2591 template <typename T>
2592 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
2593 
2594 template <typename BasicJsonType, typename CompatibleObjectType,
2595  typename = void>
2596 struct is_compatible_object_type_impl : std::false_type {};
2597 
2598 template <typename BasicJsonType, typename CompatibleObjectType>
2600  BasicJsonType, CompatibleObjectType,
2601  enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value and
2602  is_detected<key_type_t, CompatibleObjectType>::value >>
2603 {
2604 
2605  using object_t = typename BasicJsonType::object_t;
2606 
2607  // macOS's is_constructible does not play well with nonesuch...
2608  static constexpr bool value =
2609  std::is_constructible<typename object_t::key_type,
2610  typename CompatibleObjectType::key_type>::value and
2611  std::is_constructible<typename object_t::mapped_type,
2612  typename CompatibleObjectType::mapped_type>::value;
2613 };
2614 
2615 template <typename BasicJsonType, typename CompatibleObjectType>
2617  : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
2618 
2619 template <typename BasicJsonType, typename ConstructibleObjectType,
2620  typename = void>
2621 struct is_constructible_object_type_impl : std::false_type {};
2622 
2623 template <typename BasicJsonType, typename ConstructibleObjectType>
2625  BasicJsonType, ConstructibleObjectType,
2626  enable_if_t<is_detected<mapped_type_t, ConstructibleObjectType>::value and
2627  is_detected<key_type_t, ConstructibleObjectType>::value >>
2628 {
2629  using object_t = typename BasicJsonType::object_t;
2630 
2631  static constexpr bool value =
2635  (std::is_constructible<typename ConstructibleObjectType::key_type,
2636  typename object_t::key_type>::value and
2637  std::is_same <
2638  typename object_t::mapped_type,
2639  typename ConstructibleObjectType::mapped_type >::value)) or
2640  (has_from_json<BasicJsonType,
2641  typename ConstructibleObjectType::mapped_type>::value or
2643  BasicJsonType,
2644  typename ConstructibleObjectType::mapped_type >::value);
2645 };
2646 
2647 template <typename BasicJsonType, typename ConstructibleObjectType>
2649  : is_constructible_object_type_impl<BasicJsonType,
2650  ConstructibleObjectType> {};
2651 
2652 template <typename BasicJsonType, typename CompatibleStringType,
2653  typename = void>
2654 struct is_compatible_string_type_impl : std::false_type {};
2655 
2656 template <typename BasicJsonType, typename CompatibleStringType>
2658  BasicJsonType, CompatibleStringType,
2659  enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
2660  value_type_t, CompatibleStringType>::value >>
2661 {
2662  static constexpr auto value =
2664 };
2665 
2666 template <typename BasicJsonType, typename ConstructibleStringType>
2668  : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
2669 
2670 template <typename BasicJsonType, typename ConstructibleStringType,
2671  typename = void>
2672 struct is_constructible_string_type_impl : std::false_type {};
2673 
2674 template <typename BasicJsonType, typename ConstructibleStringType>
2676  BasicJsonType, ConstructibleStringType,
2677  enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
2678  value_type_t, ConstructibleStringType>::value >>
2679 {
2680  static constexpr auto value =
2681  std::is_constructible<ConstructibleStringType,
2682  typename BasicJsonType::string_t>::value;
2683 };
2684 
2685 template <typename BasicJsonType, typename ConstructibleStringType>
2687  : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
2688 
2689 template <typename BasicJsonType, typename CompatibleArrayType, typename = void>
2690 struct is_compatible_array_type_impl : std::false_type {};
2691 
2692 template <typename BasicJsonType, typename CompatibleArrayType>
2694  BasicJsonType, CompatibleArrayType,
2695  enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and
2696  is_detected<iterator_t, CompatibleArrayType>::value and
2697 // This is needed because json_reverse_iterator has a ::iterator type...
2698 // Therefore it is detected as a CompatibleArrayType.
2699 // The real fix would be to have an Iterable concept.
2700  not is_iterator_traits<
2701  iterator_traits<CompatibleArrayType>>::value >>
2702 {
2703  static constexpr bool value =
2704  std::is_constructible<BasicJsonType,
2705  typename CompatibleArrayType::value_type>::value;
2706 };
2707 
2708 template <typename BasicJsonType, typename CompatibleArrayType>
2710  : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
2711 
2712 template <typename BasicJsonType, typename ConstructibleArrayType, typename = void>
2713 struct is_constructible_array_type_impl : std::false_type {};
2714 
2715 template <typename BasicJsonType, typename ConstructibleArrayType>
2717  BasicJsonType, ConstructibleArrayType,
2718  enable_if_t<std::is_same<ConstructibleArrayType,
2719  typename BasicJsonType::value_type>::value >>
2720  : std::true_type {};
2721 
2722 template <typename BasicJsonType, typename ConstructibleArrayType>
2724  BasicJsonType, ConstructibleArrayType,
2725  enable_if_t<not std::is_same<ConstructibleArrayType,
2726  typename BasicJsonType::value_type>::value and
2727  std::is_default_constructible<ConstructibleArrayType>::value and
2728 (std::is_move_assignable<ConstructibleArrayType>::value or
2729  std::is_copy_assignable<ConstructibleArrayType>::value) and
2730 is_detected<value_type_t, ConstructibleArrayType>::value and
2731 is_detected<iterator_t, ConstructibleArrayType>::value and
2733 detected_t<value_type_t, ConstructibleArrayType>>::value >>
2734 {
2735  static constexpr bool value =
2736  // This is needed because json_reverse_iterator has a ::iterator type,
2737  // furthermore, std::back_insert_iterator (and other iterators) have a
2738  // base class `iterator`... Therefore it is detected as a
2739  // ConstructibleArrayType. The real fix would be to have an Iterable
2740  // concept.
2742 
2743  (std::is_same<typename ConstructibleArrayType::value_type,
2744  typename BasicJsonType::array_t::value_type>::value or
2745  has_from_json<BasicJsonType,
2746  typename ConstructibleArrayType::value_type>::value or
2748  BasicJsonType, typename ConstructibleArrayType::value_type >::value);
2749 };
2750 
2751 template <typename BasicJsonType, typename ConstructibleArrayType>
2753  : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
2754 
2755 template <typename RealIntegerType, typename CompatibleNumberIntegerType,
2756  typename = void>
2757 struct is_compatible_integer_type_impl : std::false_type {};
2758 
2759 template <typename RealIntegerType, typename CompatibleNumberIntegerType>
2761  RealIntegerType, CompatibleNumberIntegerType,
2762  enable_if_t<std::is_integral<RealIntegerType>::value and
2763  std::is_integral<CompatibleNumberIntegerType>::value and
2764  not std::is_same<bool, CompatibleNumberIntegerType>::value >>
2765 {
2766  // is there an assert somewhere on overflows?
2767  using RealLimits = std::numeric_limits<RealIntegerType>;
2768  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
2769 
2770  static constexpr auto value =
2771  std::is_constructible<RealIntegerType,
2772  CompatibleNumberIntegerType>::value and
2773  CompatibleLimits::is_integer and
2774  RealLimits::is_signed == CompatibleLimits::is_signed;
2775 };
2776 
2777 template <typename RealIntegerType, typename CompatibleNumberIntegerType>
2779  : is_compatible_integer_type_impl<RealIntegerType,
2780  CompatibleNumberIntegerType> {};
2781 
2782 template <typename BasicJsonType, typename CompatibleType, typename = void>
2783 struct is_compatible_type_impl: std::false_type {};
2784 
2785 template <typename BasicJsonType, typename CompatibleType>
2787  BasicJsonType, CompatibleType,
2788  enable_if_t<is_complete_type<CompatibleType>::value >>
2789 {
2790  static constexpr bool value =
2792 };
2793 
2794 template <typename BasicJsonType, typename CompatibleType>
2796  : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
2797 
2798 // https://en.cppreference.com/w/cpp/types/conjunction
2799 template<class...> struct conjunction : std::true_type { };
2800 template<class B1> struct conjunction<B1> : B1 { };
2801 template<class B1, class... Bn>
2802 struct conjunction<B1, Bn...>
2803 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
2804 
2805 template <typename T1, typename T2>
2806 struct is_constructible_tuple : std::false_type {};
2807 
2808 template <typename T1, typename... Args>
2809 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
2810 } // namespace detail
2811 } // namespace nlohmann
2812 
2813 // #include <nlohmann/detail/value_t.hpp>
2814 
2815 
2816 #include <array> // array
2817 #include <ciso646> // and
2818 #include <cstddef> // size_t
2819 #include <cstdint> // uint8_t
2820 #include <string> // string
2821 
2822 namespace nlohmann
2823 {
2824 namespace detail
2825 {
2827 // JSON type enumeration //
2829 
2854 enum class value_t : std::uint8_t
2855 {
2856  null,
2857  object,
2858  array,
2859  string,
2860  boolean,
2861  number_integer,
2862  number_unsigned,
2863  number_float,
2864  discarded
2865 };
2866 
2877 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2878 {
2879  static constexpr std::array<std::uint8_t, 8> order = {{
2880  0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
2881  1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */
2882  }
2883  };
2884 
2885  const auto l_index = static_cast<std::size_t>(lhs);
2886  const auto r_index = static_cast<std::size_t>(rhs);
2887  return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
2888 }
2889 } // namespace detail
2890 } // namespace nlohmann
2891 
2892 
2893 namespace nlohmann
2894 {
2895 namespace detail
2896 {
2897 template<typename BasicJsonType>
2898 void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
2899 {
2900  if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
2901  {
2902  JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
2903  }
2904  n = nullptr;
2905 }
2906 
2907 // overloads for basic_json template parameters
2908 template<typename BasicJsonType, typename ArithmeticType,
2911  int> = 0>
2912 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
2913 {
2914  switch (static_cast<value_t>(j))
2915  {
2916  case value_t::number_unsigned:
2917  {
2918  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
2919  break;
2920  }
2921  case value_t::number_integer:
2922  {
2923  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
2924  break;
2925  }
2926  case value_t::number_float:
2927  {
2928  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
2929  break;
2930  }
2931 
2932  default:
2933  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
2934  }
2935 }
2936 
2937 template<typename BasicJsonType>
2938 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
2939 {
2940  if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
2941  {
2942  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
2943  }
2944  b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
2945 }
2946 
2947 template<typename BasicJsonType>
2948 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
2949 {
2950  if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
2951  {
2952  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
2953  }
2954  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
2955 }
2956 
2957 template <
2958  typename BasicJsonType, typename ConstructibleStringType,
2959  enable_if_t <
2961  not std::is_same<typename BasicJsonType::string_t,
2962  ConstructibleStringType>::value,
2963  int > = 0 >
2964 void from_json(const BasicJsonType& j, ConstructibleStringType& s)
2965 {
2966  if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
2967  {
2968  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
2969  }
2970 
2971  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
2972 }
2973 
2974 template<typename BasicJsonType>
2975 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
2976 {
2977  get_arithmetic_value(j, val);
2978 }
2979 
2980 template<typename BasicJsonType>
2981 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
2982 {
2983  get_arithmetic_value(j, val);
2984 }
2985 
2986 template<typename BasicJsonType>
2987 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
2988 {
2989  get_arithmetic_value(j, val);
2990 }
2991 
2992 template<typename BasicJsonType, typename EnumType,
2994 void from_json(const BasicJsonType& j, EnumType& e)
2995 {
2996  typename std::underlying_type<EnumType>::type val;
2997  get_arithmetic_value(j, val);
2998  e = static_cast<EnumType>(val);
2999 }
3000 
3001 // forward_list doesn't have an insert method
3002 template<typename BasicJsonType, typename T, typename Allocator,
3004 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3005 {
3006  if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
3007  {
3008  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3009  }
3010  l.clear();
3011  std::transform(j.rbegin(), j.rend(),
3012  std::front_inserter(l), [](const BasicJsonType & i)
3013  {
3014  return i.template get<T>();
3015  });
3016 }
3017 
3018 // valarray doesn't have an insert method
3019 template<typename BasicJsonType, typename T,
3021 void from_json(const BasicJsonType& j, std::valarray<T>& l)
3022 {
3023  if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
3024  {
3025  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3026  }
3027  l.resize(j.size());
3028  std::copy(j.begin(), j.end(), std::begin(l));
3029 }
3030 
3031 template <typename BasicJsonType, typename T, std::size_t N>
3032 auto from_json(const BasicJsonType& j, T (&arr)[N])
3033 -> decltype(j.template get<T>(), void())
3034 {
3035  for (std::size_t i = 0; i < N; ++i)
3036  {
3037  arr[i] = j.at(i).template get<T>();
3038  }
3039 }
3040 
3041 template<typename BasicJsonType>
3042 void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
3043 {
3044  arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3045 }
3046 
3047 template <typename BasicJsonType, typename T, std::size_t N>
3048 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
3049  priority_tag<2> /*unused*/)
3050 -> decltype(j.template get<T>(), void())
3051 {
3052  for (std::size_t i = 0; i < N; ++i)
3053  {
3054  arr[i] = j.at(i).template get<T>();
3055  }
3056 }
3057 
3058 template<typename BasicJsonType, typename ConstructibleArrayType>
3059 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
3060 -> decltype(
3061  arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
3062  j.template get<typename ConstructibleArrayType::value_type>(),
3063  void())
3064 {
3065  using std::end;
3066 
3067  ConstructibleArrayType ret;
3068  ret.reserve(j.size());
3069  std::transform(j.begin(), j.end(),
3070  std::inserter(ret, end(ret)), [](const BasicJsonType & i)
3071  {
3072  // get<BasicJsonType>() returns *this, this won't call a from_json
3073  // method when value_type is BasicJsonType
3074  return i.template get<typename ConstructibleArrayType::value_type>();
3075  });
3076  arr = std::move(ret);
3077 }
3078 
3079 template <typename BasicJsonType, typename ConstructibleArrayType>
3080 void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
3081  priority_tag<0> /*unused*/)
3082 {
3083  using std::end;
3084 
3085  ConstructibleArrayType ret;
3087  j.begin(), j.end(), std::inserter(ret, end(ret)),
3088  [](const BasicJsonType & i)
3089  {
3090  // get<BasicJsonType>() returns *this, this won't call a from_json
3091  // method when value_type is BasicJsonType
3092  return i.template get<typename ConstructibleArrayType::value_type>();
3093  });
3094  arr = std::move(ret);
3095 }
3096 
3097 template <typename BasicJsonType, typename ConstructibleArrayType,
3098  enable_if_t <
3103  int > = 0 >
3104 
3105 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
3106 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
3107 j.template get<typename ConstructibleArrayType::value_type>(),
3108 void())
3109 {
3110  if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
3111  {
3112  JSON_THROW(type_error::create(302, "type must be array, but is " +
3113  std::string(j.type_name())));
3114  }
3115 
3117 }
3118 
3119 template<typename BasicJsonType, typename ConstructibleObjectType,
3121 void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
3122 {
3123  if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
3124  {
3125  JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
3126  }
3127 
3128  ConstructibleObjectType ret;
3129  auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
3130  using value_type = typename ConstructibleObjectType::value_type;
3132  inner_object->begin(), inner_object->end(),
3133  std::inserter(ret, ret.begin()),
3134  [](typename BasicJsonType::object_t::value_type const & p)
3135  {
3136  return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
3137  });
3138  obj = std::move(ret);
3139 }
3140 
3141 // overload for arithmetic types, not chosen for basic_json template arguments
3142 // (BooleanType, etc..); note: Is it really necessary to provide explicit
3143 // overloads for boolean_t etc. in case of a custom BooleanType which is not
3144 // an arithmetic type?
3145 template<typename BasicJsonType, typename ArithmeticType,
3146  enable_if_t <
3152  int> = 0>
3153 void from_json(const BasicJsonType& j, ArithmeticType& val)
3154 {
3155  switch (static_cast<value_t>(j))
3156  {
3157  case value_t::number_unsigned:
3158  {
3159  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3160  break;
3161  }
3162  case value_t::number_integer:
3163  {
3164  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3165  break;
3166  }
3167  case value_t::number_float:
3168  {
3169  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3170  break;
3171  }
3172  case value_t::boolean:
3173  {
3174  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
3175  break;
3176  }
3177 
3178  default:
3179  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
3180  }
3181 }
3182 
3183 template<typename BasicJsonType, typename A1, typename A2>
3184 void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
3185 {
3186  p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
3187 }
3188 
3189 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
3190 void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
3191 {
3192  t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
3193 }
3194 
3195 template<typename BasicJsonType, typename... Args>
3196 void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
3197 {
3199 }
3200 
3201 template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
3202  typename = enable_if_t<not std::is_constructible<
3203  typename BasicJsonType::string_t, Key>::value>>
3204 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
3205 {
3206  if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
3207  {
3208  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3209  }
3210  m.clear();
3211  for (const auto& p : j)
3212  {
3213  if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
3214  {
3215  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
3216  }
3217  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3218  }
3219 }
3220 
3221 template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
3222  typename = enable_if_t<not std::is_constructible<
3223  typename BasicJsonType::string_t, Key>::value>>
3224 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
3225 {
3226  if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
3227  {
3228  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3229  }
3230  m.clear();
3231  for (const auto& p : j)
3232  {
3233  if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
3234  {
3235  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
3236  }
3237  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3238  }
3239 }
3240 
3242 {
3243  template<typename BasicJsonType, typename T>
3244  auto operator()(const BasicJsonType& j, T& val) const
3245  noexcept(noexcept(from_json(j, val)))
3246  -> decltype(from_json(j, val), void())
3247  {
3248  return from_json(j, val);
3249  }
3250 };
3251 } // namespace detail
3252 
3256 namespace
3257 {
3259 } // namespace
3260 } // namespace nlohmann
3261 
3262 // #include <nlohmann/detail/conversions/to_json.hpp>
3263 
3264 
3265 #include <algorithm> // copy
3266 #include <ciso646> // or, and, not
3267 #include <iterator> // begin, end
3268 #include <string> // string
3269 #include <tuple> // tuple, get
3270 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
3271 #include <utility> // move, forward, declval, pair
3272 #include <valarray> // valarray
3273 #include <vector> // vector
3274 
3275 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
3276 
3277 
3278 #include <cstddef> // size_t
3279 #include <iterator> // input_iterator_tag
3280 #include <string> // string, to_string
3281 #include <tuple> // tuple_size, get, tuple_element
3282 
3283 // #include <nlohmann/detail/meta/type_traits.hpp>
3284 
3285 // #include <nlohmann/detail/value_t.hpp>
3286 
3287 
3288 namespace nlohmann
3289 {
3290 namespace detail
3291 {
3292 template<typename string_type>
3293 void int_to_string( string_type& target, std::size_t value )
3294 {
3295  target = std::to_string(value);
3296 }
3297 template <typename IteratorType> class iteration_proxy_value
3298 {
3299  public:
3300  using difference_type = std::ptrdiff_t;
3302  using pointer = value_type * ;
3303  using reference = value_type & ;
3304  using iterator_category = std::input_iterator_tag;
3305  using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
3306 
3307  private:
3309  IteratorType anchor;
3311  std::size_t array_index = 0;
3313  mutable std::size_t array_index_last = 0;
3315  mutable string_type array_index_str = "0";
3317  const string_type empty_str = "";
3318 
3319  public:
3320  explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
3321 
3324  {
3325  return *this;
3326  }
3327 
3330  {
3331  ++anchor;
3332  ++array_index;
3333 
3334  return *this;
3335  }
3336 
3338  bool operator==(const iteration_proxy_value& o) const
3339  {
3340  return anchor == o.anchor;
3341  }
3342 
3344  bool operator!=(const iteration_proxy_value& o) const
3345  {
3346  return anchor != o.anchor;
3347  }
3348 
3350  const string_type& key() const
3351  {
3352  assert(anchor.m_object != nullptr);
3353 
3354  switch (anchor.m_object->type())
3355  {
3356  // use integer array index as key
3357  case value_t::array:
3358  {
3359  if (array_index != array_index_last)
3360  {
3361  int_to_string( array_index_str, array_index );
3362  array_index_last = array_index;
3363  }
3364  return array_index_str;
3365  }
3366 
3367  // use key from the object
3368  case value_t::object:
3369  return anchor.key();
3370 
3371  // use an empty key for all primitive types
3372  default:
3373  return empty_str;
3374  }
3375  }
3376 
3378  typename IteratorType::reference value() const
3379  {
3380  return anchor.value();
3381  }
3382 };
3383 
3385 template<typename IteratorType> class iteration_proxy
3386 {
3387  private:
3389  typename IteratorType::reference container;
3390 
3391  public:
3393  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
3394  : container(cont) {}
3395 
3398  {
3399  return iteration_proxy_value<IteratorType>(container.begin());
3400  }
3401 
3404  {
3405  return iteration_proxy_value<IteratorType>(container.end());
3406  }
3407 };
3408 // Structured Bindings Support
3409 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3410 // And see https://github.com/nlohmann/json/pull/1391
3411 template <std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
3412 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
3413 {
3414  return i.key();
3415 }
3416 // Structured Bindings Support
3417 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3418 // And see https://github.com/nlohmann/json/pull/1391
3419 template <std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
3420 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
3421 {
3422  return i.value();
3423 }
3424 } // namespace detail
3425 } // namespace nlohmann
3426 
3427 // The Addition to the STD Namespace is required to add
3428 // Structured Bindings Support to the iteration_proxy_value class
3429 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3430 // And see https://github.com/nlohmann/json/pull/1391
3431 namespace std
3432 {
3433 #if defined(__clang__)
3434  // Fix: https://github.com/nlohmann/json/issues/1401
3435  #pragma clang diagnostic push
3436  #pragma clang diagnostic ignored "-Wmismatched-tags"
3437 #endif
3438 template <typename IteratorType>
3439 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
3440  : public std::integral_constant<std::size_t, 2> {};
3441 
3442 template <std::size_t N, typename IteratorType>
3443 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
3444 {
3445  public:
3446  using type = decltype(
3447  get<N>(std::declval <
3449 };
3450 #if defined(__clang__)
3451  #pragma clang diagnostic pop
3452 #endif
3453 } // namespace std
3454 
3455 // #include <nlohmann/detail/meta/cpp_future.hpp>
3456 
3457 // #include <nlohmann/detail/meta/type_traits.hpp>
3458 
3459 // #include <nlohmann/detail/value_t.hpp>
3460 
3461 
3462 namespace nlohmann
3463 {
3464 namespace detail
3465 {
3467 // constructors //
3469 
3470 template<value_t> struct external_constructor;
3471 
3472 template<>
3474 {
3475  template<typename BasicJsonType>
3476  static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
3477  {
3478  j.m_type = value_t::boolean;
3479  j.m_value = b;
3480  j.assert_invariant();
3481  }
3482 };
3483 
3484 template<>
3486 {
3487  template<typename BasicJsonType>
3488  static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
3489  {
3490  j.m_type = value_t::string;
3491  j.m_value = s;
3492  j.assert_invariant();
3493  }
3494 
3495  template<typename BasicJsonType>
3496  static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
3497  {
3498  j.m_type = value_t::string;
3499  j.m_value = std::move(s);
3500  j.assert_invariant();
3501  }
3502 
3503  template<typename BasicJsonType, typename CompatibleStringType,
3505  int> = 0>
3506  static void construct(BasicJsonType& j, const CompatibleStringType& str)
3507  {
3508  j.m_type = value_t::string;
3509  j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
3510  j.assert_invariant();
3511  }
3512 };
3513 
3514 template<>
3515 struct external_constructor<value_t::number_float>
3516 {
3517  template<typename BasicJsonType>
3518  static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
3519  {
3520  j.m_type = value_t::number_float;
3521  j.m_value = val;
3522  j.assert_invariant();
3523  }
3524 };
3525 
3526 template<>
3527 struct external_constructor<value_t::number_unsigned>
3528 {
3529  template<typename BasicJsonType>
3530  static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
3531  {
3532  j.m_type = value_t::number_unsigned;
3533  j.m_value = val;
3534  j.assert_invariant();
3535  }
3536 };
3537 
3538 template<>
3539 struct external_constructor<value_t::number_integer>
3540 {
3541  template<typename BasicJsonType>
3542  static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
3543  {
3544  j.m_type = value_t::number_integer;
3545  j.m_value = val;
3546  j.assert_invariant();
3547  }
3548 };
3549 
3550 template<>
3552 {
3553  template<typename BasicJsonType>
3554  static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
3555  {
3556  j.m_type = value_t::array;
3557  j.m_value = arr;
3558  j.assert_invariant();
3559  }
3560 
3561  template<typename BasicJsonType>
3562  static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
3563  {
3564  j.m_type = value_t::array;
3565  j.m_value = std::move(arr);
3566  j.assert_invariant();
3567  }
3568 
3569  template<typename BasicJsonType, typename CompatibleArrayType,
3571  int> = 0>
3572  static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
3573  {
3574  using std::begin;
3575  using std::end;
3576  j.m_type = value_t::array;
3577  j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
3578  j.assert_invariant();
3579  }
3580 
3581  template<typename BasicJsonType>
3582  static void construct(BasicJsonType& j, const std::vector<bool>& arr)
3583  {
3584  j.m_type = value_t::array;
3585  j.m_value = value_t::array;
3586  j.m_value.array->reserve(arr.size());
3587  for (const bool x : arr)
3588  {
3589  j.m_value.array->push_back(x);
3590  }
3591  j.assert_invariant();
3592  }
3593 
3594  template<typename BasicJsonType, typename T,
3596  static void construct(BasicJsonType& j, const std::valarray<T>& arr)
3597  {
3598  j.m_type = value_t::array;
3599  j.m_value = value_t::array;
3600  j.m_value.array->resize(arr.size());
3601  if (arr.size() > 0)
3602  {
3603  std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
3604  }
3605  j.assert_invariant();
3606  }
3607 };
3608 
3609 template<>
3611 {
3612  template<typename BasicJsonType>
3613  static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
3614  {
3615  j.m_type = value_t::object;
3616  j.m_value = obj;
3617  j.assert_invariant();
3618  }
3619 
3620  template<typename BasicJsonType>
3621  static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
3622  {
3623  j.m_type = value_t::object;
3624  j.m_value = std::move(obj);
3625  j.assert_invariant();
3626  }
3627 
3628  template<typename BasicJsonType, typename CompatibleObjectType,
3630  static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
3631  {
3632  using std::begin;
3633  using std::end;
3634 
3635  j.m_type = value_t::object;
3636  j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
3637  j.assert_invariant();
3638  }
3639 };
3640 
3642 // to_json //
3644 
3645 template<typename BasicJsonType, typename T,
3647 void to_json(BasicJsonType& j, T b) noexcept
3648 {
3650 }
3651 
3652 template<typename BasicJsonType, typename CompatibleString,
3654 void to_json(BasicJsonType& j, const CompatibleString& s)
3655 {
3657 }
3658 
3659 template<typename BasicJsonType>
3660 void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
3661 {
3663 }
3664 
3665 template<typename BasicJsonType, typename FloatType,
3667 void to_json(BasicJsonType& j, FloatType val) noexcept
3668 {
3669  external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
3670 }
3671 
3672 template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
3674 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
3675 {
3676  external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
3677 }
3678 
3679 template<typename BasicJsonType, typename CompatibleNumberIntegerType,
3681 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
3682 {
3683  external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
3684 }
3685 
3686 template<typename BasicJsonType, typename EnumType,
3688 void to_json(BasicJsonType& j, EnumType e) noexcept
3689 {
3690  using underlying_type = typename std::underlying_type<EnumType>::type;
3691  external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
3692 }
3693 
3694 template<typename BasicJsonType>
3695 void to_json(BasicJsonType& j, const std::vector<bool>& e)
3696 {
3698 }
3699 
3700 template <typename BasicJsonType, typename CompatibleArrayType,
3701  enable_if_t<is_compatible_array_type<BasicJsonType,
3702  CompatibleArrayType>::value and
3703  not is_compatible_object_type<
3704  BasicJsonType, CompatibleArrayType>::value and
3707  int> = 0>
3708 void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
3709 {
3711 }
3712 
3713 template<typename BasicJsonType, typename T,
3715 void to_json(BasicJsonType& j, const std::valarray<T>& arr)
3716 {
3718 }
3719 
3720 template<typename BasicJsonType>
3721 void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
3722 {
3724 }
3725 
3726 template<typename BasicJsonType, typename CompatibleObjectType,
3728 void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
3729 {
3731 }
3732 
3733 template<typename BasicJsonType>
3734 void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
3735 {
3737 }
3738 
3739 template <
3740  typename BasicJsonType, typename T, std::size_t N,
3741  enable_if_t<not std::is_constructible<typename BasicJsonType::string_t,
3742  const T(&)[N]>::value,
3743  int> = 0 >
3744 void to_json(BasicJsonType& j, const T(&arr)[N])
3745 {
3747 }
3748 
3750 void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
3751 {
3752  j = { p.first, p.second };
3753 }
3754 
3755 // for https://github.com/nlohmann/json/pull/1134
3756 template < typename BasicJsonType, typename T,
3757  enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
3758 void to_json(BasicJsonType& j, const T& b)
3759 {
3760  j = { {b.key(), b.value()} };
3761 }
3762 
3763 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
3764 void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
3765 {
3766  j = { std::get<Idx>(t)... };
3767 }
3768 
3770 void to_json(BasicJsonType& j, const T& t)
3771 {
3773 }
3774 
3776 {
3777  template<typename BasicJsonType, typename T>
3778  auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
3779  -> decltype(to_json(j, std::forward<T>(val)), void())
3780  {
3781  return to_json(j, std::forward<T>(val));
3782  }
3783 };
3784 } // namespace detail
3785 
3787 namespace
3788 {
3790 } // namespace
3791 } // namespace nlohmann
3792 
3793 
3794 namespace nlohmann
3795 {
3796 
3797 template<typename, typename>
3799 {
3809  template<typename BasicJsonType, typename ValueType>
3810  static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
3811  noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
3812  -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
3813  {
3814  ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
3815  }
3816 
3826  template <typename BasicJsonType, typename ValueType>
3827  static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
3828  noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
3829  -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
3830  {
3831  ::nlohmann::to_json(j, std::forward<ValueType>(val));
3832  }
3833 };
3834 
3835 } // namespace nlohmann
3836 
3837 // #include <nlohmann/detail/conversions/from_json.hpp>
3838 
3839 // #include <nlohmann/detail/conversions/to_json.hpp>
3840 
3841 // #include <nlohmann/detail/exceptions.hpp>
3842 
3843 // #include <nlohmann/detail/input/binary_reader.hpp>
3844 
3845 
3846 #include <algorithm> // generate_n
3847 #include <array> // array
3848 #include <cassert> // assert
3849 #include <cmath> // ldexp
3850 #include <cstddef> // size_t
3851 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
3852 #include <cstdio> // snprintf
3853 #include <cstring> // memcpy
3854 #include <iterator> // back_inserter
3855 #include <limits> // numeric_limits
3856 #include <string> // char_traits, string
3857 #include <utility> // make_pair, move
3858 
3859 // #include <nlohmann/detail/exceptions.hpp>
3860 
3861 // #include <nlohmann/detail/input/input_adapters.hpp>
3862 
3863 
3864 #include <array> // array
3865 #include <cassert> // assert
3866 #include <cstddef> // size_t
3867 #include <cstdio> //FILE *
3868 #include <cstring> // strlen
3869 #include <istream> // istream
3870 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
3871 #include <memory> // shared_ptr, make_shared, addressof
3872 #include <numeric> // accumulate
3873 #include <string> // string, char_traits
3874 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
3875 #include <utility> // pair, declval
3876 
3877 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
3878 
3879 // #include <nlohmann/detail/macro_scope.hpp>
3880 
3881 
3882 namespace nlohmann
3883 {
3884 namespace detail
3885 {
3887 enum class input_format_t { json, cbor, msgpack, ubjson, bson };
3888 
3890 // input adapters //
3892 
3905 {
3907  virtual std::char_traits<char>::int_type get_character() = 0;
3908  virtual ~input_adapter_protocol() = default;
3909 };
3910 
3912 using input_adapter_t = std::shared_ptr<input_adapter_protocol>;
3913 
3919 {
3920  public:
3922  explicit file_input_adapter(std::FILE* f) noexcept
3923  : m_file(f)
3924  {}
3925 
3926  // make class move-only
3927  file_input_adapter(const file_input_adapter&) = delete;
3929  file_input_adapter& operator=(const file_input_adapter&) = delete;
3930  file_input_adapter& operator=(file_input_adapter&&) = default;
3931  ~file_input_adapter() override = default;
3932 
3933  std::char_traits<char>::int_type get_character() noexcept override
3934  {
3935  return std::fgetc(m_file);
3936  }
3937 
3938  private:
3940  std::FILE* m_file;
3941 };
3942 
3943 
3954 {
3955  public:
3957  {
3958  // clear stream flags; we use underlying streambuf I/O, do not
3959  // maintain ifstream flags, except eof
3960  is.clear(is.rdstate() & std::ios::eofbit);
3961  }
3962 
3963  explicit input_stream_adapter(std::istream& i)
3964  : is(i), sb(*i.rdbuf())
3965  {}
3966 
3967  // delete because of pointer members
3968  input_stream_adapter(const input_stream_adapter&) = delete;
3969  input_stream_adapter& operator=(input_stream_adapter&) = delete;
3971  input_stream_adapter& operator=(input_stream_adapter&&) = delete;
3972 
3973  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
3974  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
3975  // end up as the same value, eg. 0xFFFFFFFF.
3976  std::char_traits<char>::int_type get_character() override
3977  {
3978  auto res = sb.sbumpc();
3979  // set eof manually, as we don't use the istream interface.
3980  if (res == EOF)
3981  {
3982  is.clear(is.rdstate() | std::ios::eofbit);
3983  }
3984  return res;
3985  }
3986 
3987  private:
3989  std::istream& is;
3990  std::streambuf& sb;
3991 };
3992 
3995 {
3996  public:
3997  input_buffer_adapter(const char* b, const std::size_t l) noexcept
3998  : cursor(b), limit(b == nullptr ? nullptr : (b + l))
3999  {}
4000 
4001  // delete because of pointer members
4002  input_buffer_adapter(const input_buffer_adapter&) = delete;
4003  input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
4005  input_buffer_adapter& operator=(input_buffer_adapter&&) = delete;
4006  ~input_buffer_adapter() override = default;
4007 
4008  std::char_traits<char>::int_type get_character() noexcept override
4009  {
4010  if (JSON_HEDLEY_LIKELY(cursor < limit))
4011  {
4012  assert(cursor != nullptr and limit != nullptr);
4013  return std::char_traits<char>::to_int_type(*(cursor++));
4014  }
4015 
4016  return std::char_traits<char>::eof();
4017  }
4018 
4019  private:
4021  const char* cursor;
4023  const char* const limit;
4024 };
4025 
4026 template<typename WideStringType, size_t T>
4028 {
4029  // UTF-32
4030  static void fill_buffer(const WideStringType& str,
4031  size_t& current_wchar,
4032  std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
4033  size_t& utf8_bytes_index,
4034  size_t& utf8_bytes_filled)
4035  {
4036  utf8_bytes_index = 0;
4037 
4038  if (current_wchar == str.size())
4039  {
4040  utf8_bytes[0] = std::char_traits<char>::eof();
4041  utf8_bytes_filled = 1;
4042  }
4043  else
4044  {
4045  // get the current character
4046  const auto wc = static_cast<unsigned int>(str[current_wchar++]);
4047 
4048  // UTF-32 to UTF-8 encoding
4049  if (wc < 0x80)
4050  {
4051  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4052  utf8_bytes_filled = 1;
4053  }
4054  else if (wc <= 0x7FF)
4055  {
4056  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u) & 0x1Fu));
4057  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
4058  utf8_bytes_filled = 2;
4059  }
4060  else if (wc <= 0xFFFF)
4061  {
4062  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u) & 0x0Fu));
4063  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
4064  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
4065  utf8_bytes_filled = 3;
4066  }
4067  else if (wc <= 0x10FFFF)
4068  {
4069  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((wc >> 18u) & 0x07u));
4070  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 12u) & 0x3Fu));
4071  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
4072  utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
4073  utf8_bytes_filled = 4;
4074  }
4075  else
4076  {
4077  // unknown character
4078  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4079  utf8_bytes_filled = 1;
4080  }
4081  }
4082  }
4083 };
4084 
4085 template<typename WideStringType>
4086 struct wide_string_input_helper<WideStringType, 2>
4087 {
4088  // UTF-16
4089  static void fill_buffer(const WideStringType& str,
4090  size_t& current_wchar,
4091  std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
4092  size_t& utf8_bytes_index,
4093  size_t& utf8_bytes_filled)
4094  {
4095  utf8_bytes_index = 0;
4096 
4097  if (current_wchar == str.size())
4098  {
4099  utf8_bytes[0] = std::char_traits<char>::eof();
4100  utf8_bytes_filled = 1;
4101  }
4102  else
4103  {
4104  // get the current character
4105  const auto wc = static_cast<unsigned int>(str[current_wchar++]);
4106 
4107  // UTF-16 to UTF-8 encoding
4108  if (wc < 0x80)
4109  {
4110  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4111  utf8_bytes_filled = 1;
4112  }
4113  else if (wc <= 0x7FF)
4114  {
4115  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u)));
4116  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
4117  utf8_bytes_filled = 2;
4118  }
4119  else if (0xD800 > wc or wc >= 0xE000)
4120  {
4121  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u)));
4122  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
4123  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
4124  utf8_bytes_filled = 3;
4125  }
4126  else
4127  {
4128  if (current_wchar < str.size())
4129  {
4130  const auto wc2 = static_cast<unsigned int>(str[current_wchar++]);
4131  const auto charcode = 0x10000u + (((wc & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
4132  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
4133  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
4134  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
4135  utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
4136  utf8_bytes_filled = 4;
4137  }
4138  else
4139  {
4140  // unknown character
4141  ++current_wchar;
4142  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4143  utf8_bytes_filled = 1;
4144  }
4145  }
4146  }
4147  }
4148 };
4149 
4150 template<typename WideStringType>
4152 {
4153  public:
4154  explicit wide_string_input_adapter(const WideStringType& w) noexcept
4155  : str(w)
4156  {}
4157 
4158  std::char_traits<char>::int_type get_character() noexcept override
4159  {
4160  // check if buffer needs to be filled
4161  if (utf8_bytes_index == utf8_bytes_filled)
4162  {
4163  fill_buffer<sizeof(typename WideStringType::value_type)>();
4164 
4165  assert(utf8_bytes_filled > 0);
4166  assert(utf8_bytes_index == 0);
4167  }
4168 
4169  // use buffer
4170  assert(utf8_bytes_filled > 0);
4171  assert(utf8_bytes_index < utf8_bytes_filled);
4172  return utf8_bytes[utf8_bytes_index++];
4173  }
4174 
4175  private:
4176  template<size_t T>
4177  void fill_buffer()
4178  {
4179  wide_string_input_helper<WideStringType, T>::fill_buffer(str, current_wchar, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
4180  }
4181 
4183  const WideStringType& str;
4184 
4186  std::size_t current_wchar = 0;
4187 
4189  std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
4190 
4192  std::size_t utf8_bytes_index = 0;
4194  std::size_t utf8_bytes_filled = 0;
4195 };
4196 
4198 {
4199  public:
4200  // native support
4202  input_adapter(std::FILE* file)
4203  : ia(std::make_shared<file_input_adapter>(file)) {}
4205  input_adapter(std::istream& i)
4206  : ia(std::make_shared<input_stream_adapter>(i)) {}
4207 
4209  input_adapter(std::istream&& i)
4210  : ia(std::make_shared<input_stream_adapter>(i)) {}
4211 
4212  input_adapter(const std::wstring& ws)
4213  : ia(std::make_shared<wide_string_input_adapter<std::wstring>>(ws)) {}
4214 
4215  input_adapter(const std::u16string& ws)
4216  : ia(std::make_shared<wide_string_input_adapter<std::u16string>>(ws)) {}
4217 
4218  input_adapter(const std::u32string& ws)
4219  : ia(std::make_shared<wide_string_input_adapter<std::u32string>>(ws)) {}
4220 
4222  template<typename CharT,
4223  typename std::enable_if<
4225  std::is_integral<typename std::remove_pointer<CharT>::type>::value and
4226  sizeof(typename std::remove_pointer<CharT>::type) == 1,
4227  int>::type = 0>
4228  input_adapter(CharT b, std::size_t l)
4229  : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
4230 
4231  // derived support
4232 
4234  template<typename CharT,
4235  typename std::enable_if<
4237  std::is_integral<typename std::remove_pointer<CharT>::type>::value and
4238  sizeof(typename std::remove_pointer<CharT>::type) == 1,
4239  int>::type = 0>
4240  input_adapter(CharT b)
4241  : input_adapter(reinterpret_cast<const char*>(b),
4242  std::strlen(reinterpret_cast<const char*>(b))) {}
4243 
4245  template<class IteratorType,
4246  typename std::enable_if<
4247  std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
4248  int>::type = 0>
4249  input_adapter(IteratorType first, IteratorType last)
4250  {
4251 #ifndef NDEBUG
4252  // assertion to check that the iterator range is indeed contiguous,
4253  // see http://stackoverflow.com/a/35008842/266378 for more discussion
4254  const auto is_contiguous = std::accumulate(
4255  first, last, std::pair<bool, int>(true, 0),
4256  [&first](std::pair<bool, int> res, decltype(*first) val)
4257  {
4258  res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
4259  return res;
4260  }).first;
4261  assert(is_contiguous);
4262 #endif
4263 
4264  // assertion to check that each element is 1 byte long
4265  static_assert(
4266  sizeof(typename iterator_traits<IteratorType>::value_type) == 1,
4267  "each element in the iterator range must have the size of 1 byte");
4268 
4269  const auto len = static_cast<size_t>(std::distance(first, last));
4270  if (JSON_HEDLEY_LIKELY(len > 0))
4271  {
4272  // there is at least one element: use the address of first
4273  ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
4274  }
4275  else
4276  {
4277  // the address of first cannot be used: use nullptr
4278  ia = std::make_shared<input_buffer_adapter>(nullptr, len);
4279  }
4280  }
4281 
4283  template<class T, std::size_t N>
4284  input_adapter(T (&array)[N])
4285  : input_adapter(std::begin(array), std::end(array)) {}
4286 
4288  template<class ContiguousContainer, typename
4290  std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
4291  int>::type = 0>
4292  input_adapter(const ContiguousContainer& c)
4293  : input_adapter(std::begin(c), std::end(c)) {}
4294 
4295  operator input_adapter_t()
4296  {
4297  return ia;
4298  }
4299 
4300  private:
4302  input_adapter_t ia = nullptr;
4303 };
4304 } // namespace detail
4305 } // namespace nlohmann
4306 
4307 // #include <nlohmann/detail/input/json_sax.hpp>
4308 
4309 
4310 #include <cassert> // assert
4311 #include <cstddef>
4312 #include <string> // string
4313 #include <utility> // move
4314 #include <vector> // vector
4315 
4316 // #include <nlohmann/detail/exceptions.hpp>
4317 
4318 // #include <nlohmann/detail/macro_scope.hpp>
4319 
4320 
4321 namespace nlohmann
4322 {
4323 
4332 template<typename BasicJsonType>
4333 struct json_sax
4334 {
4336  using number_integer_t = typename BasicJsonType::number_integer_t;
4338  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
4340  using number_float_t = typename BasicJsonType::number_float_t;
4342  using string_t = typename BasicJsonType::string_t;
4343 
4348  virtual bool null() = 0;
4349 
4355  virtual bool boolean(bool val) = 0;
4356 
4362  virtual bool number_integer(number_integer_t val) = 0;
4363 
4369  virtual bool number_unsigned(number_unsigned_t val) = 0;
4370 
4377  virtual bool number_float(number_float_t val, const string_t& s) = 0;
4378 
4385  virtual bool string(string_t& val) = 0;
4386 
4393  virtual bool start_object(std::size_t elements) = 0;
4394 
4401  virtual bool key(string_t& val) = 0;
4402 
4407  virtual bool end_object() = 0;
4408 
4415  virtual bool start_array(std::size_t elements) = 0;
4416 
4421  virtual bool end_array() = 0;
4422 
4430  virtual bool parse_error(std::size_t position,
4431  const std::string& last_token,
4432  const detail::exception& ex) = 0;
4433 
4434  virtual ~json_sax() = default;
4435 };
4436 
4437 
4438 namespace detail
4439 {
4453 template<typename BasicJsonType>
4455 {
4456  public:
4457  using number_integer_t = typename BasicJsonType::number_integer_t;
4458  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
4459  using number_float_t = typename BasicJsonType::number_float_t;
4460  using string_t = typename BasicJsonType::string_t;
4461 
4467  explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
4468  : root(r), allow_exceptions(allow_exceptions_)
4469  {}
4470 
4471  // make class move-only
4472  json_sax_dom_parser(const json_sax_dom_parser&) = delete;
4474  json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
4475  json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
4476  ~json_sax_dom_parser() = default;
4477 
4478  bool null()
4479  {
4480  handle_value(nullptr);
4481  return true;
4482  }
4483 
4484  bool boolean(bool val)
4485  {
4486  handle_value(val);
4487  return true;
4488  }
4489 
4490  bool number_integer(number_integer_t val)
4491  {
4492  handle_value(val);
4493  return true;
4494  }
4495 
4496  bool number_unsigned(number_unsigned_t val)
4497  {
4498  handle_value(val);
4499  return true;
4500  }
4501 
4502  bool number_float(number_float_t val, const string_t& /*unused*/)
4503  {
4504  handle_value(val);
4505  return true;
4506  }
4507 
4508  bool string(string_t& val)
4509  {
4510  handle_value(val);
4511  return true;
4512  }
4513 
4514  bool start_object(std::size_t len)
4515  {
4516  ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
4517 
4518  if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
4519  {
4520  JSON_THROW(out_of_range::create(408,
4521  "excessive object size: " + std::to_string(len)));
4522  }
4523 
4524  return true;
4525  }
4526 
4527  bool key(string_t& val)
4528  {
4529  // add null at given key and store the reference for later
4530  object_element = &(ref_stack.back()->m_value.object->operator[](val));
4531  return true;
4532  }
4533 
4534  bool end_object()
4535  {
4536  ref_stack.pop_back();
4537  return true;
4538  }
4539 
4540  bool start_array(std::size_t len)
4541  {
4542  ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
4543 
4544  if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
4545  {
4546  JSON_THROW(out_of_range::create(408,
4547  "excessive array size: " + std::to_string(len)));
4548  }
4549 
4550  return true;
4551  }
4552 
4553  bool end_array()
4554  {
4555  ref_stack.pop_back();
4556  return true;
4557  }
4558 
4559  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
4560  const detail::exception& ex)
4561  {
4562  errored = true;
4563  if (allow_exceptions)
4564  {
4565  // determine the proper exception type from the id
4566  switch ((ex.id / 100) % 100)
4567  {
4568  case 1:
4569  JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
4570  case 4:
4571  JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
4572  // LCOV_EXCL_START
4573  case 2:
4574  JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
4575  case 3:
4576  JSON_THROW(*static_cast<const detail::type_error*>(&ex));
4577  case 5:
4578  JSON_THROW(*static_cast<const detail::other_error*>(&ex));
4579  default:
4580  assert(false);
4581  // LCOV_EXCL_STOP
4582  }
4583  }
4584  return false;
4585  }
4586 
4587  constexpr bool is_errored() const
4588  {
4589  return errored;
4590  }
4591 
4592  private:
4599  template<typename Value>
4601  BasicJsonType* handle_value(Value&& v)
4602  {
4603  if (ref_stack.empty())
4604  {
4605  root = BasicJsonType(std::forward<Value>(v));
4606  return &root;
4607  }
4608 
4609  assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
4610 
4611  if (ref_stack.back()->is_array())
4612  {
4613  ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
4614  return &(ref_stack.back()->m_value.array->back());
4615  }
4616 
4617  assert(ref_stack.back()->is_object());
4618  assert(object_element);
4619  *object_element = BasicJsonType(std::forward<Value>(v));
4620  return object_element;
4621  }
4622 
4624  BasicJsonType& root;
4626  std::vector<BasicJsonType*> ref_stack {};
4628  BasicJsonType* object_element = nullptr;
4630  bool errored = false;
4632  const bool allow_exceptions = true;
4633 };
4634 
4635 template<typename BasicJsonType>
4637 {
4638  public:
4639  using number_integer_t = typename BasicJsonType::number_integer_t;
4640  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
4641  using number_float_t = typename BasicJsonType::number_float_t;
4642  using string_t = typename BasicJsonType::string_t;
4643  using parser_callback_t = typename BasicJsonType::parser_callback_t;
4644  using parse_event_t = typename BasicJsonType::parse_event_t;
4645 
4647  const parser_callback_t cb,
4648  const bool allow_exceptions_ = true)
4649  : root(r), callback(cb), allow_exceptions(allow_exceptions_)
4650  {
4651  keep_stack.push_back(true);
4652  }
4653 
4654  // make class move-only
4657  json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
4659  ~json_sax_dom_callback_parser() = default;
4660 
4661  bool null()
4662  {
4663  handle_value(nullptr);
4664  return true;
4665  }
4666 
4667  bool boolean(bool val)
4668  {
4669  handle_value(val);
4670  return true;
4671  }
4672 
4673  bool number_integer(number_integer_t val)
4674  {
4675  handle_value(val);
4676  return true;
4677  }
4678 
4679  bool number_unsigned(number_unsigned_t val)
4680  {
4681  handle_value(val);
4682  return true;
4683  }
4684 
4685  bool number_float(number_float_t val, const string_t& /*unused*/)
4686  {
4687  handle_value(val);
4688  return true;
4689  }
4690 
4691  bool string(string_t& val)
4692  {
4693  handle_value(val);
4694  return true;
4695  }
4696 
4697  bool start_object(std::size_t len)
4698  {
4699  // check callback for object start
4700  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
4701  keep_stack.push_back(keep);
4702 
4703  auto val = handle_value(BasicJsonType::value_t::object, true);
4704  ref_stack.push_back(val.second);
4705 
4706  // check object limit
4707  if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
4708  {
4709  JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
4710  }
4711 
4712  return true;
4713  }
4714 
4715  bool key(string_t& val)
4716  {
4717  BasicJsonType k = BasicJsonType(val);
4718 
4719  // check callback for key
4720  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
4721  key_keep_stack.push_back(keep);
4722 
4723  // add discarded value at given key and store the reference for later
4724  if (keep and ref_stack.back())
4725  {
4726  object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
4727  }
4728 
4729  return true;
4730  }
4731 
4732  bool end_object()
4733  {
4734  if (ref_stack.back() and not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
4735  {
4736  // discard object
4737  *ref_stack.back() = discarded;
4738  }
4739 
4740  assert(not ref_stack.empty());
4741  assert(not keep_stack.empty());
4742  ref_stack.pop_back();
4743  keep_stack.pop_back();
4744 
4745  if (not ref_stack.empty() and ref_stack.back() and ref_stack.back()->is_object())
4746  {
4747  // remove discarded value
4748  for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
4749  {
4750  if (it->is_discarded())
4751  {
4752  ref_stack.back()->erase(it);
4753  break;
4754  }
4755  }
4756  }
4757 
4758  return true;
4759  }
4760 
4761  bool start_array(std::size_t len)
4762  {
4763  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
4764  keep_stack.push_back(keep);
4765 
4766  auto val = handle_value(BasicJsonType::value_t::array, true);
4767  ref_stack.push_back(val.second);
4768 
4769  // check array limit
4770  if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
4771  {
4772  JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
4773  }
4774 
4775  return true;
4776  }
4777 
4778  bool end_array()
4779  {
4780  bool keep = true;
4781 
4782  if (ref_stack.back())
4783  {
4784  keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
4785  if (not keep)
4786  {
4787  // discard array
4788  *ref_stack.back() = discarded;
4789  }
4790  }
4791 
4792  assert(not ref_stack.empty());
4793  assert(not keep_stack.empty());
4794  ref_stack.pop_back();
4795  keep_stack.pop_back();
4796 
4797  // remove discarded value
4798  if (not keep and not ref_stack.empty() and ref_stack.back()->is_array())
4799  {
4800  ref_stack.back()->m_value.array->pop_back();
4801  }
4802 
4803  return true;
4804  }
4805 
4806  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
4807  const detail::exception& ex)
4808  {
4809  errored = true;
4810  if (allow_exceptions)
4811  {
4812  // determine the proper exception type from the id
4813  switch ((ex.id / 100) % 100)
4814  {
4815  case 1:
4816  JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
4817  case 4:
4818  JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
4819  // LCOV_EXCL_START
4820  case 2:
4821  JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
4822  case 3:
4823  JSON_THROW(*static_cast<const detail::type_error*>(&ex));
4824  case 5:
4825  JSON_THROW(*static_cast<const detail::other_error*>(&ex));
4826  default:
4827  assert(false);
4828  // LCOV_EXCL_STOP
4829  }
4830  }
4831  return false;
4832  }
4833 
4834  constexpr bool is_errored() const
4835  {
4836  return errored;
4837  }
4838 
4839  private:
4855  template<typename Value>
4856  std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
4857  {
4858  assert(not keep_stack.empty());
4859 
4860  // do not handle this value if we know it would be added to a discarded
4861  // container
4862  if (not keep_stack.back())
4863  {
4864  return {false, nullptr};
4865  }
4866 
4867  // create value
4868  auto value = BasicJsonType(std::forward<Value>(v));
4869 
4870  // check callback
4871  const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
4872 
4873  // do not handle this value if we just learnt it shall be discarded
4874  if (not keep)
4875  {
4876  return {false, nullptr};
4877  }
4878 
4879  if (ref_stack.empty())
4880  {
4881  root = std::move(value);
4882  return {true, &root};
4883  }
4884 
4885  // skip this value if we already decided to skip the parent
4886  // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
4887  if (not ref_stack.back())
4888  {
4889  return {false, nullptr};
4890  }
4891 
4892  // we now only expect arrays and objects
4893  assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
4894 
4895  // array
4896  if (ref_stack.back()->is_array())
4897  {
4898  ref_stack.back()->m_value.array->push_back(std::move(value));
4899  return {true, &(ref_stack.back()->m_value.array->back())};
4900  }
4901 
4902  // object
4903  assert(ref_stack.back()->is_object());
4904  // check if we should store an element for the current key
4905  assert(not key_keep_stack.empty());
4906  const bool store_element = key_keep_stack.back();
4907  key_keep_stack.pop_back();
4908 
4909  if (not store_element)
4910  {
4911  return {false, nullptr};
4912  }
4913 
4914  assert(object_element);
4915  *object_element = std::move(value);
4916  return {true, object_element};
4917  }
4918 
4920  BasicJsonType& root;
4922  std::vector<BasicJsonType*> ref_stack {};
4924  std::vector<bool> keep_stack {};
4926  std::vector<bool> key_keep_stack {};
4928  BasicJsonType* object_element = nullptr;
4930  bool errored = false;
4932  const parser_callback_t callback = nullptr;
4934  const bool allow_exceptions = true;
4936  BasicJsonType discarded = BasicJsonType::value_t::discarded;
4937 };
4938 
4939 template<typename BasicJsonType>
4941 {
4942  public:
4943  using number_integer_t = typename BasicJsonType::number_integer_t;
4944  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
4945  using number_float_t = typename BasicJsonType::number_float_t;
4946  using string_t = typename BasicJsonType::string_t;
4947 
4948  bool null()
4949  {
4950  return true;
4951  }
4952 
4953  bool boolean(bool /*unused*/)
4954  {
4955  return true;
4956  }
4957 
4958  bool number_integer(number_integer_t /*unused*/)
4959  {
4960  return true;
4961  }
4962 
4963  bool number_unsigned(number_unsigned_t /*unused*/)
4964  {
4965  return true;
4966  }
4967 
4968  bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
4969  {
4970  return true;
4971  }
4972 
4973  bool string(string_t& /*unused*/)
4974  {
4975  return true;
4976  }
4977 
4978  bool start_object(std::size_t /*unused*/ = std::size_t(-1))
4979  {
4980  return true;
4981  }
4982 
4983  bool key(string_t& /*unused*/)
4984  {
4985  return true;
4986  }
4987 
4988  bool end_object()
4989  {
4990  return true;
4991  }
4992 
4993  bool start_array(std::size_t /*unused*/ = std::size_t(-1))
4994  {
4995  return true;
4996  }
4997 
4998  bool end_array()
4999  {
5000  return true;
5001  }
5002 
5003  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
5004  {
5005  return false;
5006  }
5007 };
5008 } // namespace detail
5009 
5010 } // namespace nlohmann
5011 
5012 // #include <nlohmann/detail/macro_scope.hpp>
5013 
5014 // #include <nlohmann/detail/meta/is_sax.hpp>
5015 
5016 
5017 #include <cstdint> // size_t
5018 #include <utility> // declval
5019 #include <string> // string
5020 
5021 // #include <nlohmann/detail/meta/detected.hpp>
5022 
5023 // #include <nlohmann/detail/meta/type_traits.hpp>
5024 
5025 
5026 namespace nlohmann
5027 {
5028 namespace detail
5029 {
5030 template <typename T>
5031 using null_function_t = decltype(std::declval<T&>().null());
5032 
5033 template <typename T>
5034 using boolean_function_t =
5035  decltype(std::declval<T&>().boolean(std::declval<bool>()));
5036 
5037 template <typename T, typename Integer>
5039  decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
5040 
5041 template <typename T, typename Unsigned>
5043  decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
5044 
5045 template <typename T, typename Float, typename String>
5046 using number_float_function_t = decltype(std::declval<T&>().number_float(
5047  std::declval<Float>(), std::declval<const String&>()));
5048 
5049 template <typename T, typename String>
5050 using string_function_t =
5051  decltype(std::declval<T&>().string(std::declval<String&>()));
5052 
5053 template <typename T>
5055  decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
5056 
5057 template <typename T, typename String>
5058 using key_function_t =
5059  decltype(std::declval<T&>().key(std::declval<String&>()));
5060 
5061 template <typename T>
5062 using end_object_function_t = decltype(std::declval<T&>().end_object());
5063 
5064 template <typename T>
5065 using start_array_function_t =
5066  decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
5067 
5068 template <typename T>
5069 using end_array_function_t = decltype(std::declval<T&>().end_array());
5070 
5071 template <typename T, typename Exception>
5072 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
5073  std::declval<std::size_t>(), std::declval<const std::string&>(),
5074  std::declval<const Exception&>()));
5075 
5076 template <typename SAX, typename BasicJsonType>
5077 struct is_sax
5078 {
5079  private:
5081  "BasicJsonType must be of type basic_json<...>");
5082 
5083  using number_integer_t = typename BasicJsonType::number_integer_t;
5084  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5085  using number_float_t = typename BasicJsonType::number_float_t;
5086  using string_t = typename BasicJsonType::string_t;
5087  using exception_t = typename BasicJsonType::exception;
5088 
5089  public:
5090  static constexpr bool value =
5098  string_t>::value &&
5106 };
5107 
5108 template <typename SAX, typename BasicJsonType>
5110 {
5111  private:
5113  "BasicJsonType must be of type basic_json<...>");
5114 
5115  using number_integer_t = typename BasicJsonType::number_integer_t;
5116  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5117  using number_float_t = typename BasicJsonType::number_float_t;
5118  using string_t = typename BasicJsonType::string_t;
5119  using exception_t = typename BasicJsonType::exception;
5120 
5121  public:
5123  "Missing/invalid function: bool null()");
5125  "Missing/invalid function: bool boolean(bool)");
5127  "Missing/invalid function: bool boolean(bool)");
5128  static_assert(
5131  "Missing/invalid function: bool number_integer(number_integer_t)");
5132  static_assert(
5133  is_detected_exact<bool, number_unsigned_function_t, SAX,
5135  "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
5136  static_assert(is_detected_exact<bool, number_float_function_t, SAX,
5138  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
5139  static_assert(
5141  "Missing/invalid function: bool string(string_t&)");
5143  "Missing/invalid function: bool start_object(std::size_t)");
5145  "Missing/invalid function: bool key(string_t&)");
5147  "Missing/invalid function: bool end_object()");
5149  "Missing/invalid function: bool start_array(std::size_t)");
5151  "Missing/invalid function: bool end_array()");
5152  static_assert(
5154  "Missing/invalid function: bool parse_error(std::size_t, const "
5155  "std::string&, const exception&)");
5156 };
5157 } // namespace detail
5158 } // namespace nlohmann
5159 
5160 // #include <nlohmann/detail/value_t.hpp>
5161 
5162 
5163 namespace nlohmann
5164 {
5165 namespace detail
5166 {
5168 // binary reader //
5170 
5174 template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>>
5176 {
5177  using number_integer_t = typename BasicJsonType::number_integer_t;
5178  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5179  using number_float_t = typename BasicJsonType::number_float_t;
5180  using string_t = typename BasicJsonType::string_t;
5181  using json_sax_t = SAX;
5182 
5183  public:
5189  explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
5190  {
5192  assert(ia);
5193  }
5194 
5195  // make class move-only
5196  binary_reader(const binary_reader&) = delete;
5197  binary_reader(binary_reader&&) = default;
5198  binary_reader& operator=(const binary_reader&) = delete;
5199  binary_reader& operator=(binary_reader&&) = default;
5200  ~binary_reader() = default;
5201 
5210  bool sax_parse(const input_format_t format,
5211  json_sax_t* sax_,
5212  const bool strict = true)
5213  {
5214  sax = sax_;
5215  bool result = false;
5216 
5217  switch (format)
5218  {
5219  case input_format_t::bson:
5220  result = parse_bson_internal();
5221  break;
5222 
5223  case input_format_t::cbor:
5224  result = parse_cbor_internal();
5225  break;
5226 
5227  case input_format_t::msgpack:
5228  result = parse_msgpack_internal();
5229  break;
5230 
5231  case input_format_t::ubjson:
5232  result = parse_ubjson_internal();
5233  break;
5234 
5235  default: // LCOV_EXCL_LINE
5236  assert(false); // LCOV_EXCL_LINE
5237  }
5238 
5239  // strict mode: next byte must be EOF
5240  if (result and strict)
5241  {
5242  if (format == input_format_t::ubjson)
5243  {
5244  get_ignore_noop();
5245  }
5246  else
5247  {
5248  get();
5249  }
5250 
5251  if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char>::eof()))
5252  {
5253  return sax->parse_error(chars_read, get_token_string(),
5254  parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
5255  }
5256  }
5257 
5258  return result;
5259  }
5260 
5268  static constexpr bool little_endianess(int num = 1) noexcept
5269  {
5270  return *reinterpret_cast<char*>(&num) == 1;
5271  }
5272 
5273  private:
5275  // BSON //
5277 
5282  bool parse_bson_internal()
5283  {
5284  std::int32_t document_size;
5285  get_number<std::int32_t, true>(input_format_t::bson, document_size);
5286 
5287  if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
5288  {
5289  return false;
5290  }
5291 
5292  if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
5293  {
5294  return false;
5295  }
5296 
5297  return sax->end_object();
5298  }
5299 
5307  bool get_bson_cstr(string_t& result)
5308  {
5309  auto out = std::back_inserter(result);
5310  while (true)
5311  {
5312  get();
5313  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
5314  {
5315  return false;
5316  }
5317  if (current == 0x00)
5318  {
5319  return true;
5320  }
5321  *out++ = static_cast<char>(current);
5322  }
5323 
5324  return true;
5325  }
5326 
5338  template<typename NumberType>
5339  bool get_bson_string(const NumberType len, string_t& result)
5340  {
5341  if (JSON_HEDLEY_UNLIKELY(len < 1))
5342  {
5343  auto last_token = get_token_string();
5344  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")));
5345  }
5346 
5347  return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) and get() != std::char_traits<char>::eof();
5348  }
5349 
5360  bool parse_bson_element_internal(const int element_type,
5361  const std::size_t element_type_parse_position)
5362  {
5363  switch (element_type)
5364  {
5365  case 0x01: // double
5366  {
5367  double number;
5368  return get_number<double, true>(input_format_t::bson, number) and sax->number_float(static_cast<number_float_t>(number), "");
5369  }
5370 
5371  case 0x02: // string
5372  {
5373  std::int32_t len;
5374  string_t value;
5375  return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_string(len, value) and sax->string(value);
5376  }
5377 
5378  case 0x03: // object
5379  {
5380  return parse_bson_internal();
5381  }
5382 
5383  case 0x04: // array
5384  {
5385  return parse_bson_array();
5386  }
5387 
5388  case 0x08: // boolean
5389  {
5390  return sax->boolean(get() != 0);
5391  }
5392 
5393  case 0x0A: // null
5394  {
5395  return sax->null();
5396  }
5397 
5398  case 0x10: // int32
5399  {
5400  std::int32_t value;
5401  return get_number<std::int32_t, true>(input_format_t::bson, value) and sax->number_integer(value);
5402  }
5403 
5404  case 0x12: // int64
5405  {
5406  std::int64_t value;
5407  return get_number<std::int64_t, true>(input_format_t::bson, value) and sax->number_integer(value);
5408  }
5409 
5410  default: // anything else not supported (yet)
5411  {
5412  std::array<char, 3> cr{{}};
5413  (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
5414  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())));
5415  }
5416  }
5417  }
5418 
5431  bool parse_bson_element_list(const bool is_array)
5432  {
5433  string_t key;
5434  while (int element_type = get())
5435  {
5436  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
5437  {
5438  return false;
5439  }
5440 
5441  const std::size_t element_type_parse_position = chars_read;
5442  if (JSON_HEDLEY_UNLIKELY(not get_bson_cstr(key)))
5443  {
5444  return false;
5445  }
5446 
5447  if (not is_array and not sax->key(key))
5448  {
5449  return false;
5450  }
5451 
5452  if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
5453  {
5454  return false;
5455  }
5456 
5457  // get_bson_cstr only appends
5458  key.clear();
5459  }
5460 
5461  return true;
5462  }
5463 
5468  bool parse_bson_array()
5469  {
5470  std::int32_t document_size;
5471  get_number<std::int32_t, true>(input_format_t::bson, document_size);
5472 
5473  if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
5474  {
5475  return false;
5476  }
5477 
5478  if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
5479  {
5480  return false;
5481  }
5482 
5483  return sax->end_array();
5484  }
5485 
5487  // CBOR //
5489 
5497  bool parse_cbor_internal(const bool get_char = true)
5498  {
5499  switch (get_char ? get() : current)
5500  {
5501  // EOF
5502  case std::char_traits<char>::eof():
5503  return unexpect_eof(input_format_t::cbor, "value");
5504 
5505  // Integer 0x00..0x17 (0..23)
5506  case 0x00:
5507  case 0x01:
5508  case 0x02:
5509  case 0x03:
5510  case 0x04:
5511  case 0x05:
5512  case 0x06:
5513  case 0x07:
5514  case 0x08:
5515  case 0x09:
5516  case 0x0A:
5517  case 0x0B:
5518  case 0x0C:
5519  case 0x0D:
5520  case 0x0E:
5521  case 0x0F:
5522  case 0x10:
5523  case 0x11:
5524  case 0x12:
5525  case 0x13:
5526  case 0x14:
5527  case 0x15:
5528  case 0x16:
5529  case 0x17:
5530  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
5531 
5532  case 0x18: // Unsigned integer (one-byte uint8_t follows)
5533  {
5534  std::uint8_t number;
5535  return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
5536  }
5537 
5538  case 0x19: // Unsigned integer (two-byte uint16_t follows)
5539  {
5540  std::uint16_t number;
5541  return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
5542  }
5543 
5544  case 0x1A: // Unsigned integer (four-byte uint32_t follows)
5545  {
5546  std::uint32_t number;
5547  return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
5548  }
5549 
5550  case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
5551  {
5552  std::uint64_t number;
5553  return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
5554  }
5555 
5556  // Negative integer -1-0x00..-1-0x17 (-1..-24)
5557  case 0x20:
5558  case 0x21:
5559  case 0x22:
5560  case 0x23:
5561  case 0x24:
5562  case 0x25:
5563  case 0x26:
5564  case 0x27:
5565  case 0x28:
5566  case 0x29:
5567  case 0x2A:
5568  case 0x2B:
5569  case 0x2C:
5570  case 0x2D:
5571  case 0x2E:
5572  case 0x2F:
5573  case 0x30:
5574  case 0x31:
5575  case 0x32:
5576  case 0x33:
5577  case 0x34:
5578  case 0x35:
5579  case 0x36:
5580  case 0x37:
5581  return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
5582 
5583  case 0x38: // Negative integer (one-byte uint8_t follows)
5584  {
5585  std::uint8_t number;
5586  return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
5587  }
5588 
5589  case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
5590  {
5591  std::uint16_t number;
5592  return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
5593  }
5594 
5595  case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
5596  {
5597  std::uint32_t number;
5598  return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
5599  }
5600 
5601  case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
5602  {
5603  std::uint64_t number;
5604  return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
5605  - static_cast<number_integer_t>(number));
5606  }
5607 
5608  // UTF-8 string (0x00..0x17 bytes follow)
5609  case 0x60:
5610  case 0x61:
5611  case 0x62:
5612  case 0x63:
5613  case 0x64:
5614  case 0x65:
5615  case 0x66:
5616  case 0x67:
5617  case 0x68:
5618  case 0x69:
5619  case 0x6A:
5620  case 0x6B:
5621  case 0x6C:
5622  case 0x6D:
5623  case 0x6E:
5624  case 0x6F:
5625  case 0x70:
5626  case 0x71:
5627  case 0x72:
5628  case 0x73:
5629  case 0x74:
5630  case 0x75:
5631  case 0x76:
5632  case 0x77:
5633  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
5634  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
5635  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
5636  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
5637  case 0x7F: // UTF-8 string (indefinite length)
5638  {
5639  string_t s;
5640  return get_cbor_string(s) and sax->string(s);
5641  }
5642 
5643  // array (0x00..0x17 data items follow)
5644  case 0x80:
5645  case 0x81:
5646  case 0x82:
5647  case 0x83:
5648  case 0x84:
5649  case 0x85:
5650  case 0x86:
5651  case 0x87:
5652  case 0x88:
5653  case 0x89:
5654  case 0x8A:
5655  case 0x8B:
5656  case 0x8C:
5657  case 0x8D:
5658  case 0x8E:
5659  case 0x8F:
5660  case 0x90:
5661  case 0x91:
5662  case 0x92:
5663  case 0x93:
5664  case 0x94:
5665  case 0x95:
5666  case 0x96:
5667  case 0x97:
5668  return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
5669 
5670  case 0x98: // array (one-byte uint8_t for n follows)
5671  {
5672  std::uint8_t len;
5673  return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
5674  }
5675 
5676  case 0x99: // array (two-byte uint16_t for n follow)
5677  {
5678  std::uint16_t len;
5679  return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
5680  }
5681 
5682  case 0x9A: // array (four-byte uint32_t for n follow)
5683  {
5684  std::uint32_t len;
5685  return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
5686  }
5687 
5688  case 0x9B: // array (eight-byte uint64_t for n follow)
5689  {
5690  std::uint64_t len;
5691  return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
5692  }
5693 
5694  case 0x9F: // array (indefinite length)
5695  return get_cbor_array(std::size_t(-1));
5696 
5697  // map (0x00..0x17 pairs of data items follow)
5698  case 0xA0:
5699  case 0xA1:
5700  case 0xA2:
5701  case 0xA3:
5702  case 0xA4:
5703  case 0xA5:
5704  case 0xA6:
5705  case 0xA7:
5706  case 0xA8:
5707  case 0xA9:
5708  case 0xAA:
5709  case 0xAB:
5710  case 0xAC:
5711  case 0xAD:
5712  case 0xAE:
5713  case 0xAF:
5714  case 0xB0:
5715  case 0xB1:
5716  case 0xB2:
5717  case 0xB3:
5718  case 0xB4:
5719  case 0xB5:
5720  case 0xB6:
5721  case 0xB7:
5722  return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
5723 
5724  case 0xB8: // map (one-byte uint8_t for n follows)
5725  {
5726  std::uint8_t len;
5727  return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
5728  }
5729 
5730  case 0xB9: // map (two-byte uint16_t for n follow)
5731  {
5732  std::uint16_t len;
5733  return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
5734  }
5735 
5736  case 0xBA: // map (four-byte uint32_t for n follow)
5737  {
5738  std::uint32_t len;
5739  return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
5740  }
5741 
5742  case 0xBB: // map (eight-byte uint64_t for n follow)
5743  {
5744  std::uint64_t len;
5745  return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
5746  }
5747 
5748  case 0xBF: // map (indefinite length)
5749  return get_cbor_object(std::size_t(-1));
5750 
5751  case 0xF4: // false
5752  return sax->boolean(false);
5753 
5754  case 0xF5: // true
5755  return sax->boolean(true);
5756 
5757  case 0xF6: // null
5758  return sax->null();
5759 
5760  case 0xF9: // Half-Precision Float (two-byte IEEE 754)
5761  {
5762  const int byte1_raw = get();
5763  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
5764  {
5765  return false;
5766  }
5767  const int byte2_raw = get();
5768  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
5769  {
5770  return false;
5771  }
5772 
5773  const auto byte1 = static_cast<unsigned char>(byte1_raw);
5774  const auto byte2 = static_cast<unsigned char>(byte2_raw);
5775 
5776  // code from RFC 7049, Appendix D, Figure 3:
5777  // As half-precision floating-point numbers were only added
5778  // to IEEE 754 in 2008, today's programming platforms often
5779  // still only have limited support for them. It is very
5780  // easy to include at least decoding support for them even
5781  // without such support. An example of a small decoder for
5782  // half-precision floating-point numbers in the C language
5783  // is shown in Fig. 3.
5784  const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
5785  const double val = [&half]
5786  {
5787  const int exp = (half >> 10u) & 0x1Fu;
5788  const unsigned int mant = half & 0x3FFu;
5789  assert(0 <= exp and exp <= 32);
5790  assert(mant <= 1024);
5791  switch (exp)
5792  {
5793  case 0:
5794  return std::ldexp(mant, -24);
5795  case 31:
5796  return (mant == 0)
5797  ? std::numeric_limits<double>::infinity()
5798  : std::numeric_limits<double>::quiet_NaN();
5799  default:
5800  return std::ldexp(mant + 1024, exp - 25);
5801  }
5802  }();
5803  return sax->number_float((half & 0x8000u) != 0
5804  ? static_cast<number_float_t>(-val)
5805  : static_cast<number_float_t>(val), "");
5806  }
5807 
5808  case 0xFA: // Single-Precision Float (four-byte IEEE 754)
5809  {
5810  float number;
5811  return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
5812  }
5813 
5814  case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
5815  {
5816  double number;
5817  return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
5818  }
5819 
5820  default: // anything else (0xFF is handled inside the other types)
5821  {
5822  auto last_token = get_token_string();
5823  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")));
5824  }
5825  }
5826  }
5827 
5839  bool get_cbor_string(string_t& result)
5840  {
5841  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
5842  {
5843  return false;
5844  }
5845 
5846  switch (current)
5847  {
5848  // UTF-8 string (0x00..0x17 bytes follow)
5849  case 0x60:
5850  case 0x61:
5851  case 0x62:
5852  case 0x63:
5853  case 0x64:
5854  case 0x65:
5855  case 0x66:
5856  case 0x67:
5857  case 0x68:
5858  case 0x69:
5859  case 0x6A:
5860  case 0x6B:
5861  case 0x6C:
5862  case 0x6D:
5863  case 0x6E:
5864  case 0x6F:
5865  case 0x70:
5866  case 0x71:
5867  case 0x72:
5868  case 0x73:
5869  case 0x74:
5870  case 0x75:
5871  case 0x76:
5872  case 0x77:
5873  {
5874  return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
5875  }
5876 
5877  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
5878  {
5879  std::uint8_t len;
5880  return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
5881  }
5882 
5883  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
5884  {
5885  std::uint16_t len;
5886  return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
5887  }
5888 
5889  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
5890  {
5891  std::uint32_t len;
5892  return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
5893  }
5894 
5895  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
5896  {
5897  std::uint64_t len;
5898  return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
5899  }
5900 
5901  case 0x7F: // UTF-8 string (indefinite length)
5902  {
5903  while (get() != 0xFF)
5904  {
5905  string_t chunk;
5906  if (not get_cbor_string(chunk))
5907  {
5908  return false;
5909  }
5910  result.append(chunk);
5911  }
5912  return true;
5913  }
5914 
5915  default:
5916  {
5917  auto last_token = get_token_string();
5918  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")));
5919  }
5920  }
5921  }
5922 
5928  bool get_cbor_array(const std::size_t len)
5929  {
5930  if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
5931  {
5932  return false;
5933  }
5934 
5935  if (len != std::size_t(-1))
5936  {
5937  for (std::size_t i = 0; i < len; ++i)
5938  {
5939  if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
5940  {
5941  return false;
5942  }
5943  }
5944  }
5945  else
5946  {
5947  while (get() != 0xFF)
5948  {
5949  if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal(false)))
5950  {
5951  return false;
5952  }
5953  }
5954  }
5955 
5956  return sax->end_array();
5957  }
5958 
5964  bool get_cbor_object(const std::size_t len)
5965  {
5966  if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
5967  {
5968  return false;
5969  }
5970 
5971  string_t key;
5972  if (len != std::size_t(-1))
5973  {
5974  for (std::size_t i = 0; i < len; ++i)
5975  {
5976  get();
5977  if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
5978  {
5979  return false;
5980  }
5981 
5982  if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
5983  {
5984  return false;
5985  }
5986  key.clear();
5987  }
5988  }
5989  else
5990  {
5991  while (get() != 0xFF)
5992  {
5993  if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
5994  {
5995  return false;
5996  }
5997 
5998  if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
5999  {
6000  return false;
6001  }
6002  key.clear();
6003  }
6004  }
6005 
6006  return sax->end_object();
6007  }
6008 
6010  // MsgPack //
6012 
6016  bool parse_msgpack_internal()
6017  {
6018  switch (get())
6019  {
6020  // EOF
6021  case std::char_traits<char>::eof():
6022  return unexpect_eof(input_format_t::msgpack, "value");
6023 
6024  // positive fixint
6025  case 0x00:
6026  case 0x01:
6027  case 0x02:
6028  case 0x03:
6029  case 0x04:
6030  case 0x05:
6031  case 0x06:
6032  case 0x07:
6033  case 0x08:
6034  case 0x09:
6035  case 0x0A:
6036  case 0x0B:
6037  case 0x0C:
6038  case 0x0D:
6039  case 0x0E:
6040  case 0x0F:
6041  case 0x10:
6042  case 0x11:
6043  case 0x12:
6044  case 0x13:
6045  case 0x14:
6046  case 0x15:
6047  case 0x16:
6048  case 0x17:
6049  case 0x18:
6050  case 0x19:
6051  case 0x1A:
6052  case 0x1B:
6053  case 0x1C:
6054  case 0x1D:
6055  case 0x1E:
6056  case 0x1F:
6057  case 0x20:
6058  case 0x21:
6059  case 0x22:
6060  case 0x23:
6061  case 0x24:
6062  case 0x25:
6063  case 0x26:
6064  case 0x27:
6065  case 0x28:
6066  case 0x29:
6067  case 0x2A:
6068  case 0x2B:
6069  case 0x2C:
6070  case 0x2D:
6071  case 0x2E:
6072  case 0x2F:
6073  case 0x30:
6074  case 0x31:
6075  case 0x32:
6076  case 0x33:
6077  case 0x34:
6078  case 0x35:
6079  case 0x36:
6080  case 0x37:
6081  case 0x38:
6082  case 0x39:
6083  case 0x3A:
6084  case 0x3B:
6085  case 0x3C:
6086  case 0x3D:
6087  case 0x3E:
6088  case 0x3F:
6089  case 0x40:
6090  case 0x41:
6091  case 0x42:
6092  case 0x43:
6093  case 0x44:
6094  case 0x45:
6095  case 0x46:
6096  case 0x47:
6097  case 0x48:
6098  case 0x49:
6099  case 0x4A:
6100  case 0x4B:
6101  case 0x4C:
6102  case 0x4D:
6103  case 0x4E:
6104  case 0x4F:
6105  case 0x50:
6106  case 0x51:
6107  case 0x52:
6108  case 0x53:
6109  case 0x54:
6110  case 0x55:
6111  case 0x56:
6112  case 0x57:
6113  case 0x58:
6114  case 0x59:
6115  case 0x5A:
6116  case 0x5B:
6117  case 0x5C:
6118  case 0x5D:
6119  case 0x5E:
6120  case 0x5F:
6121  case 0x60:
6122  case 0x61:
6123  case 0x62:
6124  case 0x63:
6125  case 0x64:
6126  case 0x65:
6127  case 0x66:
6128  case 0x67:
6129  case 0x68:
6130  case 0x69:
6131  case 0x6A:
6132  case 0x6B:
6133  case 0x6C:
6134  case 0x6D:
6135  case 0x6E:
6136  case 0x6F:
6137  case 0x70:
6138  case 0x71:
6139  case 0x72:
6140  case 0x73:
6141  case 0x74:
6142  case 0x75:
6143  case 0x76:
6144  case 0x77:
6145  case 0x78:
6146  case 0x79:
6147  case 0x7A:
6148  case 0x7B:
6149  case 0x7C:
6150  case 0x7D:
6151  case 0x7E:
6152  case 0x7F:
6153  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
6154 
6155  // fixmap
6156  case 0x80:
6157  case 0x81:
6158  case 0x82:
6159  case 0x83:
6160  case 0x84:
6161  case 0x85:
6162  case 0x86:
6163  case 0x87:
6164  case 0x88:
6165  case 0x89:
6166  case 0x8A:
6167  case 0x8B:
6168  case 0x8C:
6169  case 0x8D:
6170  case 0x8E:
6171  case 0x8F:
6172  return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
6173 
6174  // fixarray
6175  case 0x90:
6176  case 0x91:
6177  case 0x92:
6178  case 0x93:
6179  case 0x94:
6180  case 0x95:
6181  case 0x96:
6182  case 0x97:
6183  case 0x98:
6184  case 0x99:
6185  case 0x9A:
6186  case 0x9B:
6187  case 0x9C:
6188  case 0x9D:
6189  case 0x9E:
6190  case 0x9F:
6191  return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
6192 
6193  // fixstr
6194  case 0xA0:
6195  case 0xA1:
6196  case 0xA2:
6197  case 0xA3:
6198  case 0xA4:
6199  case 0xA5:
6200  case 0xA6:
6201  case 0xA7:
6202  case 0xA8:
6203  case 0xA9:
6204  case 0xAA:
6205  case 0xAB:
6206  case 0xAC:
6207  case 0xAD:
6208  case 0xAE:
6209  case 0xAF:
6210  case 0xB0:
6211  case 0xB1:
6212  case 0xB2:
6213  case 0xB3:
6214  case 0xB4:
6215  case 0xB5:
6216  case 0xB6:
6217  case 0xB7:
6218  case 0xB8:
6219  case 0xB9:
6220  case 0xBA:
6221  case 0xBB:
6222  case 0xBC:
6223  case 0xBD:
6224  case 0xBE:
6225  case 0xBF:
6226  case 0xD9: // str 8
6227  case 0xDA: // str 16
6228  case 0xDB: // str 32
6229  {
6230  string_t s;
6231  return get_msgpack_string(s) and sax->string(s);
6232  }
6233 
6234  case 0xC0: // nil
6235  return sax->null();
6236 
6237  case 0xC2: // false
6238  return sax->boolean(false);
6239 
6240  case 0xC3: // true
6241  return sax->boolean(true);
6242 
6243  case 0xCA: // float 32
6244  {
6245  float number;
6246  return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
6247  }
6248 
6249  case 0xCB: // float 64
6250  {
6251  double number;
6252  return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
6253  }
6254 
6255  case 0xCC: // uint 8
6256  {
6257  std::uint8_t number;
6258  return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
6259  }
6260 
6261  case 0xCD: // uint 16
6262  {
6263  std::uint16_t number;
6264  return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
6265  }
6266 
6267  case 0xCE: // uint 32
6268  {
6269  std::uint32_t number;
6270  return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
6271  }
6272 
6273  case 0xCF: // uint 64
6274  {
6275  std::uint64_t number;
6276  return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
6277  }
6278 
6279  case 0xD0: // int 8
6280  {
6281  std::int8_t number;
6282  return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
6283  }
6284 
6285  case 0xD1: // int 16
6286  {
6287  std::int16_t number;
6288  return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
6289  }
6290 
6291  case 0xD2: // int 32
6292  {
6293  std::int32_t number;
6294  return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
6295  }
6296 
6297  case 0xD3: // int 64
6298  {
6299  std::int64_t number;
6300  return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
6301  }
6302 
6303  case 0xDC: // array 16
6304  {
6305  std::uint16_t len;
6306  return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
6307  }
6308 
6309  case 0xDD: // array 32
6310  {
6311  std::uint32_t len;
6312  return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
6313  }
6314 
6315  case 0xDE: // map 16
6316  {
6317  std::uint16_t len;
6318  return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
6319  }
6320 
6321  case 0xDF: // map 32
6322  {
6323  std::uint32_t len;
6324  return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
6325  }
6326 
6327  // negative fixint
6328  case 0xE0:
6329  case 0xE1:
6330  case 0xE2:
6331  case 0xE3:
6332  case 0xE4:
6333  case 0xE5:
6334  case 0xE6:
6335  case 0xE7:
6336  case 0xE8:
6337  case 0xE9:
6338  case 0xEA:
6339  case 0xEB:
6340  case 0xEC:
6341  case 0xED:
6342  case 0xEE:
6343  case 0xEF:
6344  case 0xF0:
6345  case 0xF1:
6346  case 0xF2:
6347  case 0xF3:
6348  case 0xF4:
6349  case 0xF5:
6350  case 0xF6:
6351  case 0xF7:
6352  case 0xF8:
6353  case 0xF9:
6354  case 0xFA:
6355  case 0xFB:
6356  case 0xFC:
6357  case 0xFD:
6358  case 0xFE:
6359  case 0xFF:
6360  return sax->number_integer(static_cast<std::int8_t>(current));
6361 
6362  default: // anything else
6363  {
6364  auto last_token = get_token_string();
6365  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")));
6366  }
6367  }
6368  }
6369 
6380  bool get_msgpack_string(string_t& result)
6381  {
6382  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
6383  {
6384  return false;
6385  }
6386 
6387  switch (current)
6388  {
6389  // fixstr
6390  case 0xA0:
6391  case 0xA1:
6392  case 0xA2:
6393  case 0xA3:
6394  case 0xA4:
6395  case 0xA5:
6396  case 0xA6:
6397  case 0xA7:
6398  case 0xA8:
6399  case 0xA9:
6400  case 0xAA:
6401  case 0xAB:
6402  case 0xAC:
6403  case 0xAD:
6404  case 0xAE:
6405  case 0xAF:
6406  case 0xB0:
6407  case 0xB1:
6408  case 0xB2:
6409  case 0xB3:
6410  case 0xB4:
6411  case 0xB5:
6412  case 0xB6:
6413  case 0xB7:
6414  case 0xB8:
6415  case 0xB9:
6416  case 0xBA:
6417  case 0xBB:
6418  case 0xBC:
6419  case 0xBD:
6420  case 0xBE:
6421  case 0xBF:
6422  {
6423  return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
6424  }
6425 
6426  case 0xD9: // str 8
6427  {
6428  std::uint8_t len;
6429  return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
6430  }
6431 
6432  case 0xDA: // str 16
6433  {
6434  std::uint16_t len;
6435  return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
6436  }
6437 
6438  case 0xDB: // str 32
6439  {
6440  std::uint32_t len;
6441  return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
6442  }
6443 
6444  default:
6445  {
6446  auto last_token = get_token_string();
6447  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")));
6448  }
6449  }
6450  }
6451 
6456  bool get_msgpack_array(const std::size_t len)
6457  {
6458  if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
6459  {
6460  return false;
6461  }
6462 
6463  for (std::size_t i = 0; i < len; ++i)
6464  {
6465  if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
6466  {
6467  return false;
6468  }
6469  }
6470 
6471  return sax->end_array();
6472  }
6473 
6478  bool get_msgpack_object(const std::size_t len)
6479  {
6480  if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
6481  {
6482  return false;
6483  }
6484 
6485  string_t key;
6486  for (std::size_t i = 0; i < len; ++i)
6487  {
6488  get();
6489  if (JSON_HEDLEY_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
6490  {
6491  return false;
6492  }
6493 
6494  if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
6495  {
6496  return false;
6497  }
6498  key.clear();
6499  }
6500 
6501  return sax->end_object();
6502  }
6503 
6505  // UBJSON //
6507 
6515  bool parse_ubjson_internal(const bool get_char = true)
6516  {
6517  return get_ubjson_value(get_char ? get_ignore_noop() : current);
6518  }
6519 
6534  bool get_ubjson_string(string_t& result, const bool get_char = true)
6535  {
6536  if (get_char)
6537  {
6538  get(); // TODO(niels): may we ignore N here?
6539  }
6540 
6541  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
6542  {
6543  return false;
6544  }
6545 
6546  switch (current)
6547  {
6548  case 'U':
6549  {
6550  std::uint8_t len;
6551  return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
6552  }
6553 
6554  case 'i':
6555  {
6556  std::int8_t len;
6557  return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
6558  }
6559 
6560  case 'I':
6561  {
6562  std::int16_t len;
6563  return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
6564  }
6565 
6566  case 'l':
6567  {
6568  std::int32_t len;
6569  return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
6570  }
6571 
6572  case 'L':
6573  {
6574  std::int64_t len;
6575  return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
6576  }
6577 
6578  default:
6579  auto last_token = get_token_string();
6580  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")));
6581  }
6582  }
6583 
6588  bool get_ubjson_size_value(std::size_t& result)
6589  {
6590  switch (get_ignore_noop())
6591  {
6592  case 'U':
6593  {
6594  std::uint8_t number;
6595  if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
6596  {
6597  return false;
6598  }
6599  result = static_cast<std::size_t>(number);
6600  return true;
6601  }
6602 
6603  case 'i':
6604  {
6605  std::int8_t number;
6606  if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
6607  {
6608  return false;
6609  }
6610  result = static_cast<std::size_t>(number);
6611  return true;
6612  }
6613 
6614  case 'I':
6615  {
6616  std::int16_t number;
6617  if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
6618  {
6619  return false;
6620  }
6621  result = static_cast<std::size_t>(number);
6622  return true;
6623  }
6624 
6625  case 'l':
6626  {
6627  std::int32_t number;
6628  if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
6629  {
6630  return false;
6631  }
6632  result = static_cast<std::size_t>(number);
6633  return true;
6634  }
6635 
6636  case 'L':
6637  {
6638  std::int64_t number;
6639  if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
6640  {
6641  return false;
6642  }
6643  result = static_cast<std::size_t>(number);
6644  return true;
6645  }
6646 
6647  default:
6648  {
6649  auto last_token = get_token_string();
6650  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")));
6651  }
6652  }
6653  }
6654 
6665  bool get_ubjson_size_type(std::pair<std::size_t, int>& result)
6666  {
6667  result.first = string_t::npos; // size
6668  result.second = 0; // type
6669 
6670  get_ignore_noop();
6671 
6672  if (current == '$')
6673  {
6674  result.second = get(); // must not ignore 'N', because 'N' maybe the type
6675  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
6676  {
6677  return false;
6678  }
6679 
6680  get_ignore_noop();
6681  if (JSON_HEDLEY_UNLIKELY(current != '#'))
6682  {
6683  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
6684  {
6685  return false;
6686  }
6687  auto last_token = get_token_string();
6688  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")));
6689  }
6690 
6691  return get_ubjson_size_value(result.first);
6692  }
6693 
6694  if (current == '#')
6695  {
6696  return get_ubjson_size_value(result.first);
6697  }
6698 
6699  return true;
6700  }
6701 
6706  bool get_ubjson_value(const int prefix)
6707  {
6708  switch (prefix)
6709  {
6710  case std::char_traits<char>::eof(): // EOF
6711  return unexpect_eof(input_format_t::ubjson, "value");
6712 
6713  case 'T': // true
6714  return sax->boolean(true);
6715  case 'F': // false
6716  return sax->boolean(false);
6717 
6718  case 'Z': // null
6719  return sax->null();
6720 
6721  case 'U':
6722  {
6723  std::uint8_t number;
6724  return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
6725  }
6726 
6727  case 'i':
6728  {
6729  std::int8_t number;
6730  return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
6731  }
6732 
6733  case 'I':
6734  {
6735  std::int16_t number;
6736  return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
6737  }
6738 
6739  case 'l':
6740  {
6741  std::int32_t number;
6742  return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
6743  }
6744 
6745  case 'L':
6746  {
6747  std::int64_t number;
6748  return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
6749  }
6750 
6751  case 'd':
6752  {
6753  float number;
6754  return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
6755  }
6756 
6757  case 'D':
6758  {
6759  double number;
6760  return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
6761  }
6762 
6763  case 'C': // char
6764  {
6765  get();
6766  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
6767  {
6768  return false;
6769  }
6770  if (JSON_HEDLEY_UNLIKELY(current > 127))
6771  {
6772  auto last_token = get_token_string();
6773  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")));
6774  }
6775  string_t s(1, static_cast<char>(current));
6776  return sax->string(s);
6777  }
6778 
6779  case 'S': // string
6780  {
6781  string_t s;
6782  return get_ubjson_string(s) and sax->string(s);
6783  }
6784 
6785  case '[': // array
6786  return get_ubjson_array();
6787 
6788  case '{': // object
6789  return get_ubjson_object();
6790 
6791  default: // anything else
6792  {
6793  auto last_token = get_token_string();
6794  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")));
6795  }
6796  }
6797  }
6798 
6802  bool get_ubjson_array()
6803  {
6804  std::pair<std::size_t, int> size_and_type;
6805  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
6806  {
6807  return false;
6808  }
6809 
6810  if (size_and_type.first != string_t::npos)
6811  {
6812  if (JSON_HEDLEY_UNLIKELY(not sax->start_array(size_and_type.first)))
6813  {
6814  return false;
6815  }
6816 
6817  if (size_and_type.second != 0)
6818  {
6819  if (size_and_type.second != 'N')
6820  {
6821  for (std::size_t i = 0; i < size_and_type.first; ++i)
6822  {
6823  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
6824  {
6825  return false;
6826  }
6827  }
6828  }
6829  }
6830  else
6831  {
6832  for (std::size_t i = 0; i < size_and_type.first; ++i)
6833  {
6834  if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
6835  {
6836  return false;
6837  }
6838  }
6839  }
6840  }
6841  else
6842  {
6843  if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
6844  {
6845  return false;
6846  }
6847 
6848  while (current != ']')
6849  {
6850  if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal(false)))
6851  {
6852  return false;
6853  }
6854  get_ignore_noop();
6855  }
6856  }
6857 
6858  return sax->end_array();
6859  }
6860 
6864  bool get_ubjson_object()
6865  {
6866  std::pair<std::size_t, int> size_and_type;
6867  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
6868  {
6869  return false;
6870  }
6871 
6872  string_t key;
6873  if (size_and_type.first != string_t::npos)
6874  {
6875  if (JSON_HEDLEY_UNLIKELY(not sax->start_object(size_and_type.first)))
6876  {
6877  return false;
6878  }
6879 
6880  if (size_and_type.second != 0)
6881  {
6882  for (std::size_t i = 0; i < size_and_type.first; ++i)
6883  {
6884  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
6885  {
6886  return false;
6887  }
6888  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
6889  {
6890  return false;
6891  }
6892  key.clear();
6893  }
6894  }
6895  else
6896  {
6897  for (std::size_t i = 0; i < size_and_type.first; ++i)
6898  {
6899  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
6900  {
6901  return false;
6902  }
6903  if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
6904  {
6905  return false;
6906  }
6907  key.clear();
6908  }
6909  }
6910  }
6911  else
6912  {
6913  if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
6914  {
6915  return false;
6916  }
6917 
6918  while (current != '}')
6919  {
6920  if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
6921  {
6922  return false;
6923  }
6924  if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
6925  {
6926  return false;
6927  }
6928  get_ignore_noop();
6929  key.clear();
6930  }
6931  }
6932 
6933  return sax->end_object();
6934  }
6935 
6937  // Utility functions //
6939 
6949  int get()
6950  {
6951  ++chars_read;
6952  return current = ia->get_character();
6953  }
6954 
6958  int get_ignore_noop()
6959  {
6960  do
6961  {
6962  get();
6963  }
6964  while (current == 'N');
6965 
6966  return current;
6967  }
6968 
6969  /*
6970  @brief read a number from the input
6971 
6972  @tparam NumberType the type of the number
6973  @param[in] format the current format (for diagnostics)
6974  @param[out] result number of type @a NumberType
6975 
6976  @return whether conversion completed
6977 
6978  @note This function needs to respect the system's endianess, because
6979  bytes in CBOR, MessagePack, and UBJSON are stored in network order
6980  (big endian) and therefore need reordering on little endian systems.
6981  */
6982  template<typename NumberType, bool InputIsLittleEndian = false>
6983  bool get_number(const input_format_t format, NumberType& result)
6984  {
6985  // step 1: read input into array with system's byte order
6986  std::array<std::uint8_t, sizeof(NumberType)> vec;
6987  for (std::size_t i = 0; i < sizeof(NumberType); ++i)
6988  {
6989  get();
6990  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "number")))
6991  {
6992  return false;
6993  }
6994 
6995  // reverse byte order prior to conversion if necessary
6996  if (is_little_endian != InputIsLittleEndian)
6997  {
6998  vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
6999  }
7000  else
7001  {
7002  vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
7003  }
7004  }
7005 
7006  // step 2: convert array into number of type T and return
7007  std::memcpy(&result, vec.data(), sizeof(NumberType));
7008  return true;
7009  }
7010 
7025  template<typename NumberType>
7026  bool get_string(const input_format_t format,
7027  const NumberType len,
7028  string_t& result)
7029  {
7030  bool success = true;
7031  std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
7032  {
7033  get();
7034  if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "string")))
7035  {
7036  success = false;
7037  }
7038  return static_cast<char>(current);
7039  });
7040  return success;
7041  }
7042 
7049  bool unexpect_eof(const input_format_t format, const char* context) const
7050  {
7051  if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char>::eof()))
7052  {
7053  return sax->parse_error(chars_read, "<end of file>",
7054  parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
7055  }
7056  return true;
7057  }
7058 
7062  std::string get_token_string() const
7063  {
7064  std::array<char, 3> cr{{}};
7065  (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
7066  return std::string{cr.data()};
7067  }
7068 
7075  std::string exception_message(const input_format_t format,
7076  const std::string& detail,
7077  const std::string& context) const
7078  {
7079  std::string error_msg = "syntax error while parsing ";
7080 
7081  switch (format)
7082  {
7083  case input_format_t::cbor:
7084  error_msg += "CBOR";
7085  break;
7086 
7087  case input_format_t::msgpack:
7088  error_msg += "MessagePack";
7089  break;
7090 
7091  case input_format_t::ubjson:
7092  error_msg += "UBJSON";
7093  break;
7094 
7095  case input_format_t::bson:
7096  error_msg += "BSON";
7097  break;
7098 
7099  default: // LCOV_EXCL_LINE
7100  assert(false); // LCOV_EXCL_LINE
7101  }
7102 
7103  return error_msg + " " + context + ": " + detail;
7104  }
7105 
7106  private:
7108  input_adapter_t ia = nullptr;
7109 
7111  int current = std::char_traits<char>::eof();
7112 
7114  std::size_t chars_read = 0;
7115 
7117  const bool is_little_endian = little_endianess();
7118 
7120  json_sax_t* sax = nullptr;
7121 };
7122 } // namespace detail
7123 } // namespace nlohmann
7124 
7125 // #include <nlohmann/detail/input/input_adapters.hpp>
7126 
7127 // #include <nlohmann/detail/input/lexer.hpp>
7128 
7129 
7130 #include <array> // array
7131 #include <clocale> // localeconv
7132 #include <cstddef> // size_t
7133 #include <cstdio> // snprintf
7134 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
7135 #include <initializer_list> // initializer_list
7136 #include <string> // char_traits, string
7137 #include <utility> // move
7138 #include <vector> // vector
7139 
7140 // #include <nlohmann/detail/input/input_adapters.hpp>
7141 
7142 // #include <nlohmann/detail/input/position_t.hpp>
7143 
7144 // #include <nlohmann/detail/macro_scope.hpp>
7145 
7146 
7147 namespace nlohmann
7148 {
7149 namespace detail
7150 {
7152 // lexer //
7154 
7160 template<typename BasicJsonType>
7161 class lexer
7162 {
7163  using number_integer_t = typename BasicJsonType::number_integer_t;
7164  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7165  using number_float_t = typename BasicJsonType::number_float_t;
7166  using string_t = typename BasicJsonType::string_t;
7167 
7168  public:
7170  enum class token_type
7171  {
7172  uninitialized,
7173  literal_true,
7174  literal_false,
7175  literal_null,
7176  value_string,
7177  value_unsigned,
7178  value_integer,
7179  value_float,
7180  begin_array,
7181  begin_object,
7182  end_array,
7183  end_object,
7184  name_separator,
7185  value_separator,
7186  parse_error,
7187  end_of_input,
7188  literal_or_value
7189  };
7190 
7194  static const char* token_type_name(const token_type t) noexcept
7195  {
7196  switch (t)
7197  {
7198  case token_type::uninitialized:
7199  return "<uninitialized>";
7200  case token_type::literal_true:
7201  return "true literal";
7202  case token_type::literal_false:
7203  return "false literal";
7204  case token_type::literal_null:
7205  return "null literal";
7206  case token_type::value_string:
7207  return "string literal";
7208  case lexer::token_type::value_unsigned:
7209  case lexer::token_type::value_integer:
7210  case lexer::token_type::value_float:
7211  return "number literal";
7212  case token_type::begin_array:
7213  return "'['";
7214  case token_type::begin_object:
7215  return "'{'";
7216  case token_type::end_array:
7217  return "']'";
7218  case token_type::end_object:
7219  return "'}'";
7220  case token_type::name_separator:
7221  return "':'";
7222  case token_type::value_separator:
7223  return "','";
7224  case token_type::parse_error:
7225  return "<parse error>";
7226  case token_type::end_of_input:
7227  return "end of input";
7228  case token_type::literal_or_value:
7229  return "'[', '{', or a literal";
7230  // LCOV_EXCL_START
7231  default: // catch non-enum values
7232  return "unknown token";
7233  // LCOV_EXCL_STOP
7234  }
7235  }
7236 
7237  explicit lexer(detail::input_adapter_t&& adapter)
7238  : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}
7239 
7240  // delete because of pointer members
7241  lexer(const lexer&) = delete;
7242  lexer(lexer&&) = delete;
7243  lexer& operator=(lexer&) = delete;
7244  lexer& operator=(lexer&&) = delete;
7245  ~lexer() = default;
7246 
7247  private:
7249  // locales
7251 
7254  static char get_decimal_point() noexcept
7255  {
7256  const auto loc = localeconv();
7257  assert(loc != nullptr);
7258  return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
7259  }
7260 
7262  // scan functions
7264 
7280  int get_codepoint()
7281  {
7282  // this function only makes sense after reading `\u`
7283  assert(current == 'u');
7284  int codepoint = 0;
7285 
7286  const auto factors = { 12u, 8u, 4u, 0u };
7287  for (const auto factor : factors)
7288  {
7289  get();
7290 
7291  if (current >= '0' and current <= '9')
7292  {
7293  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
7294  }
7295  else if (current >= 'A' and current <= 'F')
7296  {
7297  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
7298  }
7299  else if (current >= 'a' and current <= 'f')
7300  {
7301  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
7302  }
7303  else
7304  {
7305  return -1;
7306  }
7307  }
7308 
7309  assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
7310  return codepoint;
7311  }
7312 
7328  bool next_byte_in_range(std::initializer_list<int> ranges)
7329  {
7330  assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
7331  add(current);
7332 
7333  for (auto range = ranges.begin(); range != ranges.end(); ++range)
7334  {
7335  get();
7336  if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
7337  {
7338  add(current);
7339  }
7340  else
7341  {
7342  error_message = "invalid string: ill-formed UTF-8 byte";
7343  return false;
7344  }
7345  }
7346 
7347  return true;
7348  }
7349 
7365  token_type scan_string()
7366  {
7367  // reset token_buffer (ignore opening quote)
7368  reset();
7369 
7370  // we entered the function by reading an open quote
7371  assert(current == '\"');
7372 
7373  while (true)
7374  {
7375  // get next character
7376  switch (get())
7377  {
7378  // end of file while parsing string
7379  case std::char_traits<char>::eof():
7380  {
7381  error_message = "invalid string: missing closing quote";
7382  return token_type::parse_error;
7383  }
7384 
7385  // closing quote
7386  case '\"':
7387  {
7388  return token_type::value_string;
7389  }
7390 
7391  // escapes
7392  case '\\':
7393  {
7394  switch (get())
7395  {
7396  // quotation mark
7397  case '\"':
7398  add('\"');
7399  break;
7400  // reverse solidus
7401  case '\\':
7402  add('\\');
7403  break;
7404  // solidus
7405  case '/':
7406  add('/');
7407  break;
7408  // backspace
7409  case 'b':
7410  add('\b');
7411  break;
7412  // form feed
7413  case 'f':
7414  add('\f');
7415  break;
7416  // line feed
7417  case 'n':
7418  add('\n');
7419  break;
7420  // carriage return
7421  case 'r':
7422  add('\r');
7423  break;
7424  // tab
7425  case 't':
7426  add('\t');
7427  break;
7428 
7429  // unicode escapes
7430  case 'u':
7431  {
7432  const int codepoint1 = get_codepoint();
7433  int codepoint = codepoint1; // start with codepoint1
7434 
7435  if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
7436  {
7437  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
7438  return token_type::parse_error;
7439  }
7440 
7441  // check if code point is a high surrogate
7442  if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
7443  {
7444  // expect next \uxxxx entry
7445  if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
7446  {
7447  const int codepoint2 = get_codepoint();
7448 
7449  if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
7450  {
7451  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
7452  return token_type::parse_error;
7453  }
7454 
7455  // check if codepoint2 is a low surrogate
7456  if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
7457  {
7458  // overwrite codepoint
7459  codepoint = static_cast<int>(
7460  // high surrogate occupies the most significant 22 bits
7461  (static_cast<unsigned int>(codepoint1) << 10u)
7462  // low surrogate occupies the least significant 15 bits
7463  + static_cast<unsigned int>(codepoint2)
7464  // there is still the 0xD800, 0xDC00 and 0x10000 noise
7465  // in the result so we have to subtract with:
7466  // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
7467  - 0x35FDC00u);
7468  }
7469  else
7470  {
7471  error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
7472  return token_type::parse_error;
7473  }
7474  }
7475  else
7476  {
7477  error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
7478  return token_type::parse_error;
7479  }
7480  }
7481  else
7482  {
7483  if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
7484  {
7485  error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
7486  return token_type::parse_error;
7487  }
7488  }
7489 
7490  // result of the above calculation yields a proper codepoint
7491  assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
7492 
7493  // translate codepoint into bytes
7494  if (codepoint < 0x80)
7495  {
7496  // 1-byte characters: 0xxxxxxx (ASCII)
7497  add(codepoint);
7498  }
7499  else if (codepoint <= 0x7FF)
7500  {
7501  // 2-byte characters: 110xxxxx 10xxxxxx
7502  add(static_cast<int>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
7503  add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7504  }
7505  else if (codepoint <= 0xFFFF)
7506  {
7507  // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
7508  add(static_cast<int>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
7509  add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7510  add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7511  }
7512  else
7513  {
7514  // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
7515  add(static_cast<int>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
7516  add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
7517  add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
7518  add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
7519  }
7520 
7521  break;
7522  }
7523 
7524  // other characters after escape
7525  default:
7526  error_message = "invalid string: forbidden character after backslash";
7527  return token_type::parse_error;
7528  }
7529 
7530  break;
7531  }
7532 
7533  // invalid control characters
7534  case 0x00:
7535  {
7536  error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
7537  return token_type::parse_error;
7538  }
7539 
7540  case 0x01:
7541  {
7542  error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
7543  return token_type::parse_error;
7544  }
7545 
7546  case 0x02:
7547  {
7548  error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
7549  return token_type::parse_error;
7550  }
7551 
7552  case 0x03:
7553  {
7554  error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
7555  return token_type::parse_error;
7556  }
7557 
7558  case 0x04:
7559  {
7560  error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
7561  return token_type::parse_error;
7562  }
7563 
7564  case 0x05:
7565  {
7566  error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
7567  return token_type::parse_error;
7568  }
7569 
7570  case 0x06:
7571  {
7572  error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
7573  return token_type::parse_error;
7574  }
7575 
7576  case 0x07:
7577  {
7578  error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
7579  return token_type::parse_error;
7580  }
7581 
7582  case 0x08:
7583  {
7584  error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
7585  return token_type::parse_error;
7586  }
7587 
7588  case 0x09:
7589  {
7590  error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
7591  return token_type::parse_error;
7592  }
7593 
7594  case 0x0A:
7595  {
7596  error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
7597  return token_type::parse_error;
7598  }
7599 
7600  case 0x0B:
7601  {
7602  error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
7603  return token_type::parse_error;
7604  }
7605 
7606  case 0x0C:
7607  {
7608  error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
7609  return token_type::parse_error;
7610  }
7611 
7612  case 0x0D:
7613  {
7614  error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
7615  return token_type::parse_error;
7616  }
7617 
7618  case 0x0E:
7619  {
7620  error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
7621  return token_type::parse_error;
7622  }
7623 
7624  case 0x0F:
7625  {
7626  error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
7627  return token_type::parse_error;
7628  }
7629 
7630  case 0x10:
7631  {
7632  error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
7633  return token_type::parse_error;
7634  }
7635 
7636  case 0x11:
7637  {
7638  error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
7639  return token_type::parse_error;
7640  }
7641 
7642  case 0x12:
7643  {
7644  error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
7645  return token_type::parse_error;
7646  }
7647 
7648  case 0x13:
7649  {
7650  error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
7651  return token_type::parse_error;
7652  }
7653 
7654  case 0x14:
7655  {
7656  error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
7657  return token_type::parse_error;
7658  }
7659 
7660  case 0x15:
7661  {
7662  error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
7663  return token_type::parse_error;
7664  }
7665 
7666  case 0x16:
7667  {
7668  error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
7669  return token_type::parse_error;
7670  }
7671 
7672  case 0x17:
7673  {
7674  error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
7675  return token_type::parse_error;
7676  }
7677 
7678  case 0x18:
7679  {
7680  error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
7681  return token_type::parse_error;
7682  }
7683 
7684  case 0x19:
7685  {
7686  error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
7687  return token_type::parse_error;
7688  }
7689 
7690  case 0x1A:
7691  {
7692  error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
7693  return token_type::parse_error;
7694  }
7695 
7696  case 0x1B:
7697  {
7698  error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
7699  return token_type::parse_error;
7700  }
7701 
7702  case 0x1C:
7703  {
7704  error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
7705  return token_type::parse_error;
7706  }
7707 
7708  case 0x1D:
7709  {
7710  error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
7711  return token_type::parse_error;
7712  }
7713 
7714  case 0x1E:
7715  {
7716  error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
7717  return token_type::parse_error;
7718  }
7719 
7720  case 0x1F:
7721  {
7722  error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
7723  return token_type::parse_error;
7724  }
7725 
7726  // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
7727  case 0x20:
7728  case 0x21:
7729  case 0x23:
7730  case 0x24:
7731  case 0x25:
7732  case 0x26:
7733  case 0x27:
7734  case 0x28:
7735  case 0x29:
7736  case 0x2A:
7737  case 0x2B:
7738  case 0x2C:
7739  case 0x2D:
7740  case 0x2E:
7741  case 0x2F:
7742  case 0x30:
7743  case 0x31:
7744  case 0x32:
7745  case 0x33:
7746  case 0x34:
7747  case 0x35:
7748  case 0x36:
7749  case 0x37:
7750  case 0x38:
7751  case 0x39:
7752  case 0x3A:
7753  case 0x3B:
7754  case 0x3C:
7755  case 0x3D:
7756  case 0x3E:
7757  case 0x3F:
7758  case 0x40:
7759  case 0x41:
7760  case 0x42:
7761  case 0x43:
7762  case 0x44:
7763  case 0x45:
7764  case 0x46:
7765  case 0x47:
7766  case 0x48:
7767  case 0x49:
7768  case 0x4A:
7769  case 0x4B:
7770  case 0x4C:
7771  case 0x4D:
7772  case 0x4E:
7773  case 0x4F:
7774  case 0x50:
7775  case 0x51:
7776  case 0x52:
7777  case 0x53:
7778  case 0x54:
7779  case 0x55:
7780  case 0x56:
7781  case 0x57:
7782  case 0x58:
7783  case 0x59:
7784  case 0x5A:
7785  case 0x5B:
7786  case 0x5D:
7787  case 0x5E:
7788  case 0x5F:
7789  case 0x60:
7790  case 0x61:
7791  case 0x62:
7792  case 0x63:
7793  case 0x64:
7794  case 0x65:
7795  case 0x66:
7796  case 0x67:
7797  case 0x68:
7798  case 0x69:
7799  case 0x6A:
7800  case 0x6B:
7801  case 0x6C:
7802  case 0x6D:
7803  case 0x6E:
7804  case 0x6F:
7805  case 0x70:
7806  case 0x71:
7807  case 0x72:
7808  case 0x73:
7809  case 0x74:
7810  case 0x75:
7811  case 0x76:
7812  case 0x77:
7813  case 0x78:
7814  case 0x79:
7815  case 0x7A:
7816  case 0x7B:
7817  case 0x7C:
7818  case 0x7D:
7819  case 0x7E:
7820  case 0x7F:
7821  {
7822  add(current);
7823  break;
7824  }
7825 
7826  // U+0080..U+07FF: bytes C2..DF 80..BF
7827  case 0xC2:
7828  case 0xC3:
7829  case 0xC4:
7830  case 0xC5:
7831  case 0xC6:
7832  case 0xC7:
7833  case 0xC8:
7834  case 0xC9:
7835  case 0xCA:
7836  case 0xCB:
7837  case 0xCC:
7838  case 0xCD:
7839  case 0xCE:
7840  case 0xCF:
7841  case 0xD0:
7842  case 0xD1:
7843  case 0xD2:
7844  case 0xD3:
7845  case 0xD4:
7846  case 0xD5:
7847  case 0xD6:
7848  case 0xD7:
7849  case 0xD8:
7850  case 0xD9:
7851  case 0xDA:
7852  case 0xDB:
7853  case 0xDC:
7854  case 0xDD:
7855  case 0xDE:
7856  case 0xDF:
7857  {
7858  if (JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
7859  {
7860  return token_type::parse_error;
7861  }
7862  break;
7863  }
7864 
7865  // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
7866  case 0xE0:
7867  {
7868  if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7869  {
7870  return token_type::parse_error;
7871  }
7872  break;
7873  }
7874 
7875  // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
7876  // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
7877  case 0xE1:
7878  case 0xE2:
7879  case 0xE3:
7880  case 0xE4:
7881  case 0xE5:
7882  case 0xE6:
7883  case 0xE7:
7884  case 0xE8:
7885  case 0xE9:
7886  case 0xEA:
7887  case 0xEB:
7888  case 0xEC:
7889  case 0xEE:
7890  case 0xEF:
7891  {
7892  if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7893  {
7894  return token_type::parse_error;
7895  }
7896  break;
7897  }
7898 
7899  // U+D000..U+D7FF: bytes ED 80..9F 80..BF
7900  case 0xED:
7901  {
7902  if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7903  {
7904  return token_type::parse_error;
7905  }
7906  break;
7907  }
7908 
7909  // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
7910  case 0xF0:
7911  {
7912  if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7913  {
7914  return token_type::parse_error;
7915  }
7916  break;
7917  }
7918 
7919  // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
7920  case 0xF1:
7921  case 0xF2:
7922  case 0xF3:
7923  {
7924  if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7925  {
7926  return token_type::parse_error;
7927  }
7928  break;
7929  }
7930 
7931  // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
7932  case 0xF4:
7933  {
7934  if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7935  {
7936  return token_type::parse_error;
7937  }
7938  break;
7939  }
7940 
7941  // remaining bytes (80..C1 and F5..FF) are ill-formed
7942  default:
7943  {
7944  error_message = "invalid string: ill-formed UTF-8 byte";
7945  return token_type::parse_error;
7946  }
7947  }
7948  }
7949  }
7950 
7952  static void strtof(float& f, const char* str, char** endptr) noexcept
7953  {
7954  f = std::strtof(str, endptr);
7955  }
7956 
7958  static void strtof(double& f, const char* str, char** endptr) noexcept
7959  {
7960  f = std::strtod(str, endptr);
7961  }
7962 
7964  static void strtof(long double& f, const char* str, char** endptr) noexcept
7965  {
7966  f = std::strtold(str, endptr);
7967  }
7968 
8009  token_type scan_number() // lgtm [cpp/use-of-goto]
8010  {
8011  // reset token_buffer to store the number's bytes
8012  reset();
8013 
8014  // the type of the parsed number; initially set to unsigned; will be
8015  // changed if minus sign, decimal point or exponent is read
8016  token_type number_type = token_type::value_unsigned;
8017 
8018  // state (init): we just found out we need to scan a number
8019  switch (current)
8020  {
8021  case '-':
8022  {
8023  add(current);
8024  goto scan_number_minus;
8025  }
8026 
8027  case '0':
8028  {
8029  add(current);
8030  goto scan_number_zero;
8031  }
8032 
8033  case '1':
8034  case '2':
8035  case '3':
8036  case '4':
8037  case '5':
8038  case '6':
8039  case '7':
8040  case '8':
8041  case '9':
8042  {
8043  add(current);
8044  goto scan_number_any1;
8045  }
8046 
8047  // all other characters are rejected outside scan_number()
8048  default: // LCOV_EXCL_LINE
8049  assert(false); // LCOV_EXCL_LINE
8050  }
8051 
8052 scan_number_minus:
8053  // state: we just parsed a leading minus sign
8054  number_type = token_type::value_integer;
8055  switch (get())
8056  {
8057  case '0':
8058  {
8059  add(current);
8060  goto scan_number_zero;
8061  }
8062 
8063  case '1':
8064  case '2':
8065  case '3':
8066  case '4':
8067  case '5':
8068  case '6':
8069  case '7':
8070  case '8':
8071  case '9':
8072  {
8073  add(current);
8074  goto scan_number_any1;
8075  }
8076 
8077  default:
8078  {
8079  error_message = "invalid number; expected digit after '-'";
8080  return token_type::parse_error;
8081  }
8082  }
8083 
8084 scan_number_zero:
8085  // state: we just parse a zero (maybe with a leading minus sign)
8086  switch (get())
8087  {
8088  case '.':
8089  {
8090  add(decimal_point_char);
8091  goto scan_number_decimal1;
8092  }
8093 
8094  case 'e':
8095  case 'E':
8096  {
8097  add(current);
8098  goto scan_number_exponent;
8099  }
8100 
8101  default:
8102  goto scan_number_done;
8103  }
8104 
8105 scan_number_any1:
8106  // state: we just parsed a number 0-9 (maybe with a leading minus sign)
8107  switch (get())
8108  {
8109  case '0':
8110  case '1':
8111  case '2':
8112  case '3':
8113  case '4':
8114  case '5':
8115  case '6':
8116  case '7':
8117  case '8':
8118  case '9':
8119  {
8120  add(current);
8121  goto scan_number_any1;
8122  }
8123 
8124  case '.':
8125  {
8126  add(decimal_point_char);
8127  goto scan_number_decimal1;
8128  }
8129 
8130  case 'e':
8131  case 'E':
8132  {
8133  add(current);
8134  goto scan_number_exponent;
8135  }
8136 
8137  default:
8138  goto scan_number_done;
8139  }
8140 
8141 scan_number_decimal1:
8142  // state: we just parsed a decimal point
8143  number_type = token_type::value_float;
8144  switch (get())
8145  {
8146  case '0':
8147  case '1':
8148  case '2':
8149  case '3':
8150  case '4':
8151  case '5':
8152  case '6':
8153  case '7':
8154  case '8':
8155  case '9':
8156  {
8157  add(current);
8158  goto scan_number_decimal2;
8159  }
8160 
8161  default:
8162  {
8163  error_message = "invalid number; expected digit after '.'";
8164  return token_type::parse_error;
8165  }
8166  }
8167 
8168 scan_number_decimal2:
8169  // we just parsed at least one number after a decimal point
8170  switch (get())
8171  {
8172  case '0':
8173  case '1':
8174  case '2':
8175  case '3':
8176  case '4':
8177  case '5':
8178  case '6':
8179  case '7':
8180  case '8':
8181  case '9':
8182  {
8183  add(current);
8184  goto scan_number_decimal2;
8185  }
8186 
8187  case 'e':
8188  case 'E':
8189  {
8190  add(current);
8191  goto scan_number_exponent;
8192  }
8193 
8194  default:
8195  goto scan_number_done;
8196  }
8197 
8198 scan_number_exponent:
8199  // we just parsed an exponent
8200  number_type = token_type::value_float;
8201  switch (get())
8202  {
8203  case '+':
8204  case '-':
8205  {
8206  add(current);
8207  goto scan_number_sign;
8208  }
8209 
8210  case '0':
8211  case '1':
8212  case '2':
8213  case '3':
8214  case '4':
8215  case '5':
8216  case '6':
8217  case '7':
8218  case '8':
8219  case '9':
8220  {
8221  add(current);
8222  goto scan_number_any2;
8223  }
8224 
8225  default:
8226  {
8227  error_message =
8228  "invalid number; expected '+', '-', or digit after exponent";
8229  return token_type::parse_error;
8230  }
8231  }
8232 
8233 scan_number_sign:
8234  // we just parsed an exponent sign
8235  switch (get())
8236  {
8237  case '0':
8238  case '1':
8239  case '2':
8240  case '3':
8241  case '4':
8242  case '5':
8243  case '6':
8244  case '7':
8245  case '8':
8246  case '9':
8247  {
8248  add(current);
8249  goto scan_number_any2;
8250  }
8251 
8252  default:
8253  {
8254  error_message = "invalid number; expected digit after exponent sign";
8255  return token_type::parse_error;
8256  }
8257  }
8258 
8259 scan_number_any2:
8260  // we just parsed a number after the exponent or exponent sign
8261  switch (get())
8262  {
8263  case '0':
8264  case '1':
8265  case '2':
8266  case '3':
8267  case '4':
8268  case '5':
8269  case '6':
8270  case '7':
8271  case '8':
8272  case '9':
8273  {
8274  add(current);
8275  goto scan_number_any2;
8276  }
8277 
8278  default:
8279  goto scan_number_done;
8280  }
8281 
8282 scan_number_done:
8283  // unget the character after the number (we only read it to know that
8284  // we are done scanning a number)
8285  unget();
8286 
8287  char* endptr = nullptr;
8288  errno = 0;
8289 
8290  // try to parse integers first and fall back to floats
8291  if (number_type == token_type::value_unsigned)
8292  {
8293  const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
8294 
8295  // we checked the number format before
8296  assert(endptr == token_buffer.data() + token_buffer.size());
8297 
8298  if (errno == 0)
8299  {
8300  value_unsigned = static_cast<number_unsigned_t>(x);
8301  if (value_unsigned == x)
8302  {
8303  return token_type::value_unsigned;
8304  }
8305  }
8306  }
8307  else if (number_type == token_type::value_integer)
8308  {
8309  const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
8310 
8311  // we checked the number format before
8312  assert(endptr == token_buffer.data() + token_buffer.size());
8313 
8314  if (errno == 0)
8315  {
8316  value_integer = static_cast<number_integer_t>(x);
8317  if (value_integer == x)
8318  {
8319  return token_type::value_integer;
8320  }
8321  }
8322  }
8323 
8324  // this code is reached if we parse a floating-point number or if an
8325  // integer conversion above failed
8326  strtof(value_float, token_buffer.data(), &endptr);
8327 
8328  // we checked the number format before
8329  assert(endptr == token_buffer.data() + token_buffer.size());
8330 
8331  return token_type::value_float;
8332  }
8333 
8340  token_type scan_literal(const char* literal_text, const std::size_t length,
8341  token_type return_type)
8342  {
8343  assert(current == literal_text[0]);
8344  for (std::size_t i = 1; i < length; ++i)
8345  {
8346  if (JSON_HEDLEY_UNLIKELY(get() != literal_text[i]))
8347  {
8348  error_message = "invalid literal";
8349  return token_type::parse_error;
8350  }
8351  }
8352  return return_type;
8353  }
8354 
8356  // input management
8358 
8360  void reset() noexcept
8361  {
8362  token_buffer.clear();
8363  token_string.clear();
8364  token_string.push_back(std::char_traits<char>::to_char_type(current));
8365  }
8366 
8367  /*
8368  @brief get next character from the input
8369 
8370  This function provides the interface to the used input adapter. It does
8371  not throw in case the input reached EOF, but returns a
8372  `std::char_traits<char>::eof()` in that case. Stores the scanned characters
8373  for use in error messages.
8374 
8375  @return character read from the input
8376  */
8377  std::char_traits<char>::int_type get()
8378  {
8379  ++position.chars_read_total;
8380  ++position.chars_read_current_line;
8381 
8382  if (next_unget)
8383  {
8384  // just reset the next_unget variable and work with current
8385  next_unget = false;
8386  }
8387  else
8388  {
8389  current = ia->get_character();
8390  }
8391 
8392  if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
8393  {
8394  token_string.push_back(std::char_traits<char>::to_char_type(current));
8395  }
8396 
8397  if (current == '\n')
8398  {
8399  ++position.lines_read;
8400  position.chars_read_current_line = 0;
8401  }
8402 
8403  return current;
8404  }
8405 
8414  void unget()
8415  {
8416  next_unget = true;
8417 
8418  --position.chars_read_total;
8419 
8420  // in case we "unget" a newline, we have to also decrement the lines_read
8421  if (position.chars_read_current_line == 0)
8422  {
8423  if (position.lines_read > 0)
8424  {
8425  --position.lines_read;
8426  }
8427  }
8428  else
8429  {
8430  --position.chars_read_current_line;
8431  }
8432 
8433  if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
8434  {
8435  assert(not token_string.empty());
8436  token_string.pop_back();
8437  }
8438  }
8439 
8441  void add(int c)
8442  {
8443  token_buffer.push_back(std::char_traits<char>::to_char_type(c));
8444  }
8445 
8446  public:
8448  // value getters
8450 
8452  constexpr number_integer_t get_number_integer() const noexcept
8453  {
8454  return value_integer;
8455  }
8456 
8458  constexpr number_unsigned_t get_number_unsigned() const noexcept
8459  {
8460  return value_unsigned;
8461  }
8462 
8464  constexpr number_float_t get_number_float() const noexcept
8465  {
8466  return value_float;
8467  }
8468 
8470  string_t& get_string()
8471  {
8472  return token_buffer;
8473  }
8474 
8476  // diagnostics
8478 
8480  constexpr position_t get_position() const noexcept
8481  {
8482  return position;
8483  }
8484 
8488  std::string get_token_string() const
8489  {
8490  // escape control characters
8491  std::string result;
8492  for (const auto c : token_string)
8493  {
8494  if ('\x00' <= c and c <= '\x1F')
8495  {
8496  // escape control characters
8497  std::array<char, 9> cs{{}};
8498  (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
8499  result += cs.data();
8500  }
8501  else
8502  {
8503  // add character as is
8504  result.push_back(c);
8505  }
8506  }
8507 
8508  return result;
8509  }
8510 
8513  constexpr const char* get_error_message() const noexcept
8514  {
8515  return error_message;
8516  }
8517 
8519  // actual scanner
8521 
8526  bool skip_bom()
8527  {
8528  if (get() == 0xEF)
8529  {
8530  // check if we completely parse the BOM
8531  return get() == 0xBB and get() == 0xBF;
8532  }
8533 
8534  // the first character is not the beginning of the BOM; unget it to
8535  // process is later
8536  unget();
8537  return true;
8538  }
8539 
8540  token_type scan()
8541  {
8542  // initially, skip the BOM
8543  if (position.chars_read_total == 0 and not skip_bom())
8544  {
8545  error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
8546  return token_type::parse_error;
8547  }
8548 
8549  // read next character and ignore whitespace
8550  do
8551  {
8552  get();
8553  }
8554  while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
8555 
8556  switch (current)
8557  {
8558  // structural characters
8559  case '[':
8560  return token_type::begin_array;
8561  case ']':
8562  return token_type::end_array;
8563  case '{':
8564  return token_type::begin_object;
8565  case '}':
8566  return token_type::end_object;
8567  case ':':
8568  return token_type::name_separator;
8569  case ',':
8570  return token_type::value_separator;
8571 
8572  // literals
8573  case 't':
8574  return scan_literal("true", 4, token_type::literal_true);
8575  case 'f':
8576  return scan_literal("false", 5, token_type::literal_false);
8577  case 'n':
8578  return scan_literal("null", 4, token_type::literal_null);
8579 
8580  // string
8581  case '\"':
8582  return scan_string();
8583 
8584  // number
8585  case '-':
8586  case '0':
8587  case '1':
8588  case '2':
8589  case '3':
8590  case '4':
8591  case '5':
8592  case '6':
8593  case '7':
8594  case '8':
8595  case '9':
8596  return scan_number();
8597 
8598  // end of input (the null byte is needed when parsing from
8599  // string literals)
8600  case '\0':
8601  case std::char_traits<char>::eof():
8602  return token_type::end_of_input;
8603 
8604  // error
8605  default:
8606  error_message = "invalid literal";
8607  return token_type::parse_error;
8608  }
8609  }
8610 
8611  private:
8614 
8616  std::char_traits<char>::int_type current = std::char_traits<char>::eof();
8617 
8619  bool next_unget = false;
8620 
8623 
8625  std::vector<char> token_string {};
8626 
8628  string_t token_buffer {};
8629 
8631  const char* error_message = "";
8632 
8633  // number values
8634  number_integer_t value_integer = 0;
8635  number_unsigned_t value_unsigned = 0;
8636  number_float_t value_float = 0;
8637 
8639  const char decimal_point_char = '.';
8640 };
8641 } // namespace detail
8642 } // namespace nlohmann
8643 
8644 // #include <nlohmann/detail/input/parser.hpp>
8645 
8646 
8647 #include <cassert> // assert
8648 #include <cmath> // isfinite
8649 #include <cstdint> // uint8_t
8650 #include <functional> // function
8651 #include <string> // string
8652 #include <utility> // move
8653 #include <vector> // vector
8654 
8655 // #include <nlohmann/detail/exceptions.hpp>
8656 
8657 // #include <nlohmann/detail/input/input_adapters.hpp>
8658 
8659 // #include <nlohmann/detail/input/json_sax.hpp>
8660 
8661 // #include <nlohmann/detail/input/lexer.hpp>
8662 
8663 // #include <nlohmann/detail/macro_scope.hpp>
8664 
8665 // #include <nlohmann/detail/meta/is_sax.hpp>
8666 
8667 // #include <nlohmann/detail/value_t.hpp>
8668 
8669 
8670 namespace nlohmann
8671 {
8672 namespace detail
8673 {
8675 // parser //
8677 
8683 template<typename BasicJsonType>
8684 class parser
8685 {
8686  using number_integer_t = typename BasicJsonType::number_integer_t;
8687  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8688  using number_float_t = typename BasicJsonType::number_float_t;
8689  using string_t = typename BasicJsonType::string_t;
8692 
8693  public:
8694  enum class parse_event_t : uint8_t
8695  {
8697  object_start,
8699  object_end,
8701  array_start,
8703  array_end,
8705  key,
8707  value
8708  };
8709 
8710  using parser_callback_t =
8711  std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
8712 
8714  explicit parser(detail::input_adapter_t&& adapter,
8715  const parser_callback_t cb = nullptr,
8716  const bool allow_exceptions_ = true)
8717  : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)
8718  {
8719  // read first token
8720  get_token();
8721  }
8722 
8733  void parse(const bool strict, BasicJsonType& result)
8734  {
8735  if (callback)
8736  {
8737  json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
8738  sax_parse_internal(&sdp);
8739  result.assert_invariant();
8740 
8741  // in strict mode, input must be completely read
8742  if (strict and (get_token() != token_type::end_of_input))
8743  {
8744  sdp.parse_error(m_lexer.get_position(),
8745  m_lexer.get_token_string(),
8746  parse_error::create(101, m_lexer.get_position(),
8747  exception_message(token_type::end_of_input, "value")));
8748  }
8749 
8750  // in case of an error, return discarded value
8751  if (sdp.is_errored())
8752  {
8753  result = value_t::discarded;
8754  return;
8755  }
8756 
8757  // set top-level value to null if it was discarded by the callback
8758  // function
8759  if (result.is_discarded())
8760  {
8761  result = nullptr;
8762  }
8763  }
8764  else
8765  {
8766  json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
8767  sax_parse_internal(&sdp);
8768  result.assert_invariant();
8769 
8770  // in strict mode, input must be completely read
8771  if (strict and (get_token() != token_type::end_of_input))
8772  {
8773  sdp.parse_error(m_lexer.get_position(),
8774  m_lexer.get_token_string(),
8775  parse_error::create(101, m_lexer.get_position(),
8776  exception_message(token_type::end_of_input, "value")));
8777  }
8778 
8779  // in case of an error, return discarded value
8780  if (sdp.is_errored())
8781  {
8782  result = value_t::discarded;
8783  return;
8784  }
8785  }
8786  }
8787 
8794  bool accept(const bool strict = true)
8795  {
8796  json_sax_acceptor<BasicJsonType> sax_acceptor;
8797  return sax_parse(&sax_acceptor, strict);
8798  }
8799 
8800  template <typename SAX>
8802  bool sax_parse(SAX* sax, const bool strict = true)
8803  {
8805  const bool result = sax_parse_internal(sax);
8806 
8807  // strict mode: next byte must be EOF
8808  if (result and strict and (get_token() != token_type::end_of_input))
8809  {
8810  return sax->parse_error(m_lexer.get_position(),
8811  m_lexer.get_token_string(),
8812  parse_error::create(101, m_lexer.get_position(),
8813  exception_message(token_type::end_of_input, "value")));
8814  }
8815 
8816  return result;
8817  }
8818 
8819  private:
8820  template <typename SAX>
8822  bool sax_parse_internal(SAX* sax)
8823  {
8824  // stack to remember the hierarchy of structured values we are parsing
8825  // true = array; false = object
8826  std::vector<bool> states;
8827  // value to avoid a goto (see comment where set to true)
8828  bool skip_to_state_evaluation = false;
8829 
8830  while (true)
8831  {
8832  if (not skip_to_state_evaluation)
8833  {
8834  // invariant: get_token() was called before each iteration
8835  switch (last_token)
8836  {
8837  case token_type::begin_object:
8838  {
8839  if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
8840  {
8841  return false;
8842  }
8843 
8844  // closing } -> we are done
8845  if (get_token() == token_type::end_object)
8846  {
8847  if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
8848  {
8849  return false;
8850  }
8851  break;
8852  }
8853 
8854  // parse key
8855  if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
8856  {
8857  return sax->parse_error(m_lexer.get_position(),
8858  m_lexer.get_token_string(),
8859  parse_error::create(101, m_lexer.get_position(),
8860  exception_message(token_type::value_string, "object key")));
8861  }
8862  if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
8863  {
8864  return false;
8865  }
8866 
8867  // parse separator (:)
8868  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
8869  {
8870  return sax->parse_error(m_lexer.get_position(),
8871  m_lexer.get_token_string(),
8872  parse_error::create(101, m_lexer.get_position(),
8873  exception_message(token_type::name_separator, "object separator")));
8874  }
8875 
8876  // remember we are now inside an object
8877  states.push_back(false);
8878 
8879  // parse values
8880  get_token();
8881  continue;
8882  }
8883 
8884  case token_type::begin_array:
8885  {
8886  if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
8887  {
8888  return false;
8889  }
8890 
8891  // closing ] -> we are done
8892  if (get_token() == token_type::end_array)
8893  {
8894  if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
8895  {
8896  return false;
8897  }
8898  break;
8899  }
8900 
8901  // remember we are now inside an array
8902  states.push_back(true);
8903 
8904  // parse values (no need to call get_token)
8905  continue;
8906  }
8907 
8908  case token_type::value_float:
8909  {
8910  const auto res = m_lexer.get_number_float();
8911 
8912  if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
8913  {
8914  return sax->parse_error(m_lexer.get_position(),
8915  m_lexer.get_token_string(),
8916  out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
8917  }
8918 
8919  if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
8920  {
8921  return false;
8922  }
8923 
8924  break;
8925  }
8926 
8927  case token_type::literal_false:
8928  {
8929  if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
8930  {
8931  return false;
8932  }
8933  break;
8934  }
8935 
8936  case token_type::literal_null:
8937  {
8938  if (JSON_HEDLEY_UNLIKELY(not sax->null()))
8939  {
8940  return false;
8941  }
8942  break;
8943  }
8944 
8945  case token_type::literal_true:
8946  {
8947  if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
8948  {
8949  return false;
8950  }
8951  break;
8952  }
8953 
8954  case token_type::value_integer:
8955  {
8956  if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
8957  {
8958  return false;
8959  }
8960  break;
8961  }
8962 
8963  case token_type::value_string:
8964  {
8965  if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
8966  {
8967  return false;
8968  }
8969  break;
8970  }
8971 
8972  case token_type::value_unsigned:
8973  {
8974  if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
8975  {
8976  return false;
8977  }
8978  break;
8979  }
8980 
8981  case token_type::parse_error:
8982  {
8983  // using "uninitialized" to avoid "expected" message
8984  return sax->parse_error(m_lexer.get_position(),
8985  m_lexer.get_token_string(),
8986  parse_error::create(101, m_lexer.get_position(),
8987  exception_message(token_type::uninitialized, "value")));
8988  }
8989 
8990  default: // the last token was unexpected
8991  {
8992  return sax->parse_error(m_lexer.get_position(),
8993  m_lexer.get_token_string(),
8994  parse_error::create(101, m_lexer.get_position(),
8995  exception_message(token_type::literal_or_value, "value")));
8996  }
8997  }
8998  }
8999  else
9000  {
9001  skip_to_state_evaluation = false;
9002  }
9003 
9004  // we reached this line after we successfully parsed a value
9005  if (states.empty())
9006  {
9007  // empty stack: we reached the end of the hierarchy: done
9008  return true;
9009  }
9010 
9011  if (states.back()) // array
9012  {
9013  // comma -> next value
9014  if (get_token() == token_type::value_separator)
9015  {
9016  // parse a new value
9017  get_token();
9018  continue;
9019  }
9020 
9021  // closing ]
9022  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
9023  {
9024  if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
9025  {
9026  return false;
9027  }
9028 
9029  // We are done with this array. Before we can parse a
9030  // new value, we need to evaluate the new state first.
9031  // By setting skip_to_state_evaluation to false, we
9032  // are effectively jumping to the beginning of this if.
9033  assert(not states.empty());
9034  states.pop_back();
9035  skip_to_state_evaluation = true;
9036  continue;
9037  }
9038 
9039  return sax->parse_error(m_lexer.get_position(),
9040  m_lexer.get_token_string(),
9041  parse_error::create(101, m_lexer.get_position(),
9042  exception_message(token_type::end_array, "array")));
9043  }
9044  else // object
9045  {
9046  // comma -> next value
9047  if (get_token() == token_type::value_separator)
9048  {
9049  // parse key
9050  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
9051  {
9052  return sax->parse_error(m_lexer.get_position(),
9053  m_lexer.get_token_string(),
9054  parse_error::create(101, m_lexer.get_position(),
9055  exception_message(token_type::value_string, "object key")));
9056  }
9057 
9058  if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
9059  {
9060  return false;
9061  }
9062 
9063  // parse separator (:)
9064  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
9065  {
9066  return sax->parse_error(m_lexer.get_position(),
9067  m_lexer.get_token_string(),
9068  parse_error::create(101, m_lexer.get_position(),
9069  exception_message(token_type::name_separator, "object separator")));
9070  }
9071 
9072  // parse values
9073  get_token();
9074  continue;
9075  }
9076 
9077  // closing }
9078  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
9079  {
9080  if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
9081  {
9082  return false;
9083  }
9084 
9085  // We are done with this object. Before we can parse a
9086  // new value, we need to evaluate the new state first.
9087  // By setting skip_to_state_evaluation to false, we
9088  // are effectively jumping to the beginning of this if.
9089  assert(not states.empty());
9090  states.pop_back();
9091  skip_to_state_evaluation = true;
9092  continue;
9093  }
9094 
9095  return sax->parse_error(m_lexer.get_position(),
9096  m_lexer.get_token_string(),
9097  parse_error::create(101, m_lexer.get_position(),
9098  exception_message(token_type::end_object, "object")));
9099  }
9100  }
9101  }
9102 
9104  token_type get_token()
9105  {
9106  return last_token = m_lexer.scan();
9107  }
9108 
9109  std::string exception_message(const token_type expected, const std::string& context)
9110  {
9111  std::string error_msg = "syntax error ";
9112 
9113  if (not context.empty())
9114  {
9115  error_msg += "while parsing " + context + " ";
9116  }
9117 
9118  error_msg += "- ";
9119 
9120  if (last_token == token_type::parse_error)
9121  {
9122  error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
9123  m_lexer.get_token_string() + "'";
9124  }
9125  else
9126  {
9127  error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
9128  }
9129 
9130  if (expected != token_type::uninitialized)
9131  {
9132  error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
9133  }
9134 
9135  return error_msg;
9136  }
9137 
9138  private:
9140  const parser_callback_t callback = nullptr;
9142  token_type last_token = token_type::uninitialized;
9146  const bool allow_exceptions = true;
9147 };
9148 } // namespace detail
9149 } // namespace nlohmann
9150 
9151 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
9152 
9153 
9154 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
9155 
9156 
9157 #include <cstddef> // ptrdiff_t
9158 #include <limits> // numeric_limits
9159 
9160 namespace nlohmann
9161 {
9162 namespace detail
9163 {
9164 /*
9165 @brief an iterator for primitive JSON types
9166 
9167 This class models an iterator for primitive JSON types (boolean, number,
9168 string). It's only purpose is to allow the iterator/const_iterator classes
9169 to "iterate" over primitive values. Internally, the iterator is modeled by
9170 a `difference_type` variable. Value begin_value (`0`) models the begin,
9171 end_value (`1`) models past the end.
9172 */
9174 {
9175  private:
9176  using difference_type = std::ptrdiff_t;
9177  static constexpr difference_type begin_value = 0;
9178  static constexpr difference_type end_value = begin_value + 1;
9179 
9182 
9183  public:
9184  constexpr difference_type get_value() const noexcept
9185  {
9186  return m_it;
9187  }
9188 
9190  void set_begin() noexcept
9191  {
9192  m_it = begin_value;
9193  }
9194 
9196  void set_end() noexcept
9197  {
9198  m_it = end_value;
9199  }
9200 
9202  constexpr bool is_begin() const noexcept
9203  {
9204  return m_it == begin_value;
9205  }
9206 
9208  constexpr bool is_end() const noexcept
9209  {
9210  return m_it == end_value;
9211  }
9212 
9213  friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
9214  {
9215  return lhs.m_it == rhs.m_it;
9216  }
9217 
9218  friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
9219  {
9220  return lhs.m_it < rhs.m_it;
9221  }
9222 
9224  {
9225  auto result = *this;
9226  result += n;
9227  return result;
9228  }
9229 
9231  {
9232  return lhs.m_it - rhs.m_it;
9233  }
9234 
9235  primitive_iterator_t& operator++() noexcept
9236  {
9237  ++m_it;
9238  return *this;
9239  }
9240 
9241  primitive_iterator_t const operator++(int) noexcept
9242  {
9243  auto result = *this;
9244  ++m_it;
9245  return result;
9246  }
9247 
9248  primitive_iterator_t& operator--() noexcept
9249  {
9250  --m_it;
9251  return *this;
9252  }
9253 
9254  primitive_iterator_t const operator--(int) noexcept
9255  {
9256  auto result = *this;
9257  --m_it;
9258  return result;
9259  }
9260 
9262  {
9263  m_it += n;
9264  return *this;
9265  }
9266 
9268  {
9269  m_it -= n;
9270  return *this;
9271  }
9272 };
9273 } // namespace detail
9274 } // namespace nlohmann
9275 
9276 
9277 namespace nlohmann
9278 {
9279 namespace detail
9280 {
9287 template<typename BasicJsonType> struct internal_iterator
9288 {
9290  typename BasicJsonType::object_t::iterator object_iterator {};
9292  typename BasicJsonType::array_t::iterator array_iterator {};
9294  primitive_iterator_t primitive_iterator {};
9295 };
9296 } // namespace detail
9297 } // namespace nlohmann
9298 
9299 // #include <nlohmann/detail/iterators/iter_impl.hpp>
9300 
9301 
9302 #include <ciso646> // not
9303 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
9304 #include <type_traits> // conditional, is_const, remove_const
9305 
9306 // #include <nlohmann/detail/exceptions.hpp>
9307 
9308 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
9309 
9310 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
9311 
9312 // #include <nlohmann/detail/macro_scope.hpp>
9313 
9314 // #include <nlohmann/detail/meta/cpp_future.hpp>
9315 
9316 // #include <nlohmann/detail/meta/type_traits.hpp>
9317 
9318 // #include <nlohmann/detail/value_t.hpp>
9319 
9320 
9321 namespace nlohmann
9322 {
9323 namespace detail
9324 {
9325 // forward declare, to be able to friend it later on
9326 template<typename IteratorType> class iteration_proxy;
9327 template<typename IteratorType> class iteration_proxy_value;
9328 
9345 template<typename BasicJsonType>
9347 {
9349  friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
9353 
9354  using object_t = typename BasicJsonType::object_t;
9355  using array_t = typename BasicJsonType::array_t;
9356  // make sure BasicJsonType is basic_json or const basic_json
9357  static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
9358  "iter_impl only accepts (const) basic_json");
9359 
9360  public:
9361 
9367  using iterator_category = std::bidirectional_iterator_tag;
9368 
9370  using value_type = typename BasicJsonType::value_type;
9372  using difference_type = typename BasicJsonType::difference_type;
9375  typename BasicJsonType::const_pointer,
9376  typename BasicJsonType::pointer>::type;
9378  using reference =
9380  typename BasicJsonType::const_reference,
9381  typename BasicJsonType::reference>::type;
9382 
9384  iter_impl() = default;
9385 
9392  explicit iter_impl(pointer object) noexcept : m_object(object)
9393  {
9394  assert(m_object != nullptr);
9395 
9396  switch (m_object->m_type)
9397  {
9398  case value_t::object:
9399  {
9400  m_it.object_iterator = typename object_t::iterator();
9401  break;
9402  }
9403 
9404  case value_t::array:
9405  {
9406  m_it.array_iterator = typename array_t::iterator();
9407  break;
9408  }
9409 
9410  default:
9411  {
9412  m_it.primitive_iterator = primitive_iterator_t();
9413  break;
9414  }
9415  }
9416  }
9417 
9435  : m_object(other.m_object), m_it(other.m_it)
9436  {}
9437 
9444  iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
9445  {
9446  m_object = other.m_object;
9447  m_it = other.m_it;
9448  return *this;
9449  }
9450 
9456  iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
9457  : m_object(other.m_object), m_it(other.m_it)
9458  {}
9459 
9466  iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
9467  {
9468  m_object = other.m_object;
9469  m_it = other.m_it;
9470  return *this;
9471  }
9472 
9473  private:
9478  void set_begin() noexcept
9479  {
9480  assert(m_object != nullptr);
9481 
9482  switch (m_object->m_type)
9483  {
9484  case value_t::object:
9485  {
9486  m_it.object_iterator = m_object->m_value.object->begin();
9487  break;
9488  }
9489 
9490  case value_t::array:
9491  {
9492  m_it.array_iterator = m_object->m_value.array->begin();
9493  break;
9494  }
9495 
9496  case value_t::null:
9497  {
9498  // set to end so begin()==end() is true: null is empty
9499  m_it.primitive_iterator.set_end();
9500  break;
9501  }
9502 
9503  default:
9504  {
9505  m_it.primitive_iterator.set_begin();
9506  break;
9507  }
9508  }
9509  }
9510 
9515  void set_end() noexcept
9516  {
9517  assert(m_object != nullptr);
9518 
9519  switch (m_object->m_type)
9520  {
9521  case value_t::object:
9522  {
9523  m_it.object_iterator = m_object->m_value.object->end();
9524  break;
9525  }
9526 
9527  case value_t::array:
9528  {
9529  m_it.array_iterator = m_object->m_value.array->end();
9530  break;
9531  }
9532 
9533  default:
9534  {
9535  m_it.primitive_iterator.set_end();
9536  break;
9537  }
9538  }
9539  }
9540 
9541  public:
9547  {
9548  assert(m_object != nullptr);
9549 
9550  switch (m_object->m_type)
9551  {
9552  case value_t::object:
9553  {
9554  assert(m_it.object_iterator != m_object->m_value.object->end());
9555  return m_it.object_iterator->second;
9556  }
9557 
9558  case value_t::array:
9559  {
9560  assert(m_it.array_iterator != m_object->m_value.array->end());
9561  return *m_it.array_iterator;
9562  }
9563 
9564  case value_t::null:
9565  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
9566 
9567  default:
9568  {
9569  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
9570  {
9571  return *m_object;
9572  }
9573 
9574  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
9575  }
9576  }
9577  }
9578 
9583  pointer operator->() const
9584  {
9585  assert(m_object != nullptr);
9586 
9587  switch (m_object->m_type)
9588  {
9589  case value_t::object:
9590  {
9591  assert(m_it.object_iterator != m_object->m_value.object->end());
9592  return &(m_it.object_iterator->second);
9593  }
9594 
9595  case value_t::array:
9596  {
9597  assert(m_it.array_iterator != m_object->m_value.array->end());
9598  return &*m_it.array_iterator;
9599  }
9600 
9601  default:
9602  {
9603  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
9604  {
9605  return m_object;
9606  }
9607 
9608  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
9609  }
9610  }
9611  }
9612 
9617  iter_impl const operator++(int)
9618  {
9619  auto result = *this;
9620  ++(*this);
9621  return result;
9622  }
9623 
9628  iter_impl& operator++()
9629  {
9630  assert(m_object != nullptr);
9631 
9632  switch (m_object->m_type)
9633  {
9634  case value_t::object:
9635  {
9636  std::advance(m_it.object_iterator, 1);
9637  break;
9638  }
9639 
9640  case value_t::array:
9641  {
9642  std::advance(m_it.array_iterator, 1);
9643  break;
9644  }
9645 
9646  default:
9647  {
9648  ++m_it.primitive_iterator;
9649  break;
9650  }
9651  }
9652 
9653  return *this;
9654  }
9655 
9660  iter_impl const operator--(int)
9661  {
9662  auto result = *this;
9663  --(*this);
9664  return result;
9665  }
9666 
9671  iter_impl& operator--()
9672  {
9673  assert(m_object != nullptr);
9674 
9675  switch (m_object->m_type)
9676  {
9677  case value_t::object:
9678  {
9679  std::advance(m_it.object_iterator, -1);
9680  break;
9681  }
9682 
9683  case value_t::array:
9684  {
9685  std::advance(m_it.array_iterator, -1);
9686  break;
9687  }
9688 
9689  default:
9690  {
9691  --m_it.primitive_iterator;
9692  break;
9693  }
9694  }
9695 
9696  return *this;
9697  }
9698 
9703  bool operator==(const iter_impl& other) const
9704  {
9705  // if objects are not the same, the comparison is undefined
9706  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
9707  {
9708  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
9709  }
9710 
9711  assert(m_object != nullptr);
9712 
9713  switch (m_object->m_type)
9714  {
9715  case value_t::object:
9716  return (m_it.object_iterator == other.m_it.object_iterator);
9717 
9718  case value_t::array:
9719  return (m_it.array_iterator == other.m_it.array_iterator);
9720 
9721  default:
9722  return (m_it.primitive_iterator == other.m_it.primitive_iterator);
9723  }
9724  }
9725 
9730  bool operator!=(const iter_impl& other) const
9731  {
9732  return not operator==(other);
9733  }
9734 
9739  bool operator<(const iter_impl& other) const
9740  {
9741  // if objects are not the same, the comparison is undefined
9742  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
9743  {
9744  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
9745  }
9746 
9747  assert(m_object != nullptr);
9748 
9749  switch (m_object->m_type)
9750  {
9751  case value_t::object:
9752  JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
9753 
9754  case value_t::array:
9755  return (m_it.array_iterator < other.m_it.array_iterator);
9756 
9757  default:
9758  return (m_it.primitive_iterator < other.m_it.primitive_iterator);
9759  }
9760  }
9761 
9766  bool operator<=(const iter_impl& other) const
9767  {
9768  return not other.operator < (*this);
9769  }
9770 
9775  bool operator>(const iter_impl& other) const
9776  {
9777  return not operator<=(other);
9778  }
9779 
9784  bool operator>=(const iter_impl& other) const
9785  {
9786  return not operator<(other);
9787  }
9788 
9794  {
9795  assert(m_object != nullptr);
9796 
9797  switch (m_object->m_type)
9798  {
9799  case value_t::object:
9800  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
9801 
9802  case value_t::array:
9803  {
9804  std::advance(m_it.array_iterator, i);
9805  break;
9806  }
9807 
9808  default:
9809  {
9810  m_it.primitive_iterator += i;
9811  break;
9812  }
9813  }
9814 
9815  return *this;
9816  }
9817 
9823  {
9824  return operator+=(-i);
9825  }
9826 
9832  {
9833  auto result = *this;
9834  result += i;
9835  return result;
9836  }
9837 
9843  {
9844  auto result = it;
9845  result += i;
9846  return result;
9847  }
9848 
9854  {
9855  auto result = *this;
9856  result -= i;
9857  return result;
9858  }
9859 
9865  {
9866  assert(m_object != nullptr);
9867 
9868  switch (m_object->m_type)
9869  {
9870  case value_t::object:
9871  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
9872 
9873  case value_t::array:
9874  return m_it.array_iterator - other.m_it.array_iterator;
9875 
9876  default:
9877  return m_it.primitive_iterator - other.m_it.primitive_iterator;
9878  }
9879  }
9880 
9885  reference operator[](difference_type n) const
9886  {
9887  assert(m_object != nullptr);
9888 
9889  switch (m_object->m_type)
9890  {
9891  case value_t::object:
9892  JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
9893 
9894  case value_t::array:
9895  return *std::next(m_it.array_iterator, n);
9896 
9897  case value_t::null:
9898  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
9899 
9900  default:
9901  {
9902  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
9903  {
9904  return *m_object;
9905  }
9906 
9907  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
9908  }
9909  }
9910  }
9911 
9916  const typename object_t::key_type& key() const
9917  {
9918  assert(m_object != nullptr);
9919 
9920  if (JSON_HEDLEY_LIKELY(m_object->is_object()))
9921  {
9922  return m_it.object_iterator->first;
9923  }
9924 
9925  JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
9926  }
9927 
9933  {
9934  return operator*();
9935  }
9936 
9937  private:
9939  pointer m_object = nullptr;
9942 };
9943 } // namespace detail
9944 } // namespace nlohmann
9945 
9946 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
9947 
9948 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
9949 
9950 
9951 #include <cstddef> // ptrdiff_t
9952 #include <iterator> // reverse_iterator
9953 #include <utility> // declval
9954 
9955 namespace nlohmann
9956 {
9957 namespace detail
9958 {
9960 // reverse_iterator //
9962 
9981 template<typename Base>
9982 class json_reverse_iterator : public std::reverse_iterator<Base>
9983 {
9984  public:
9985  using difference_type = std::ptrdiff_t;
9987  using base_iterator = std::reverse_iterator<Base>;
9989  using reference = typename Base::reference;
9990 
9992  explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
9993  : base_iterator(it) {}
9994 
9996  explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
9997 
9999  json_reverse_iterator const operator++(int)
10000  {
10001  return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
10002  }
10003 
10006  {
10007  return static_cast<json_reverse_iterator&>(base_iterator::operator++());
10008  }
10009 
10011  json_reverse_iterator const operator--(int)
10012  {
10013  return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
10014  }
10015 
10018  {
10019  return static_cast<json_reverse_iterator&>(base_iterator::operator--());
10020  }
10021 
10024  {
10025  return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
10026  }
10027 
10030  {
10031  return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
10032  }
10033 
10036  {
10037  return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
10038  }
10039 
10042  {
10043  return base_iterator(*this) - base_iterator(other);
10044  }
10045 
10047  reference operator[](difference_type n) const
10048  {
10049  return *(this->operator+(n));
10050  }
10051 
10053  auto key() const -> decltype(std::declval<Base>().key())
10054  {
10055  auto it = --this->base();
10056  return it.key();
10057  }
10058 
10061  {
10062  auto it = --this->base();
10063  return it.operator * ();
10064  }
10065 };
10066 } // namespace detail
10067 } // namespace nlohmann
10068 
10069 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
10070 
10071 // #include <nlohmann/detail/json_pointer.hpp>
10072 
10073 
10074 #include <algorithm> // all_of
10075 #include <cassert> // assert
10076 #include <cctype> // isdigit
10077 #include <numeric> // accumulate
10078 #include <string> // string
10079 #include <utility> // move
10080 #include <vector> // vector
10081 
10082 // #include <nlohmann/detail/exceptions.hpp>
10083 
10084 // #include <nlohmann/detail/macro_scope.hpp>
10085 
10086 // #include <nlohmann/detail/value_t.hpp>
10087 
10088 
10089 namespace nlohmann
10090 {
10091 template<typename BasicJsonType>
10093 {
10094  // allow basic_json to access private members
10096  friend class basic_json;
10097 
10098  public:
10120  explicit json_pointer(const std::string& s = "")
10121  : reference_tokens(split(s))
10122  {}
10123 
10138  std::string to_string() const
10139  {
10140  return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
10141  std::string{},
10142  [](const std::string & a, const std::string & b)
10143  {
10144  return a + "/" + escape(b);
10145  });
10146  }
10147 
10149  operator std::string() const
10150  {
10151  return to_string();
10152  }
10153 
10170  json_pointer& operator/=(const json_pointer& ptr)
10171  {
10172  reference_tokens.insert(reference_tokens.end(),
10173  ptr.reference_tokens.begin(),
10174  ptr.reference_tokens.end());
10175  return *this;
10176  }
10177 
10194  json_pointer& operator/=(std::string token)
10195  {
10196  push_back(std::move(token));
10197  return *this;
10198  }
10199 
10216  json_pointer& operator/=(std::size_t array_index)
10217  {
10218  return *this /= std::to_string(array_index);
10219  }
10220 
10237  const json_pointer& rhs)
10238  {
10239  return json_pointer(lhs) /= rhs;
10240  }
10241 
10257  friend json_pointer operator/(const json_pointer& ptr, std::string token)
10258  {
10259  return json_pointer(ptr) /= std::move(token);
10260  }
10261 
10277  friend json_pointer operator/(const json_pointer& ptr, std::size_t array_index)
10278  {
10279  return json_pointer(ptr) /= array_index;
10280  }
10281 
10295  json_pointer parent_pointer() const
10296  {
10297  if (empty())
10298  {
10299  return *this;
10300  }
10301 
10302  json_pointer res = *this;
10303  res.pop_back();
10304  return res;
10305  }
10306 
10320  void pop_back()
10321  {
10322  if (JSON_HEDLEY_UNLIKELY(empty()))
10323  {
10324  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
10325  }
10326 
10327  reference_tokens.pop_back();
10328  }
10329 
10344  const std::string& back() const
10345  {
10346  if (JSON_HEDLEY_UNLIKELY(empty()))
10347  {
10348  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
10349  }
10350 
10351  return reference_tokens.back();
10352  }
10353 
10366  void push_back(const std::string& token)
10367  {
10368  reference_tokens.push_back(token);
10369  }
10370 
10372  void push_back(std::string&& token)
10373  {
10374  reference_tokens.push_back(std::move(token));
10375  }
10376 
10391  bool empty() const noexcept
10392  {
10393  return reference_tokens.empty();
10394  }
10395 
10396  private:
10404  static int array_index(const std::string& s)
10405  {
10406  std::size_t processed_chars = 0;
10407  const int res = std::stoi(s, &processed_chars);
10408 
10409  // check if the string was completely read
10410  if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
10411  {
10412  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
10413  }
10414 
10415  return res;
10416  }
10417 
10418  json_pointer top() const
10419  {
10420  if (JSON_HEDLEY_UNLIKELY(empty()))
10421  {
10422  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
10423  }
10424 
10425  json_pointer result = *this;
10426  result.reference_tokens = {reference_tokens[0]};
10427  return result;
10428  }
10429 
10438  BasicJsonType& get_and_create(BasicJsonType& j) const
10439  {
10440  using size_type = typename BasicJsonType::size_type;
10441  auto result = &j;
10442 
10443  // in case no reference tokens exist, return a reference to the JSON value
10444  // j which will be overwritten by a primitive value
10445  for (const auto& reference_token : reference_tokens)
10446  {
10447  switch (result->type())
10448  {
10449  case detail::value_t::null:
10450  {
10451  if (reference_token == "0")
10452  {
10453  // start a new array if reference token is 0
10454  result = &result->operator[](0);
10455  }
10456  else
10457  {
10458  // start a new object otherwise
10459  result = &result->operator[](reference_token);
10460  }
10461  break;
10462  }
10463 
10464  case detail::value_t::object:
10465  {
10466  // create an entry in the object
10467  result = &result->operator[](reference_token);
10468  break;
10469  }
10470 
10471  case detail::value_t::array:
10472  {
10473  // create an entry in the array
10474  JSON_TRY
10475  {
10476  result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
10477  }
10478  JSON_CATCH(std::invalid_argument&)
10479  {
10480  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
10481  }
10482  break;
10483  }
10484 
10485  /*
10486  The following code is only reached if there exists a reference
10487  token _and_ the current value is primitive. In this case, we have
10488  an error situation, because primitive values may only occur as
10489  single value; that is, with an empty list of reference tokens.
10490  */
10491  default:
10492  JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
10493  }
10494  }
10495 
10496  return *result;
10497  }
10498 
10518  BasicJsonType& get_unchecked(BasicJsonType* ptr) const
10519  {
10520  using size_type = typename BasicJsonType::size_type;
10521  for (const auto& reference_token : reference_tokens)
10522  {
10523  // convert null values to arrays or objects before continuing
10524  if (ptr->is_null())
10525  {
10526  // check if reference token is a number
10527  const bool nums =
10528  std::all_of(reference_token.begin(), reference_token.end(),
10529  [](const unsigned char x)
10530  {
10531  return std::isdigit(x);
10532  });
10533 
10534  // change value to array for numbers or "-" or to object otherwise
10535  *ptr = (nums or reference_token == "-")
10536  ? detail::value_t::array
10537  : detail::value_t::object;
10538  }
10539 
10540  switch (ptr->type())
10541  {
10542  case detail::value_t::object:
10543  {
10544  // use unchecked object access
10545  ptr = &ptr->operator[](reference_token);
10546  break;
10547  }
10548 
10549  case detail::value_t::array:
10550  {
10551  // error condition (cf. RFC 6901, Sect. 4)
10552  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
10553  {
10555  "array index '" + reference_token +
10556  "' must not begin with '0'"));
10557  }
10558 
10559  if (reference_token == "-")
10560  {
10561  // explicitly treat "-" as index beyond the end
10562  ptr = &ptr->operator[](ptr->m_value.array->size());
10563  }
10564  else
10565  {
10566  // convert array index to number; unchecked access
10567  JSON_TRY
10568  {
10569  ptr = &ptr->operator[](
10570  static_cast<size_type>(array_index(reference_token)));
10571  }
10572  JSON_CATCH(std::invalid_argument&)
10573  {
10574  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
10575  }
10576  }
10577  break;
10578  }
10579 
10580  default:
10581  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
10582  }
10583  }
10584 
10585  return *ptr;
10586  }
10587 
10594  BasicJsonType& get_checked(BasicJsonType* ptr) const
10595  {
10596  using size_type = typename BasicJsonType::size_type;
10597  for (const auto& reference_token : reference_tokens)
10598  {
10599  switch (ptr->type())
10600  {
10601  case detail::value_t::object:
10602  {
10603  // note: at performs range check
10604  ptr = &ptr->at(reference_token);
10605  break;
10606  }
10607 
10608  case detail::value_t::array:
10609  {
10610  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
10611  {
10612  // "-" always fails the range check
10614  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
10615  ") is out of range"));
10616  }
10617 
10618  // error condition (cf. RFC 6901, Sect. 4)
10619  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
10620  {
10622  "array index '" + reference_token +
10623  "' must not begin with '0'"));
10624  }
10625 
10626  // note: at performs range check
10627  JSON_TRY
10628  {
10629  ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
10630  }
10631  JSON_CATCH(std::invalid_argument&)
10632  {
10633  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
10634  }
10635  break;
10636  }
10637 
10638  default:
10639  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
10640  }
10641  }
10642 
10643  return *ptr;
10644  }
10645 
10659  const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
10660  {
10661  using size_type = typename BasicJsonType::size_type;
10662  for (const auto& reference_token : reference_tokens)
10663  {
10664  switch (ptr->type())
10665  {
10666  case detail::value_t::object:
10667  {
10668  // use unchecked object access
10669  ptr = &ptr->operator[](reference_token);
10670  break;
10671  }
10672 
10673  case detail::value_t::array:
10674  {
10675  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
10676  {
10677  // "-" cannot be used for const access
10679  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
10680  ") is out of range"));
10681  }
10682 
10683  // error condition (cf. RFC 6901, Sect. 4)
10684  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
10685  {
10687  "array index '" + reference_token +
10688  "' must not begin with '0'"));
10689  }
10690 
10691  // use unchecked array access
10692  JSON_TRY
10693  {
10694  ptr = &ptr->operator[](
10695  static_cast<size_type>(array_index(reference_token)));
10696  }
10697  JSON_CATCH(std::invalid_argument&)
10698  {
10699  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
10700  }
10701  break;
10702  }
10703 
10704  default:
10705  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
10706  }
10707  }
10708 
10709  return *ptr;
10710  }
10711 
10718  const BasicJsonType& get_checked(const BasicJsonType* ptr) const
10719  {
10720  using size_type = typename BasicJsonType::size_type;
10721  for (const auto& reference_token : reference_tokens)
10722  {
10723  switch (ptr->type())
10724  {
10725  case detail::value_t::object:
10726  {
10727  // note: at performs range check
10728  ptr = &ptr->at(reference_token);
10729  break;
10730  }
10731 
10732  case detail::value_t::array:
10733  {
10734  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
10735  {
10736  // "-" always fails the range check
10738  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
10739  ") is out of range"));
10740  }
10741 
10742  // error condition (cf. RFC 6901, Sect. 4)
10743  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
10744  {
10746  "array index '" + reference_token +
10747  "' must not begin with '0'"));
10748  }
10749 
10750  // note: at performs range check
10751  JSON_TRY
10752  {
10753  ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
10754  }
10755  JSON_CATCH(std::invalid_argument&)
10756  {
10757  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
10758  }
10759  break;
10760  }
10761 
10762  default:
10763  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
10764  }
10765  }
10766 
10767  return *ptr;
10768  }
10769 
10774  bool contains(const BasicJsonType* ptr) const
10775  {
10776  using size_type = typename BasicJsonType::size_type;
10777  for (const auto& reference_token : reference_tokens)
10778  {
10779  switch (ptr->type())
10780  {
10781  case detail::value_t::object:
10782  {
10783  if (not ptr->contains(reference_token))
10784  {
10785  // we did not find the key in the object
10786  return false;
10787  }
10788 
10789  ptr = &ptr->operator[](reference_token);
10790  break;
10791  }
10792 
10793  case detail::value_t::array:
10794  {
10795  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
10796  {
10797  // "-" always fails the range check
10798  return false;
10799  }
10800 
10801  // error condition (cf. RFC 6901, Sect. 4)
10802  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
10803  {
10805  "array index '" + reference_token +
10806  "' must not begin with '0'"));
10807  }
10808 
10809  JSON_TRY
10810  {
10811  const auto idx = static_cast<size_type>(array_index(reference_token));
10812  if (idx >= ptr->size())
10813  {
10814  // index out of range
10815  return false;
10816  }
10817 
10818  ptr = &ptr->operator[](idx);
10819  break;
10820  }
10821  JSON_CATCH(std::invalid_argument&)
10822  {
10823  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
10824  }
10825  break;
10826  }
10827 
10828  default:
10829  {
10830  // we do not expect primitive values if there is still a
10831  // reference token to process
10832  return false;
10833  }
10834  }
10835  }
10836 
10837  // no reference token left means we found a primitive value
10838  return true;
10839  }
10840 
10850  static std::vector<std::string> split(const std::string& reference_string)
10851  {
10852  std::vector<std::string> result;
10853 
10854  // special case: empty reference string -> no reference tokens
10855  if (reference_string.empty())
10856  {
10857  return result;
10858  }
10859 
10860  // check if nonempty reference string begins with slash
10861  if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
10862  {
10864  "JSON pointer must be empty or begin with '/' - was: '" +
10865  reference_string + "'"));
10866  }
10867 
10868  // extract the reference tokens:
10869  // - slash: position of the last read slash (or end of string)
10870  // - start: position after the previous slash
10871  for (
10872  // search for the first slash after the first character
10873  std::size_t slash = reference_string.find_first_of('/', 1),
10874  // set the beginning of the first reference token
10875  start = 1;
10876  // we can stop if start == 0 (if slash == std::string::npos)
10877  start != 0;
10878  // set the beginning of the next reference token
10879  // (will eventually be 0 if slash == std::string::npos)
10880  start = (slash == std::string::npos) ? 0 : slash + 1,
10881  // find next slash
10882  slash = reference_string.find_first_of('/', start))
10883  {
10884  // use the text between the beginning of the reference token
10885  // (start) and the last slash (slash).
10886  auto reference_token = reference_string.substr(start, slash - start);
10887 
10888  // check reference tokens are properly escaped
10889  for (std::size_t pos = reference_token.find_first_of('~');
10890  pos != std::string::npos;
10891  pos = reference_token.find_first_of('~', pos + 1))
10892  {
10893  assert(reference_token[pos] == '~');
10894 
10895  // ~ must be followed by 0 or 1
10896  if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
10897  (reference_token[pos + 1] != '0' and
10898  reference_token[pos + 1] != '1')))
10899  {
10900  JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
10901  }
10902  }
10903 
10904  // finally, store the reference token
10905  unescape(reference_token);
10906  result.push_back(reference_token);
10907  }
10908 
10909  return result;
10910  }
10911 
10925  static void replace_substring(std::string& s, const std::string& f,
10926  const std::string& t)
10927  {
10928  assert(not f.empty());
10929  for (auto pos = s.find(f); // find first occurrence of f
10930  pos != std::string::npos; // make sure f was found
10931  s.replace(pos, f.size(), t), // replace with t, and
10932  pos = s.find(f, pos + t.size())) // find next occurrence of f
10933  {}
10934  }
10935 
10937  static std::string escape(std::string s)
10938  {
10939  replace_substring(s, "~", "~0");
10940  replace_substring(s, "/", "~1");
10941  return s;
10942  }
10943 
10945  static void unescape(std::string& s)
10946  {
10947  replace_substring(s, "~1", "/");
10948  replace_substring(s, "~0", "~");
10949  }
10950 
10958  static void flatten(const std::string& reference_string,
10959  const BasicJsonType& value,
10960  BasicJsonType& result)
10961  {
10962  switch (value.type())
10963  {
10964  case detail::value_t::array:
10965  {
10966  if (value.m_value.array->empty())
10967  {
10968  // flatten empty array as null
10969  result[reference_string] = nullptr;
10970  }
10971  else
10972  {
10973  // iterate array and use index as reference string
10974  for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
10975  {
10976  flatten(reference_string + "/" + std::to_string(i),
10977  value.m_value.array->operator[](i), result);
10978  }
10979  }
10980  break;
10981  }
10982 
10983  case detail::value_t::object:
10984  {
10985  if (value.m_value.object->empty())
10986  {
10987  // flatten empty object as null
10988  result[reference_string] = nullptr;
10989  }
10990  else
10991  {
10992  // iterate object and use keys as reference string
10993  for (const auto& element : *value.m_value.object)
10994  {
10995  flatten(reference_string + "/" + escape(element.first), element.second, result);
10996  }
10997  }
10998  break;
10999  }
11000 
11001  default:
11002  {
11003  // add primitive value with its reference string
11004  result[reference_string] = value;
11005  break;
11006  }
11007  }
11008  }
11009 
11020  static BasicJsonType
11021  unflatten(const BasicJsonType& value)
11022  {
11023  if (JSON_HEDLEY_UNLIKELY(not value.is_object()))
11024  {
11025  JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
11026  }
11027 
11028  BasicJsonType result;
11029 
11030  // iterate the JSON object values
11031  for (const auto& element : *value.m_value.object)
11032  {
11033  if (JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
11034  {
11035  JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
11036  }
11037 
11038  // assign value to reference pointed to by JSON pointer; Note that if
11039  // the JSON pointer is "" (i.e., points to the whole value), function
11040  // get_and_create returns a reference to result itself. An assignment
11041  // will then create a primitive value.
11042  json_pointer(element.first).get_and_create(result) = element.second;
11043  }
11044 
11045  return result;
11046  }
11047 
11059  friend bool operator==(json_pointer const& lhs,
11060  json_pointer const& rhs) noexcept
11061  {
11062  return lhs.reference_tokens == rhs.reference_tokens;
11063  }
11064 
11076  friend bool operator!=(json_pointer const& lhs,
11077  json_pointer const& rhs) noexcept
11078  {
11079  return not (lhs == rhs);
11080  }
11081 
11083  std::vector<std::string> reference_tokens;
11084 };
11085 } // namespace nlohmann
11086 
11087 // #include <nlohmann/detail/json_ref.hpp>
11088 
11089 
11090 #include <initializer_list>
11091 #include <utility>
11092 
11093 // #include <nlohmann/detail/meta/type_traits.hpp>
11094 
11095 
11096 namespace nlohmann
11097 {
11098 namespace detail
11099 {
11100 template<typename BasicJsonType>
11102 {
11103  public:
11104  using value_type = BasicJsonType;
11105 
11107  : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
11108  {}
11109 
11111  : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
11112  {}
11113 
11114  json_ref(std::initializer_list<json_ref> init)
11115  : owned_value(init), value_ref(&owned_value), is_rvalue(true)
11116  {}
11117 
11118  template <
11119  class... Args,
11120  enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
11121  json_ref(Args && ... args)
11122  : owned_value(std::forward<Args>(args)...), value_ref(&owned_value),
11123  is_rvalue(true) {}
11124 
11125  // class should be movable only
11126  json_ref(json_ref&&) = default;
11127  json_ref(const json_ref&) = delete;
11128  json_ref& operator=(const json_ref&) = delete;
11129  json_ref& operator=(json_ref&&) = delete;
11130  ~json_ref() = default;
11131 
11132  value_type moved_or_copied() const
11133  {
11134  if (is_rvalue)
11135  {
11136  return std::move(*value_ref);
11137  }
11138  return *value_ref;
11139  }
11140 
11141  value_type const& operator*() const
11142  {
11143  return *static_cast<value_type const*>(value_ref);
11144  }
11145 
11146  value_type const* operator->() const
11147  {
11148  return static_cast<value_type const*>(value_ref);
11149  }
11150 
11151  private:
11152  mutable value_type owned_value = nullptr;
11153  value_type* value_ref = nullptr;
11154  const bool is_rvalue;
11155 };
11156 } // namespace detail
11157 } // namespace nlohmann
11158 
11159 // #include <nlohmann/detail/macro_scope.hpp>
11160 
11161 // #include <nlohmann/detail/meta/cpp_future.hpp>
11162 
11163 // #include <nlohmann/detail/meta/type_traits.hpp>
11164 
11165 // #include <nlohmann/detail/output/binary_writer.hpp>
11166 
11167 
11168 #include <algorithm> // reverse
11169 #include <array> // array
11170 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
11171 #include <cstring> // memcpy
11172 #include <limits> // numeric_limits
11173 #include <string> // string
11174 
11175 // #include <nlohmann/detail/input/binary_reader.hpp>
11176 
11177 // #include <nlohmann/detail/macro_scope.hpp>
11178 
11179 // #include <nlohmann/detail/output/output_adapters.hpp>
11180 
11181 
11182 #include <algorithm> // copy
11183 #include <cstddef> // size_t
11184 #include <ios> // streamsize
11185 #include <iterator> // back_inserter
11186 #include <memory> // shared_ptr, make_shared
11187 #include <ostream> // basic_ostream
11188 #include <string> // basic_string
11189 #include <vector> // vector
11190 // #include <nlohmann/detail/macro_scope.hpp>
11191 
11192 
11193 namespace nlohmann
11194 {
11195 namespace detail
11196 {
11198 template<typename CharType> struct output_adapter_protocol
11199 {
11200  virtual void write_character(CharType c) = 0;
11201  virtual void write_characters(const CharType* s, std::size_t length) = 0;
11202  virtual ~output_adapter_protocol() = default;
11203 };
11204 
11206 template<typename CharType>
11207 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
11208 
11210 template<typename CharType>
11212 {
11213  public:
11214  explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
11215  : v(vec)
11216  {}
11217 
11218  void write_character(CharType c) override
11219  {
11220  v.push_back(c);
11221  }
11222 
11224  void write_characters(const CharType* s, std::size_t length) override
11225  {
11226  std::copy(s, s + length, std::back_inserter(v));
11227  }
11228 
11229  private:
11230  std::vector<CharType>& v;
11231 };
11232 
11234 template<typename CharType>
11236 {
11237  public:
11238  explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
11239  : stream(s)
11240  {}
11241 
11242  void write_character(CharType c) override
11243  {
11244  stream.put(c);
11245  }
11246 
11248  void write_characters(const CharType* s, std::size_t length) override
11249  {
11250  stream.write(s, static_cast<std::streamsize>(length));
11251  }
11252 
11253  private:
11254  std::basic_ostream<CharType>& stream;
11255 };
11256 
11258 template<typename CharType, typename StringType = std::basic_string<CharType>>
11260 {
11261  public:
11262  explicit output_string_adapter(StringType& s) noexcept
11263  : str(s)
11264  {}
11265 
11266  void write_character(CharType c) override
11267  {
11268  str.push_back(c);
11269  }
11270 
11272  void write_characters(const CharType* s, std::size_t length) override
11273  {
11274  str.append(s, length);
11275  }
11276 
11277  private:
11278  StringType& str;
11279 };
11280 
11281 template<typename CharType, typename StringType = std::basic_string<CharType>>
11283 {
11284  public:
11285  output_adapter(std::vector<CharType>& vec)
11286  : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
11287 
11288  output_adapter(std::basic_ostream<CharType>& s)
11289  : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
11290 
11291  output_adapter(StringType& s)
11292  : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
11293 
11295  {
11296  return oa;
11297  }
11298 
11299  private:
11301 };
11302 } // namespace detail
11303 } // namespace nlohmann
11304 
11305 
11306 namespace nlohmann
11307 {
11308 namespace detail
11309 {
11311 // binary writer //
11313 
11317 template<typename BasicJsonType, typename CharType>
11319 {
11320  using string_t = typename BasicJsonType::string_t;
11321 
11322  public:
11328  explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
11329  {
11330  assert(oa);
11331  }
11332 
11337  void write_bson(const BasicJsonType& j)
11338  {
11339  switch (j.type())
11340  {
11341  case value_t::object:
11342  {
11343  write_bson_object(*j.m_value.object);
11344  break;
11345  }
11346 
11347  default:
11348  {
11349  JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
11350  }
11351  }
11352  }
11353 
11357  void write_cbor(const BasicJsonType& j)
11358  {
11359  switch (j.type())
11360  {
11361  case value_t::null:
11362  {
11363  oa->write_character(to_char_type(0xF6));
11364  break;
11365  }
11366 
11367  case value_t::boolean:
11368  {
11369  oa->write_character(j.m_value.boolean
11370  ? to_char_type(0xF5)
11371  : to_char_type(0xF4));
11372  break;
11373  }
11374 
11375  case value_t::number_integer:
11376  {
11377  if (j.m_value.number_integer >= 0)
11378  {
11379  // CBOR does not differentiate between positive signed
11380  // integers and unsigned integers. Therefore, we used the
11381  // code from the value_t::number_unsigned case here.
11382  if (j.m_value.number_integer <= 0x17)
11383  {
11384  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
11385  }
11386  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
11387  {
11388  oa->write_character(to_char_type(0x18));
11389  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
11390  }
11391  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
11392  {
11393  oa->write_character(to_char_type(0x19));
11394  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
11395  }
11396  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
11397  {
11398  oa->write_character(to_char_type(0x1A));
11399  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
11400  }
11401  else
11402  {
11403  oa->write_character(to_char_type(0x1B));
11404  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
11405  }
11406  }
11407  else
11408  {
11409  // The conversions below encode the sign in the first
11410  // byte, and the value is converted to a positive number.
11411  const auto positive_number = -1 - j.m_value.number_integer;
11412  if (j.m_value.number_integer >= -24)
11413  {
11414  write_number(static_cast<std::uint8_t>(0x20 + positive_number));
11415  }
11416  else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
11417  {
11418  oa->write_character(to_char_type(0x38));
11419  write_number(static_cast<std::uint8_t>(positive_number));
11420  }
11421  else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
11422  {
11423  oa->write_character(to_char_type(0x39));
11424  write_number(static_cast<std::uint16_t>(positive_number));
11425  }
11426  else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
11427  {
11428  oa->write_character(to_char_type(0x3A));
11429  write_number(static_cast<std::uint32_t>(positive_number));
11430  }
11431  else
11432  {
11433  oa->write_character(to_char_type(0x3B));
11434  write_number(static_cast<std::uint64_t>(positive_number));
11435  }
11436  }
11437  break;
11438  }
11439 
11440  case value_t::number_unsigned:
11441  {
11442  if (j.m_value.number_unsigned <= 0x17)
11443  {
11444  write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
11445  }
11446  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
11447  {
11448  oa->write_character(to_char_type(0x18));
11449  write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
11450  }
11451  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
11452  {
11453  oa->write_character(to_char_type(0x19));
11454  write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
11455  }
11456  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
11457  {
11458  oa->write_character(to_char_type(0x1A));
11459  write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
11460  }
11461  else
11462  {
11463  oa->write_character(to_char_type(0x1B));
11464  write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
11465  }
11466  break;
11467  }
11468 
11469  case value_t::number_float:
11470  {
11471  oa->write_character(get_cbor_float_prefix(j.m_value.number_float));
11472  write_number(j.m_value.number_float);
11473  break;
11474  }
11475 
11476  case value_t::string:
11477  {
11478  // step 1: write control byte and the string length
11479  const auto N = j.m_value.string->size();
11480  if (N <= 0x17)
11481  {
11482  write_number(static_cast<std::uint8_t>(0x60 + N));
11483  }
11484  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
11485  {
11486  oa->write_character(to_char_type(0x78));
11487  write_number(static_cast<std::uint8_t>(N));
11488  }
11490  {
11491  oa->write_character(to_char_type(0x79));
11492  write_number(static_cast<std::uint16_t>(N));
11493  }
11495  {
11496  oa->write_character(to_char_type(0x7A));
11497  write_number(static_cast<std::uint32_t>(N));
11498  }
11499  // LCOV_EXCL_START
11501  {
11502  oa->write_character(to_char_type(0x7B));
11503  write_number(static_cast<std::uint64_t>(N));
11504  }
11505  // LCOV_EXCL_STOP
11506 
11507  // step 2: write the string
11508  oa->write_characters(
11509  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
11510  j.m_value.string->size());
11511  break;
11512  }
11513 
11514  case value_t::array:
11515  {
11516  // step 1: write control byte and the array size
11517  const auto N = j.m_value.array->size();
11518  if (N <= 0x17)
11519  {
11520  write_number(static_cast<std::uint8_t>(0x80 + N));
11521  }
11522  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
11523  {
11524  oa->write_character(to_char_type(0x98));
11525  write_number(static_cast<std::uint8_t>(N));
11526  }
11528  {
11529  oa->write_character(to_char_type(0x99));
11530  write_number(static_cast<std::uint16_t>(N));
11531  }
11533  {
11534  oa->write_character(to_char_type(0x9A));
11535  write_number(static_cast<std::uint32_t>(N));
11536  }
11537  // LCOV_EXCL_START
11539  {
11540  oa->write_character(to_char_type(0x9B));
11541  write_number(static_cast<std::uint64_t>(N));
11542  }
11543  // LCOV_EXCL_STOP
11544 
11545  // step 2: write each element
11546  for (const auto& el : *j.m_value.array)
11547  {
11548  write_cbor(el);
11549  }
11550  break;
11551  }
11552 
11553  case value_t::object:
11554  {
11555  // step 1: write control byte and the object size
11556  const auto N = j.m_value.object->size();
11557  if (N <= 0x17)
11558  {
11559  write_number(static_cast<std::uint8_t>(0xA0 + N));
11560  }
11561  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
11562  {
11563  oa->write_character(to_char_type(0xB8));
11564  write_number(static_cast<std::uint8_t>(N));
11565  }
11567  {
11568  oa->write_character(to_char_type(0xB9));
11569  write_number(static_cast<std::uint16_t>(N));
11570  }
11572  {
11573  oa->write_character(to_char_type(0xBA));
11574  write_number(static_cast<std::uint32_t>(N));
11575  }
11576  // LCOV_EXCL_START
11578  {
11579  oa->write_character(to_char_type(0xBB));
11580  write_number(static_cast<std::uint64_t>(N));
11581  }
11582  // LCOV_EXCL_STOP
11583 
11584  // step 2: write each element
11585  for (const auto& el : *j.m_value.object)
11586  {
11587  write_cbor(el.first);
11588  write_cbor(el.second);
11589  }
11590  break;
11591  }
11592 
11593  default:
11594  break;
11595  }
11596  }
11597 
11601  void write_msgpack(const BasicJsonType& j)
11602  {
11603  switch (j.type())
11604  {
11605  case value_t::null: // nil
11606  {
11607  oa->write_character(to_char_type(0xC0));
11608  break;
11609  }
11610 
11611  case value_t::boolean: // true and false
11612  {
11613  oa->write_character(j.m_value.boolean
11614  ? to_char_type(0xC3)
11615  : to_char_type(0xC2));
11616  break;
11617  }
11618 
11619  case value_t::number_integer:
11620  {
11621  if (j.m_value.number_integer >= 0)
11622  {
11623  // MessagePack does not differentiate between positive
11624  // signed integers and unsigned integers. Therefore, we used
11625  // the code from the value_t::number_unsigned case here.
11626  if (j.m_value.number_unsigned < 128)
11627  {
11628  // positive fixnum
11629  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
11630  }
11631  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
11632  {
11633  // uint 8
11634  oa->write_character(to_char_type(0xCC));
11635  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
11636  }
11637  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
11638  {
11639  // uint 16
11640  oa->write_character(to_char_type(0xCD));
11641  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
11642  }
11643  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
11644  {
11645  // uint 32
11646  oa->write_character(to_char_type(0xCE));
11647  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
11648  }
11649  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
11650  {
11651  // uint 64
11652  oa->write_character(to_char_type(0xCF));
11653  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
11654  }
11655  }
11656  else
11657  {
11658  if (j.m_value.number_integer >= -32)
11659  {
11660  // negative fixnum
11661  write_number(static_cast<std::int8_t>(j.m_value.number_integer));
11662  }
11663  else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() and
11664  j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
11665  {
11666  // int 8
11667  oa->write_character(to_char_type(0xD0));
11668  write_number(static_cast<std::int8_t>(j.m_value.number_integer));
11669  }
11670  else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() and
11671  j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
11672  {
11673  // int 16
11674  oa->write_character(to_char_type(0xD1));
11675  write_number(static_cast<std::int16_t>(j.m_value.number_integer));
11676  }
11677  else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() and
11678  j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
11679  {
11680  // int 32
11681  oa->write_character(to_char_type(0xD2));
11682  write_number(static_cast<std::int32_t>(j.m_value.number_integer));
11683  }
11684  else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() and
11685  j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
11686  {
11687  // int 64
11688  oa->write_character(to_char_type(0xD3));
11689  write_number(static_cast<std::int64_t>(j.m_value.number_integer));
11690  }
11691  }
11692  break;
11693  }
11694 
11695  case value_t::number_unsigned:
11696  {
11697  if (j.m_value.number_unsigned < 128)
11698  {
11699  // positive fixnum
11700  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
11701  }
11702  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
11703  {
11704  // uint 8
11705  oa->write_character(to_char_type(0xCC));
11706  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
11707  }
11708  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
11709  {
11710  // uint 16
11711  oa->write_character(to_char_type(0xCD));
11712  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
11713  }
11714  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
11715  {
11716  // uint 32
11717  oa->write_character(to_char_type(0xCE));
11718  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
11719  }
11720  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
11721  {
11722  // uint 64
11723  oa->write_character(to_char_type(0xCF));
11724  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
11725  }
11726  break;
11727  }
11728 
11729  case value_t::number_float:
11730  {
11731  oa->write_character(get_msgpack_float_prefix(j.m_value.number_float));
11732  write_number(j.m_value.number_float);
11733  break;
11734  }
11735 
11736  case value_t::string:
11737  {
11738  // step 1: write control byte and the string length
11739  const auto N = j.m_value.string->size();
11740  if (N <= 31)
11741  {
11742  // fixstr
11743  write_number(static_cast<std::uint8_t>(0xA0 | N));
11744  }
11745  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
11746  {
11747  // str 8
11748  oa->write_character(to_char_type(0xD9));
11749  write_number(static_cast<std::uint8_t>(N));
11750  }
11752  {
11753  // str 16
11754  oa->write_character(to_char_type(0xDA));
11755  write_number(static_cast<std::uint16_t>(N));
11756  }
11758  {
11759  // str 32
11760  oa->write_character(to_char_type(0xDB));
11761  write_number(static_cast<std::uint32_t>(N));
11762  }
11763 
11764  // step 2: write the string
11765  oa->write_characters(
11766  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
11767  j.m_value.string->size());
11768  break;
11769  }
11770 
11771  case value_t::array:
11772  {
11773  // step 1: write control byte and the array size
11774  const auto N = j.m_value.array->size();
11775  if (N <= 15)
11776  {
11777  // fixarray
11778  write_number(static_cast<std::uint8_t>(0x90 | N));
11779  }
11781  {
11782  // array 16
11783  oa->write_character(to_char_type(0xDC));
11784  write_number(static_cast<std::uint16_t>(N));
11785  }
11787  {
11788  // array 32
11789  oa->write_character(to_char_type(0xDD));
11790  write_number(static_cast<std::uint32_t>(N));
11791  }
11792 
11793  // step 2: write each element
11794  for (const auto& el : *j.m_value.array)
11795  {
11796  write_msgpack(el);
11797  }
11798  break;
11799  }
11800 
11801  case value_t::object:
11802  {
11803  // step 1: write control byte and the object size
11804  const auto N = j.m_value.object->size();
11805  if (N <= 15)
11806  {
11807  // fixmap
11808  write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
11809  }
11811  {
11812  // map 16
11813  oa->write_character(to_char_type(0xDE));
11814  write_number(static_cast<std::uint16_t>(N));
11815  }
11817  {
11818  // map 32
11819  oa->write_character(to_char_type(0xDF));
11820  write_number(static_cast<std::uint32_t>(N));
11821  }
11822 
11823  // step 2: write each element
11824  for (const auto& el : *j.m_value.object)
11825  {
11826  write_msgpack(el.first);
11827  write_msgpack(el.second);
11828  }
11829  break;
11830  }
11831 
11832  default:
11833  break;
11834  }
11835  }
11836 
11843  void write_ubjson(const BasicJsonType& j, const bool use_count,
11844  const bool use_type, const bool add_prefix = true)
11845  {
11846  switch (j.type())
11847  {
11848  case value_t::null:
11849  {
11850  if (add_prefix)
11851  {
11852  oa->write_character(to_char_type('Z'));
11853  }
11854  break;
11855  }
11856 
11857  case value_t::boolean:
11858  {
11859  if (add_prefix)
11860  {
11861  oa->write_character(j.m_value.boolean
11862  ? to_char_type('T')
11863  : to_char_type('F'));
11864  }
11865  break;
11866  }
11867 
11868  case value_t::number_integer:
11869  {
11870  write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
11871  break;
11872  }
11873 
11874  case value_t::number_unsigned:
11875  {
11876  write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
11877  break;
11878  }
11879 
11880  case value_t::number_float:
11881  {
11882  write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
11883  break;
11884  }
11885 
11886  case value_t::string:
11887  {
11888  if (add_prefix)
11889  {
11890  oa->write_character(to_char_type('S'));
11891  }
11892  write_number_with_ubjson_prefix(j.m_value.string->size(), true);
11893  oa->write_characters(
11894  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
11895  j.m_value.string->size());
11896  break;
11897  }
11898 
11899  case value_t::array:
11900  {
11901  if (add_prefix)
11902  {
11903  oa->write_character(to_char_type('['));
11904  }
11905 
11906  bool prefix_required = true;
11907  if (use_type and not j.m_value.array->empty())
11908  {
11909  assert(use_count);
11910  const CharType first_prefix = ubjson_prefix(j.front());
11911  const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
11912  [this, first_prefix](const BasicJsonType & v)
11913  {
11914  return ubjson_prefix(v) == first_prefix;
11915  });
11916 
11917  if (same_prefix)
11918  {
11919  prefix_required = false;
11920  oa->write_character(to_char_type('$'));
11921  oa->write_character(first_prefix);
11922  }
11923  }
11924 
11925  if (use_count)
11926  {
11927  oa->write_character(to_char_type('#'));
11928  write_number_with_ubjson_prefix(j.m_value.array->size(), true);
11929  }
11930 
11931  for (const auto& el : *j.m_value.array)
11932  {
11933  write_ubjson(el, use_count, use_type, prefix_required);
11934  }
11935 
11936  if (not use_count)
11937  {
11938  oa->write_character(to_char_type(']'));
11939  }
11940 
11941  break;
11942  }
11943 
11944  case value_t::object:
11945  {
11946  if (add_prefix)
11947  {
11948  oa->write_character(to_char_type('{'));
11949  }
11950 
11951  bool prefix_required = true;
11952  if (use_type and not j.m_value.object->empty())
11953  {
11954  assert(use_count);
11955  const CharType first_prefix = ubjson_prefix(j.front());
11956  const bool same_prefix = std::all_of(j.begin(), j.end(),
11957  [this, first_prefix](const BasicJsonType & v)
11958  {
11959  return ubjson_prefix(v) == first_prefix;
11960  });
11961 
11962  if (same_prefix)
11963  {
11964  prefix_required = false;
11965  oa->write_character(to_char_type('$'));
11966  oa->write_character(first_prefix);
11967  }
11968  }
11969 
11970  if (use_count)
11971  {
11972  oa->write_character(to_char_type('#'));
11973  write_number_with_ubjson_prefix(j.m_value.object->size(), true);
11974  }
11975 
11976  for (const auto& el : *j.m_value.object)
11977  {
11978  write_number_with_ubjson_prefix(el.first.size(), true);
11979  oa->write_characters(
11980  reinterpret_cast<const CharType*>(el.first.c_str()),
11981  el.first.size());
11982  write_ubjson(el.second, use_count, use_type, prefix_required);
11983  }
11984 
11985  if (not use_count)
11986  {
11987  oa->write_character(to_char_type('}'));
11988  }
11989 
11990  break;
11991  }
11992 
11993  default:
11994  break;
11995  }
11996  }
11997 
11998  private:
12000  // BSON //
12002 
12007  static std::size_t calc_bson_entry_header_size(const string_t& name)
12008  {
12009  const auto it = name.find(static_cast<typename string_t::value_type>(0));
12010  if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
12011  {
12012  JSON_THROW(out_of_range::create(409,
12013  "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
12014  }
12015 
12016  return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
12017  }
12018 
12022  void write_bson_entry_header(const string_t& name,
12023  const std::uint8_t element_type)
12024  {
12025  oa->write_character(to_char_type(element_type)); // boolean
12026  oa->write_characters(
12027  reinterpret_cast<const CharType*>(name.c_str()),
12028  name.size() + 1u);
12029  }
12030 
12034  void write_bson_boolean(const string_t& name,
12035  const bool value)
12036  {
12037  write_bson_entry_header(name, 0x08);
12038  oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
12039  }
12040 
12044  void write_bson_double(const string_t& name,
12045  const double value)
12046  {
12047  write_bson_entry_header(name, 0x01);
12048  write_number<double, true>(value);
12049  }
12050 
12054  static std::size_t calc_bson_string_size(const string_t& value)
12055  {
12056  return sizeof(std::int32_t) + value.size() + 1ul;
12057  }
12058 
12062  void write_bson_string(const string_t& name,
12063  const string_t& value)
12064  {
12065  write_bson_entry_header(name, 0x02);
12066 
12067  write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
12068  oa->write_characters(
12069  reinterpret_cast<const CharType*>(value.c_str()),
12070  value.size() + 1);
12071  }
12072 
12076  void write_bson_null(const string_t& name)
12077  {
12078  write_bson_entry_header(name, 0x0A);
12079  }
12080 
12084  static std::size_t calc_bson_integer_size(const std::int64_t value)
12085  {
12087  ? sizeof(std::int32_t)
12088  : sizeof(std::int64_t);
12089  }
12090 
12094  void write_bson_integer(const string_t& name,
12095  const std::int64_t value)
12096  {
12098  {
12099  write_bson_entry_header(name, 0x10); // int32
12100  write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
12101  }
12102  else
12103  {
12104  write_bson_entry_header(name, 0x12); // int64
12105  write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
12106  }
12107  }
12108 
12112  static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
12113  {
12114  return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
12115  ? sizeof(std::int32_t)
12116  : sizeof(std::int64_t);
12117  }
12118 
12122  void write_bson_unsigned(const string_t& name,
12123  const std::uint64_t value)
12124  {
12125  if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
12126  {
12127  write_bson_entry_header(name, 0x10 /* int32 */);
12128  write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
12129  }
12130  else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
12131  {
12132  write_bson_entry_header(name, 0x12 /* int64 */);
12133  write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
12134  }
12135  else
12136  {
12137  JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
12138  }
12139  }
12140 
12144  void write_bson_object_entry(const string_t& name,
12145  const typename BasicJsonType::object_t& value)
12146  {
12147  write_bson_entry_header(name, 0x03); // object
12148  write_bson_object(value);
12149  }
12150 
12154  static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
12155  {
12156  std::size_t array_index = 0ul;
12157 
12158  const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), 0ul, [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
12159  {
12160  return result + calc_bson_element_size(std::to_string(array_index++), el);
12161  });
12162 
12163  return sizeof(std::int32_t) + embedded_document_size + 1ul;
12164  }
12165 
12169  void write_bson_array(const string_t& name,
12170  const typename BasicJsonType::array_t& value)
12171  {
12172  write_bson_entry_header(name, 0x04); // array
12173  write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
12174 
12175  std::size_t array_index = 0ul;
12176 
12177  for (const auto& el : value)
12178  {
12179  write_bson_element(std::to_string(array_index++), el);
12180  }
12181 
12182  oa->write_character(to_char_type(0x00));
12183  }
12184 
12189  static std::size_t calc_bson_element_size(const string_t& name,
12190  const BasicJsonType& j)
12191  {
12192  const auto header_size = calc_bson_entry_header_size(name);
12193  switch (j.type())
12194  {
12195  case value_t::object:
12196  return header_size + calc_bson_object_size(*j.m_value.object);
12197 
12198  case value_t::array:
12199  return header_size + calc_bson_array_size(*j.m_value.array);
12200 
12201  case value_t::boolean:
12202  return header_size + 1ul;
12203 
12204  case value_t::number_float:
12205  return header_size + 8ul;
12206 
12207  case value_t::number_integer:
12208  return header_size + calc_bson_integer_size(j.m_value.number_integer);
12209 
12210  case value_t::number_unsigned:
12211  return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
12212 
12213  case value_t::string:
12214  return header_size + calc_bson_string_size(*j.m_value.string);
12215 
12216  case value_t::null:
12217  return header_size + 0ul;
12218 
12219  // LCOV_EXCL_START
12220  default:
12221  assert(false);
12222  return 0ul;
12223  // LCOV_EXCL_STOP
12224  }
12225  }
12226 
12234  void write_bson_element(const string_t& name,
12235  const BasicJsonType& j)
12236  {
12237  switch (j.type())
12238  {
12239  case value_t::object:
12240  return write_bson_object_entry(name, *j.m_value.object);
12241 
12242  case value_t::array:
12243  return write_bson_array(name, *j.m_value.array);
12244 
12245  case value_t::boolean:
12246  return write_bson_boolean(name, j.m_value.boolean);
12247 
12248  case value_t::number_float:
12249  return write_bson_double(name, j.m_value.number_float);
12250 
12251  case value_t::number_integer:
12252  return write_bson_integer(name, j.m_value.number_integer);
12253 
12254  case value_t::number_unsigned:
12255  return write_bson_unsigned(name, j.m_value.number_unsigned);
12256 
12257  case value_t::string:
12258  return write_bson_string(name, *j.m_value.string);
12259 
12260  case value_t::null:
12261  return write_bson_null(name);
12262 
12263  // LCOV_EXCL_START
12264  default:
12265  assert(false);
12266  return;
12267  // LCOV_EXCL_STOP
12268  }
12269  }
12270 
12277  static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
12278  {
12279  std::size_t document_size = std::accumulate(value.begin(), value.end(), 0ul,
12280  [](size_t result, const typename BasicJsonType::object_t::value_type & el)
12281  {
12282  return result += calc_bson_element_size(el.first, el.second);
12283  });
12284 
12285  return sizeof(std::int32_t) + document_size + 1ul;
12286  }
12287 
12292  void write_bson_object(const typename BasicJsonType::object_t& value)
12293  {
12294  write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
12295 
12296  for (const auto& el : value)
12297  {
12298  write_bson_element(el.first, el.second);
12299  }
12300 
12301  oa->write_character(to_char_type(0x00));
12302  }
12303 
12305  // CBOR //
12307 
12308  static constexpr CharType get_cbor_float_prefix(float /*unused*/)
12309  {
12310  return to_char_type(0xFA); // Single-Precision Float
12311  }
12312 
12313  static constexpr CharType get_cbor_float_prefix(double /*unused*/)
12314  {
12315  return to_char_type(0xFB); // Double-Precision Float
12316  }
12317 
12319  // MsgPack //
12321 
12322  static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
12323  {
12324  return to_char_type(0xCA); // float 32
12325  }
12326 
12327  static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
12328  {
12329  return to_char_type(0xCB); // float 64
12330  }
12331 
12333  // UBJSON //
12335 
12336  // UBJSON: write number (floating point)
12337  template<typename NumberType, typename std::enable_if<
12339  void write_number_with_ubjson_prefix(const NumberType n,
12340  const bool add_prefix)
12341  {
12342  if (add_prefix)
12343  {
12344  oa->write_character(get_ubjson_float_prefix(n));
12345  }
12346  write_number(n);
12347  }
12348 
12349  // UBJSON: write number (unsigned integer)
12350  template<typename NumberType, typename std::enable_if<
12351  std::is_unsigned<NumberType>::value, int>::type = 0>
12352  void write_number_with_ubjson_prefix(const NumberType n,
12353  const bool add_prefix)
12354  {
12355  if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
12356  {
12357  if (add_prefix)
12358  {
12359  oa->write_character(to_char_type('i')); // int8
12360  }
12361  write_number(static_cast<std::uint8_t>(n));
12362  }
12363  else if (n <= (std::numeric_limits<std::uint8_t>::max)())
12364  {
12365  if (add_prefix)
12366  {
12367  oa->write_character(to_char_type('U')); // uint8
12368  }
12369  write_number(static_cast<std::uint8_t>(n));
12370  }
12371  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
12372  {
12373  if (add_prefix)
12374  {
12375  oa->write_character(to_char_type('I')); // int16
12376  }
12377  write_number(static_cast<std::int16_t>(n));
12378  }
12379  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
12380  {
12381  if (add_prefix)
12382  {
12383  oa->write_character(to_char_type('l')); // int32
12384  }
12385  write_number(static_cast<std::int32_t>(n));
12386  }
12387  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
12388  {
12389  if (add_prefix)
12390  {
12391  oa->write_character(to_char_type('L')); // int64
12392  }
12393  write_number(static_cast<std::int64_t>(n));
12394  }
12395  else
12396  {
12397  JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
12398  }
12399  }
12400 
12401  // UBJSON: write number (signed integer)
12402  template<typename NumberType, typename std::enable_if<
12404  not std::is_floating_point<NumberType>::value, int>::type = 0>
12405  void write_number_with_ubjson_prefix(const NumberType n,
12406  const bool add_prefix)
12407  {
12409  {
12410  if (add_prefix)
12411  {
12412  oa->write_character(to_char_type('i')); // int8
12413  }
12414  write_number(static_cast<std::int8_t>(n));
12415  }
12416  else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n and n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
12417  {
12418  if (add_prefix)
12419  {
12420  oa->write_character(to_char_type('U')); // uint8
12421  }
12422  write_number(static_cast<std::uint8_t>(n));
12423  }
12425  {
12426  if (add_prefix)
12427  {
12428  oa->write_character(to_char_type('I')); // int16
12429  }
12430  write_number(static_cast<std::int16_t>(n));
12431  }
12433  {
12434  if (add_prefix)
12435  {
12436  oa->write_character(to_char_type('l')); // int32
12437  }
12438  write_number(static_cast<std::int32_t>(n));
12439  }
12441  {
12442  if (add_prefix)
12443  {
12444  oa->write_character(to_char_type('L')); // int64
12445  }
12446  write_number(static_cast<std::int64_t>(n));
12447  }
12448  // LCOV_EXCL_START
12449  else
12450  {
12451  JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
12452  }
12453  // LCOV_EXCL_STOP
12454  }
12455 
12465  CharType ubjson_prefix(const BasicJsonType& j) const noexcept
12466  {
12467  switch (j.type())
12468  {
12469  case value_t::null:
12470  return 'Z';
12471 
12472  case value_t::boolean:
12473  return j.m_value.boolean ? 'T' : 'F';
12474 
12475  case value_t::number_integer:
12476  {
12477  if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
12478  {
12479  return 'i';
12480  }
12481  if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
12482  {
12483  return 'U';
12484  }
12485  if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
12486  {
12487  return 'I';
12488  }
12489  if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
12490  {
12491  return 'l';
12492  }
12493  // no check and assume int64_t (see note above)
12494  return 'L';
12495  }
12496 
12497  case value_t::number_unsigned:
12498  {
12499  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
12500  {
12501  return 'i';
12502  }
12503  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
12504  {
12505  return 'U';
12506  }
12507  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
12508  {
12509  return 'I';
12510  }
12511  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
12512  {
12513  return 'l';
12514  }
12515  // no check and assume int64_t (see note above)
12516  return 'L';
12517  }
12518 
12519  case value_t::number_float:
12520  return get_ubjson_float_prefix(j.m_value.number_float);
12521 
12522  case value_t::string:
12523  return 'S';
12524 
12525  case value_t::array:
12526  return '[';
12527 
12528  case value_t::object:
12529  return '{';
12530 
12531  default: // discarded values
12532  return 'N';
12533  }
12534  }
12535 
12536  static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
12537  {
12538  return 'd'; // float 32
12539  }
12540 
12541  static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
12542  {
12543  return 'D'; // float 64
12544  }
12545 
12547  // Utility functions //
12549 
12550  /*
12551  @brief write a number to output input
12552  @param[in] n number of type @a NumberType
12553  @tparam NumberType the type of the number
12554  @tparam OutputIsLittleEndian Set to true if output data is
12555  required to be little endian
12556 
12557  @note This function needs to respect the system's endianess, because bytes
12558  in CBOR, MessagePack, and UBJSON are stored in network order (big
12559  endian) and therefore need reordering on little endian systems.
12560  */
12561  template<typename NumberType, bool OutputIsLittleEndian = false>
12562  void write_number(const NumberType n)
12563  {
12564  // step 1: write number to array of length NumberType
12565  std::array<CharType, sizeof(NumberType)> vec;
12566  std::memcpy(vec.data(), &n, sizeof(NumberType));
12567 
12568  // step 2: write array to output (with possible reordering)
12569  if (is_little_endian != OutputIsLittleEndian)
12570  {
12571  // reverse byte order prior to conversion if necessary
12572  std::reverse(vec.begin(), vec.end());
12573  }
12574 
12575  oa->write_characters(vec.data(), sizeof(NumberType));
12576  }
12577 
12578  public:
12579  // The following to_char_type functions are implement the conversion
12580  // between uint8_t and CharType. In case CharType is not unsigned,
12581  // such a conversion is required to allow values greater than 128.
12582  // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
12583  template < typename C = CharType,
12585  static constexpr CharType to_char_type(std::uint8_t x) noexcept
12586  {
12587  return *reinterpret_cast<char*>(&x);
12588  }
12589 
12590  template < typename C = CharType,
12592  static CharType to_char_type(std::uint8_t x) noexcept
12593  {
12594  static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
12595  static_assert(std::is_pod<CharType>::value, "CharType must be POD");
12596  CharType result;
12597  std::memcpy(&result, &x, sizeof(x));
12598  return result;
12599  }
12600 
12601  template<typename C = CharType,
12603  static constexpr CharType to_char_type(std::uint8_t x) noexcept
12604  {
12605  return x;
12606  }
12607 
12608  template < typename InputCharType, typename C = CharType,
12609  enable_if_t <
12612  std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
12613  > * = nullptr >
12614  static constexpr CharType to_char_type(InputCharType x) noexcept
12615  {
12616  return x;
12617  }
12618 
12619  private:
12621  const bool is_little_endian = binary_reader<BasicJsonType>::little_endianess();
12622 
12625 };
12626 } // namespace detail
12627 } // namespace nlohmann
12628 
12629 // #include <nlohmann/detail/output/output_adapters.hpp>
12630 
12631 // #include <nlohmann/detail/output/serializer.hpp>
12632 
12633 
12634 #include <algorithm> // reverse, remove, fill, find, none_of
12635 #include <array> // array
12636 #include <cassert> // assert
12637 #include <ciso646> // and, or
12638 #include <clocale> // localeconv, lconv
12639 #include <cmath> // labs, isfinite, isnan, signbit
12640 #include <cstddef> // size_t, ptrdiff_t
12641 #include <cstdint> // uint8_t
12642 #include <cstdio> // snprintf
12643 #include <limits> // numeric_limits
12644 #include <string> // string
12645 #include <type_traits> // is_same
12646 #include <utility> // move
12647 
12648 // #include <nlohmann/detail/conversions/to_chars.hpp>
12649 
12650 
12651 #include <array> // array
12652 #include <cassert> // assert
12653 #include <ciso646> // or, and, not
12654 #include <cmath> // signbit, isfinite
12655 #include <cstdint> // intN_t, uintN_t
12656 #include <cstring> // memcpy, memmove
12657 #include <limits> // numeric_limits
12658 #include <type_traits> // conditional
12659 // #include <nlohmann/detail/macro_scope.hpp>
12660 
12661 
12662 namespace nlohmann
12663 {
12664 namespace detail
12665 {
12666 
12686 namespace dtoa_impl
12687 {
12688 
12689 template <typename Target, typename Source>
12690 Target reinterpret_bits(const Source source)
12691 {
12692  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
12693 
12694  Target target;
12695  std::memcpy(&target, &source, sizeof(Source));
12696  return target;
12697 }
12698 
12699 struct diyfp // f * 2^e
12700 {
12701  static constexpr int kPrecision = 64; // = q
12702 
12703  std::uint64_t f = 0;
12704  int e = 0;
12705 
12706  constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
12707 
12712  static diyfp sub(const diyfp& x, const diyfp& y) noexcept
12713  {
12714  assert(x.e == y.e);
12715  assert(x.f >= y.f);
12716 
12717  return {x.f - y.f, x.e};
12718  }
12719 
12724  static diyfp mul(const diyfp& x, const diyfp& y) noexcept
12725  {
12726  static_assert(kPrecision == 64, "internal error");
12727 
12728  // Computes:
12729  // f = round((x.f * y.f) / 2^q)
12730  // e = x.e + y.e + q
12731 
12732  // Emulate the 64-bit * 64-bit multiplication:
12733  //
12734  // p = u * v
12735  // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
12736  // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
12737  // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
12738  // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
12739  // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
12740  // = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
12741  // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
12742  //
12743  // (Since Q might be larger than 2^32 - 1)
12744  //
12745  // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
12746  //
12747  // (Q_hi + H does not overflow a 64-bit int)
12748  //
12749  // = p_lo + 2^64 p_hi
12750 
12751  const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
12752  const std::uint64_t u_hi = x.f >> 32u;
12753  const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
12754  const std::uint64_t v_hi = y.f >> 32u;
12755 
12756  const std::uint64_t p0 = u_lo * v_lo;
12757  const std::uint64_t p1 = u_lo * v_hi;
12758  const std::uint64_t p2 = u_hi * v_lo;
12759  const std::uint64_t p3 = u_hi * v_hi;
12760 
12761  const std::uint64_t p0_hi = p0 >> 32u;
12762  const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
12763  const std::uint64_t p1_hi = p1 >> 32u;
12764  const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
12765  const std::uint64_t p2_hi = p2 >> 32u;
12766 
12767  std::uint64_t Q = p0_hi + p1_lo + p2_lo;
12768 
12769  // The full product might now be computed as
12770  //
12771  // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
12772  // p_lo = p0_lo + (Q << 32)
12773  //
12774  // But in this particular case here, the full p_lo is not required.
12775  // Effectively we only need to add the highest bit in p_lo to p_hi (and
12776  // Q_hi + 1 does not overflow).
12777 
12778  Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
12779 
12780  const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
12781 
12782  return {h, x.e + y.e + 64};
12783  }
12784 
12789  static diyfp normalize(diyfp x) noexcept
12790  {
12791  assert(x.f != 0);
12792 
12793  while ((x.f >> 63u) == 0)
12794  {
12795  x.f <<= 1u;
12796  x.e--;
12797  }
12798 
12799  return x;
12800  }
12801 
12806  static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
12807  {
12808  const int delta = x.e - target_exponent;
12809 
12810  assert(delta >= 0);
12811  assert(((x.f << delta) >> delta) == x.f);
12812 
12813  return {x.f << delta, target_exponent};
12814  }
12815 };
12816 
12818 {
12822 };
12823 
12830 template <typename FloatType>
12832 {
12833  assert(std::isfinite(value));
12834  assert(value > 0);
12835 
12836  // Convert the IEEE representation into a diyfp.
12837  //
12838  // If v is denormal:
12839  // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
12840  // If v is normalized:
12841  // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
12842 
12843  static_assert(std::numeric_limits<FloatType>::is_iec559,
12844  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
12845 
12846  constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
12847  constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
12848  constexpr int kMinExp = 1 - kBias;
12849  constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
12850 
12851  using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
12852 
12853  const std::uint64_t bits = reinterpret_bits<bits_type>(value);
12854  const std::uint64_t E = bits >> (kPrecision - 1);
12855  const std::uint64_t F = bits & (kHiddenBit - 1);
12856 
12857  const bool is_denormal = E == 0;
12858  const diyfp v = is_denormal
12859  ? diyfp(F, kMinExp)
12860  : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
12861 
12862  // Compute the boundaries m- and m+ of the floating-point value
12863  // v = f * 2^e.
12864  //
12865  // Determine v- and v+, the floating-point predecessor and successor if v,
12866  // respectively.
12867  //
12868  // v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
12869  // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
12870  //
12871  // v+ = v + 2^e
12872  //
12873  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
12874  // between m- and m+ round to v, regardless of how the input rounding
12875  // algorithm breaks ties.
12876  //
12877  // ---+-------------+-------------+-------------+-------------+--- (A)
12878  // v- m- v m+ v+
12879  //
12880  // -----------------+------+------+-------------+-------------+--- (B)
12881  // v- m- v m+ v+
12882 
12883  const bool lower_boundary_is_closer = F == 0 and E > 1;
12884  const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
12885  const diyfp m_minus = lower_boundary_is_closer
12886  ? diyfp(4 * v.f - 1, v.e - 2) // (B)
12887  : diyfp(2 * v.f - 1, v.e - 1); // (A)
12888 
12889  // Determine the normalized w+ = m+.
12890  const diyfp w_plus = diyfp::normalize(m_plus);
12891 
12892  // Determine w- = m- such that e_(w-) = e_(w+).
12893  const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
12894 
12895  return {diyfp::normalize(v), w_minus, w_plus};
12896 }
12897 
12898 // Given normalized diyfp w, Grisu needs to find a (normalized) cached
12899 // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
12900 // within a certain range [alpha, gamma] (Definition 3.2 from [1])
12901 //
12902 // alpha <= e = e_c + e_w + q <= gamma
12903 //
12904 // or
12905 //
12906 // f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
12907 // <= f_c * f_w * 2^gamma
12908 //
12909 // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
12910 //
12911 // 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
12912 //
12913 // or
12914 //
12915 // 2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
12916 //
12917 // The choice of (alpha,gamma) determines the size of the table and the form of
12918 // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
12919 // in practice:
12920 //
12921 // The idea is to cut the number c * w = f * 2^e into two parts, which can be
12922 // processed independently: An integral part p1, and a fractional part p2:
12923 //
12924 // f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
12925 // = (f div 2^-e) + (f mod 2^-e) * 2^e
12926 // = p1 + p2 * 2^e
12927 //
12928 // The conversion of p1 into decimal form requires a series of divisions and
12929 // modulos by (a power of) 10. These operations are faster for 32-bit than for
12930 // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
12931 // achieved by choosing
12932 //
12933 // -e >= 32 or e <= -32 := gamma
12934 //
12935 // In order to convert the fractional part
12936 //
12937 // p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
12938 //
12939 // into decimal form, the fraction is repeatedly multiplied by 10 and the digits
12940 // d[-i] are extracted in order:
12941 //
12942 // (10 * p2) div 2^-e = d[-1]
12943 // (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
12944 //
12945 // The multiplication by 10 must not overflow. It is sufficient to choose
12946 //
12947 // 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
12948 //
12949 // Since p2 = f mod 2^-e < 2^-e,
12950 //
12951 // -e <= 60 or e >= -60 := alpha
12952 
12953 constexpr int kAlpha = -60;
12954 constexpr int kGamma = -32;
12955 
12956 struct cached_power // c = f * 2^e ~= 10^k
12957 {
12958  std::uint64_t f;
12959  int e;
12960  int k;
12961 };
12962 
12971 {
12972  // Now
12973  //
12974  // alpha <= e_c + e + q <= gamma (1)
12975  // ==> f_c * 2^alpha <= c * 2^e * 2^q
12976  //
12977  // and since the c's are normalized, 2^(q-1) <= f_c,
12978  //
12979  // ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
12980  // ==> 2^(alpha - e - 1) <= c
12981  //
12982  // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
12983  //
12984  // k = ceil( log_10( 2^(alpha - e - 1) ) )
12985  // = ceil( (alpha - e - 1) * log_10(2) )
12986  //
12987  // From the paper:
12988  // "In theory the result of the procedure could be wrong since c is rounded,
12989  // and the computation itself is approximated [...]. In practice, however,
12990  // this simple function is sufficient."
12991  //
12992  // For IEEE double precision floating-point numbers converted into
12993  // normalized diyfp's w = f * 2^e, with q = 64,
12994  //
12995  // e >= -1022 (min IEEE exponent)
12996  // -52 (p - 1)
12997  // -52 (p - 1, possibly normalize denormal IEEE numbers)
12998  // -11 (normalize the diyfp)
12999  // = -1137
13000  //
13001  // and
13002  //
13003  // e <= +1023 (max IEEE exponent)
13004  // -52 (p - 1)
13005  // -11 (normalize the diyfp)
13006  // = 960
13007  //
13008  // This binary exponent range [-1137,960] results in a decimal exponent
13009  // range [-307,324]. One does not need to store a cached power for each
13010  // k in this range. For each such k it suffices to find a cached power
13011  // such that the exponent of the product lies in [alpha,gamma].
13012  // This implies that the difference of the decimal exponents of adjacent
13013  // table entries must be less than or equal to
13014  //
13015  // floor( (gamma - alpha) * log_10(2) ) = 8.
13016  //
13017  // (A smaller distance gamma-alpha would require a larger table.)
13018 
13019  // NB:
13020  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
13021 
13022  constexpr int kCachedPowersMinDecExp = -300;
13023  constexpr int kCachedPowersDecStep = 8;
13024 
13025  static constexpr std::array<cached_power, 79> kCachedPowers =
13026  {
13027  {
13028  { 0xAB70FE17C79AC6CA, -1060, -300 },
13029  { 0xFF77B1FCBEBCDC4F, -1034, -292 },
13030  { 0xBE5691EF416BD60C, -1007, -284 },
13031  { 0x8DD01FAD907FFC3C, -980, -276 },
13032  { 0xD3515C2831559A83, -954, -268 },
13033  { 0x9D71AC8FADA6C9B5, -927, -260 },
13034  { 0xEA9C227723EE8BCB, -901, -252 },
13035  { 0xAECC49914078536D, -874, -244 },
13036  { 0x823C12795DB6CE57, -847, -236 },
13037  { 0xC21094364DFB5637, -821, -228 },
13038  { 0x9096EA6F3848984F, -794, -220 },
13039  { 0xD77485CB25823AC7, -768, -212 },
13040  { 0xA086CFCD97BF97F4, -741, -204 },
13041  { 0xEF340A98172AACE5, -715, -196 },
13042  { 0xB23867FB2A35B28E, -688, -188 },
13043  { 0x84C8D4DFD2C63F3B, -661, -180 },
13044  { 0xC5DD44271AD3CDBA, -635, -172 },
13045  { 0x936B9FCEBB25C996, -608, -164 },
13046  { 0xDBAC6C247D62A584, -582, -156 },
13047  { 0xA3AB66580D5FDAF6, -555, -148 },
13048  { 0xF3E2F893DEC3F126, -529, -140 },
13049  { 0xB5B5ADA8AAFF80B8, -502, -132 },
13050  { 0x87625F056C7C4A8B, -475, -124 },
13051  { 0xC9BCFF6034C13053, -449, -116 },
13052  { 0x964E858C91BA2655, -422, -108 },
13053  { 0xDFF9772470297EBD, -396, -100 },
13054  { 0xA6DFBD9FB8E5B88F, -369, -92 },
13055  { 0xF8A95FCF88747D94, -343, -84 },
13056  { 0xB94470938FA89BCF, -316, -76 },
13057  { 0x8A08F0F8BF0F156B, -289, -68 },
13058  { 0xCDB02555653131B6, -263, -60 },
13059  { 0x993FE2C6D07B7FAC, -236, -52 },
13060  { 0xE45C10C42A2B3B06, -210, -44 },
13061  { 0xAA242499697392D3, -183, -36 },
13062  { 0xFD87B5F28300CA0E, -157, -28 },
13063  { 0xBCE5086492111AEB, -130, -20 },
13064  { 0x8CBCCC096F5088CC, -103, -12 },
13065  { 0xD1B71758E219652C, -77, -4 },
13066  { 0x9C40000000000000, -50, 4 },
13067  { 0xE8D4A51000000000, -24, 12 },
13068  { 0xAD78EBC5AC620000, 3, 20 },
13069  { 0x813F3978F8940984, 30, 28 },
13070  { 0xC097CE7BC90715B3, 56, 36 },
13071  { 0x8F7E32CE7BEA5C70, 83, 44 },
13072  { 0xD5D238A4ABE98068, 109, 52 },
13073  { 0x9F4F2726179A2245, 136, 60 },
13074  { 0xED63A231D4C4FB27, 162, 68 },
13075  { 0xB0DE65388CC8ADA8, 189, 76 },
13076  { 0x83C7088E1AAB65DB, 216, 84 },
13077  { 0xC45D1DF942711D9A, 242, 92 },
13078  { 0x924D692CA61BE758, 269, 100 },
13079  { 0xDA01EE641A708DEA, 295, 108 },
13080  { 0xA26DA3999AEF774A, 322, 116 },
13081  { 0xF209787BB47D6B85, 348, 124 },
13082  { 0xB454E4A179DD1877, 375, 132 },
13083  { 0x865B86925B9BC5C2, 402, 140 },
13084  { 0xC83553C5C8965D3D, 428, 148 },
13085  { 0x952AB45CFA97A0B3, 455, 156 },
13086  { 0xDE469FBD99A05FE3, 481, 164 },
13087  { 0xA59BC234DB398C25, 508, 172 },
13088  { 0xF6C69A72A3989F5C, 534, 180 },
13089  { 0xB7DCBF5354E9BECE, 561, 188 },
13090  { 0x88FCF317F22241E2, 588, 196 },
13091  { 0xCC20CE9BD35C78A5, 614, 204 },
13092  { 0x98165AF37B2153DF, 641, 212 },
13093  { 0xE2A0B5DC971F303A, 667, 220 },
13094  { 0xA8D9D1535CE3B396, 694, 228 },
13095  { 0xFB9B7CD9A4A7443C, 720, 236 },
13096  { 0xBB764C4CA7A44410, 747, 244 },
13097  { 0x8BAB8EEFB6409C1A, 774, 252 },
13098  { 0xD01FEF10A657842C, 800, 260 },
13099  { 0x9B10A4E5E9913129, 827, 268 },
13100  { 0xE7109BFBA19C0C9D, 853, 276 },
13101  { 0xAC2820D9623BF429, 880, 284 },
13102  { 0x80444B5E7AA7CF85, 907, 292 },
13103  { 0xBF21E44003ACDD2D, 933, 300 },
13104  { 0x8E679C2F5E44FF8F, 960, 308 },
13105  { 0xD433179D9C8CB841, 986, 316 },
13106  { 0x9E19DB92B4E31BA9, 1013, 324 },
13107  }
13108  };
13109 
13110  // This computation gives exactly the same results for k as
13111  // k = ceil((kAlpha - e - 1) * 0.30102999566398114)
13112  // for |e| <= 1500, but doesn't require floating-point operations.
13113  // NB: log_10(2) ~= 78913 / 2^18
13114  assert(e >= -1500);
13115  assert(e <= 1500);
13116  const int f = kAlpha - e - 1;
13117  const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
13118 
13119  const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
13120  assert(index >= 0);
13121  assert(static_cast<std::size_t>(index) < kCachedPowers.size());
13122 
13123  const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
13124  assert(kAlpha <= cached.e + e + 64);
13125  assert(kGamma >= cached.e + e + 64);
13126 
13127  return cached;
13128 }
13129 
13134 inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
13135 {
13136  // LCOV_EXCL_START
13137  if (n >= 1000000000)
13138  {
13139  pow10 = 1000000000;
13140  return 10;
13141  }
13142  // LCOV_EXCL_STOP
13143  else if (n >= 100000000)
13144  {
13145  pow10 = 100000000;
13146  return 9;
13147  }
13148  else if (n >= 10000000)
13149  {
13150  pow10 = 10000000;
13151  return 8;
13152  }
13153  else if (n >= 1000000)
13154  {
13155  pow10 = 1000000;
13156  return 7;
13157  }
13158  else if (n >= 100000)
13159  {
13160  pow10 = 100000;
13161  return 6;
13162  }
13163  else if (n >= 10000)
13164  {
13165  pow10 = 10000;
13166  return 5;
13167  }
13168  else if (n >= 1000)
13169  {
13170  pow10 = 1000;
13171  return 4;
13172  }
13173  else if (n >= 100)
13174  {
13175  pow10 = 100;
13176  return 3;
13177  }
13178  else if (n >= 10)
13179  {
13180  pow10 = 10;
13181  return 2;
13182  }
13183  else
13184  {
13185  pow10 = 1;
13186  return 1;
13187  }
13188 }
13189 
13190 inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
13191  std::uint64_t rest, std::uint64_t ten_k)
13192 {
13193  assert(len >= 1);
13194  assert(dist <= delta);
13195  assert(rest <= delta);
13196  assert(ten_k > 0);
13197 
13198  // <--------------------------- delta ---->
13199  // <---- dist --------->
13200  // --------------[------------------+-------------------]--------------
13201  // M- w M+
13202  //
13203  // ten_k
13204  // <------>
13205  // <---- rest ---->
13206  // --------------[------------------+----+--------------]--------------
13207  // w V
13208  // = buf * 10^k
13209  //
13210  // ten_k represents a unit-in-the-last-place in the decimal representation
13211  // stored in buf.
13212  // Decrement buf by ten_k while this takes buf closer to w.
13213 
13214  // The tests are written in this order to avoid overflow in unsigned
13215  // integer arithmetic.
13216 
13217  while (rest < dist
13218  and delta - rest >= ten_k
13219  and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))
13220  {
13221  assert(buf[len - 1] != '0');
13222  buf[len - 1]--;
13223  rest += ten_k;
13224  }
13225 }
13226 
13231 inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
13232  diyfp M_minus, diyfp w, diyfp M_plus)
13233 {
13234  static_assert(kAlpha >= -60, "internal error");
13235  static_assert(kGamma <= -32, "internal error");
13236 
13237  // Generates the digits (and the exponent) of a decimal floating-point
13238  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
13239  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
13240  //
13241  // <--------------------------- delta ---->
13242  // <---- dist --------->
13243  // --------------[------------------+-------------------]--------------
13244  // M- w M+
13245  //
13246  // Grisu2 generates the digits of M+ from left to right and stops as soon as
13247  // V is in [M-,M+].
13248 
13249  assert(M_plus.e >= kAlpha);
13250  assert(M_plus.e <= kGamma);
13251 
13252  std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
13253  std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
13254 
13255  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
13256  //
13257  // M+ = f * 2^e
13258  // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
13259  // = ((p1 ) * 2^-e + (p2 )) * 2^e
13260  // = p1 + p2 * 2^e
13261 
13262  const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
13263 
13264  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.)
13265  std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
13266 
13267  // 1)
13268  //
13269  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
13270 
13271  assert(p1 > 0);
13272 
13273  std::uint32_t pow10;
13274  const int k = find_largest_pow10(p1, pow10);
13275 
13276  // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
13277  //
13278  // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
13279  // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
13280  //
13281  // M+ = p1 + p2 * 2^e
13282  // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
13283  // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
13284  // = d[k-1] * 10^(k-1) + ( rest) * 2^e
13285  //
13286  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
13287  //
13288  // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
13289  //
13290  // but stop as soon as
13291  //
13292  // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
13293 
13294  int n = k;
13295  while (n > 0)
13296  {
13297  // Invariants:
13298  // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
13299  // pow10 = 10^(n-1) <= p1 < 10^n
13300  //
13301  const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
13302  const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
13303  //
13304  // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
13305  // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
13306  //
13307  assert(d <= 9);
13308  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
13309  //
13310  // M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
13311  //
13312  p1 = r;
13313  n--;
13314  //
13315  // M+ = buffer * 10^n + (p1 + p2 * 2^e)
13316  // pow10 = 10^n
13317  //
13318 
13319  // Now check if enough digits have been generated.
13320  // Compute
13321  //
13322  // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
13323  //
13324  // Note:
13325  // Since rest and delta share the same exponent e, it suffices to
13326  // compare the significands.
13327  const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
13328  if (rest <= delta)
13329  {
13330  // V = buffer * 10^n, with M- <= V <= M+.
13331 
13332  decimal_exponent += n;
13333 
13334  // We may now just stop. But instead look if the buffer could be
13335  // decremented to bring V closer to w.
13336  //
13337  // pow10 = 10^n is now 1 ulp in the decimal representation V.
13338  // The rounding procedure works with diyfp's with an implicit
13339  // exponent of e.
13340  //
13341  // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
13342  //
13343  const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
13344  grisu2_round(buffer, length, dist, delta, rest, ten_n);
13345 
13346  return;
13347  }
13348 
13349  pow10 /= 10;
13350  //
13351  // pow10 = 10^(n-1) <= p1 < 10^n
13352  // Invariants restored.
13353  }
13354 
13355  // 2)
13356  //
13357  // The digits of the integral part have been generated:
13358  //
13359  // M+ = d[k-1]...d[1]d[0] + p2 * 2^e
13360  // = buffer + p2 * 2^e
13361  //
13362  // Now generate the digits of the fractional part p2 * 2^e.
13363  //
13364  // Note:
13365  // No decimal point is generated: the exponent is adjusted instead.
13366  //
13367  // p2 actually represents the fraction
13368  //
13369  // p2 * 2^e
13370  // = p2 / 2^-e
13371  // = d[-1] / 10^1 + d[-2] / 10^2 + ...
13372  //
13373  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
13374  //
13375  // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
13376  // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
13377  //
13378  // using
13379  //
13380  // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
13381  // = ( d) * 2^-e + ( r)
13382  //
13383  // or
13384  // 10^m * p2 * 2^e = d + r * 2^e
13385  //
13386  // i.e.
13387  //
13388  // M+ = buffer + p2 * 2^e
13389  // = buffer + 10^-m * (d + r * 2^e)
13390  // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
13391  //
13392  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
13393 
13394  assert(p2 > delta);
13395 
13396  int m = 0;
13397  for (;;)
13398  {
13399  // Invariant:
13400  // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
13401  // = buffer * 10^-m + 10^-m * (p2 ) * 2^e
13402  // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
13403  // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
13404  //
13405  assert(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
13406  p2 *= 10;
13407  const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
13408  const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
13409  //
13410  // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
13411  // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
13412  // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
13413  //
13414  assert(d <= 9);
13415  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
13416  //
13417  // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
13418  //
13419  p2 = r;
13420  m++;
13421  //
13422  // M+ = buffer * 10^-m + 10^-m * p2 * 2^e
13423  // Invariant restored.
13424 
13425  // Check if enough digits have been generated.
13426  //
13427  // 10^-m * p2 * 2^e <= delta * 2^e
13428  // p2 * 2^e <= 10^m * delta * 2^e
13429  // p2 <= 10^m * delta
13430  delta *= 10;
13431  dist *= 10;
13432  if (p2 <= delta)
13433  {
13434  break;
13435  }
13436  }
13437 
13438  // V = buffer * 10^-m, with M- <= V <= M+.
13439 
13440  decimal_exponent -= m;
13441 
13442  // 1 ulp in the decimal representation is now 10^-m.
13443  // Since delta and dist are now scaled by 10^m, we need to do the
13444  // same with ulp in order to keep the units in sync.
13445  //
13446  // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
13447  //
13448  const std::uint64_t ten_m = one.f;
13449  grisu2_round(buffer, length, dist, delta, p2, ten_m);
13450 
13451  // By construction this algorithm generates the shortest possible decimal
13452  // number (Loitsch, Theorem 6.2) which rounds back to w.
13453  // For an input number of precision p, at least
13454  //
13455  // N = 1 + ceil(p * log_10(2))
13456  //
13457  // decimal digits are sufficient to identify all binary floating-point
13458  // numbers (Matula, "In-and-Out conversions").
13459  // This implies that the algorithm does not produce more than N decimal
13460  // digits.
13461  //
13462  // N = 17 for p = 53 (IEEE double precision)
13463  // N = 9 for p = 24 (IEEE single precision)
13464 }
13465 
13472 inline void grisu2(char* buf, int& len, int& decimal_exponent,
13473  diyfp m_minus, diyfp v, diyfp m_plus)
13474 {
13475  assert(m_plus.e == m_minus.e);
13476  assert(m_plus.e == v.e);
13477 
13478  // --------(-----------------------+-----------------------)-------- (A)
13479  // m- v m+
13480  //
13481  // --------------------(-----------+-----------------------)-------- (B)
13482  // m- v m+
13483  //
13484  // First scale v (and m- and m+) such that the exponent is in the range
13485  // [alpha, gamma].
13486 
13487  const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
13488 
13489  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
13490 
13491  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
13492  const diyfp w = diyfp::mul(v, c_minus_k);
13493  const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
13494  const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
13495 
13496  // ----(---+---)---------------(---+---)---------------(---+---)----
13497  // w- w w+
13498  // = c*m- = c*v = c*m+
13499  //
13500  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
13501  // w+ are now off by a small amount.
13502  // In fact:
13503  //
13504  // w - v * 10^k < 1 ulp
13505  //
13506  // To account for this inaccuracy, add resp. subtract 1 ulp.
13507  //
13508  // --------+---[---------------(---+---)---------------]---+--------
13509  // w- M- w M+ w+
13510  //
13511  // Now any number in [M-, M+] (bounds included) will round to w when input,
13512  // regardless of how the input rounding algorithm breaks ties.
13513  //
13514  // And digit_gen generates the shortest possible such number in [M-, M+].
13515  // Note that this does not mean that Grisu2 always generates the shortest
13516  // possible number in the interval (m-, m+).
13517  const diyfp M_minus(w_minus.f + 1, w_minus.e);
13518  const diyfp M_plus (w_plus.f - 1, w_plus.e );
13519 
13520  decimal_exponent = -cached.k; // = -(-k) = k
13521 
13522  grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
13523 }
13524 
13530 template <typename FloatType>
13532 void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
13533 {
13534  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
13535  "internal error: not enough precision");
13536 
13537  assert(std::isfinite(value));
13538  assert(value > 0);
13539 
13540  // If the neighbors (and boundaries) of 'value' are always computed for double-precision
13541  // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
13542  // decimal representations are not exactly "short".
13543  //
13544  // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
13545  // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
13546  // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
13547  // does.
13548  // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
13549  // representation using the corresponding std::from_chars function recovers value exactly". That
13550  // indicates that single precision floating-point numbers should be recovered using
13551  // 'std::strtof'.
13552  //
13553  // NB: If the neighbors are computed for single-precision numbers, there is a single float
13554  // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
13555  // value is off by 1 ulp.
13556 #if 0
13557  const boundaries w = compute_boundaries(static_cast<double>(value));
13558 #else
13559  const boundaries w = compute_boundaries(value);
13560 #endif
13561 
13562  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
13563 }
13564 
13572 inline char* append_exponent(char* buf, int e)
13573 {
13574  assert(e > -1000);
13575  assert(e < 1000);
13576 
13577  if (e < 0)
13578  {
13579  e = -e;
13580  *buf++ = '-';
13581  }
13582  else
13583  {
13584  *buf++ = '+';
13585  }
13586 
13587  auto k = static_cast<std::uint32_t>(e);
13588  if (k < 10)
13589  {
13590  // Always print at least two digits in the exponent.
13591  // This is for compatibility with printf("%g").
13592  *buf++ = '0';
13593  *buf++ = static_cast<char>('0' + k);
13594  }
13595  else if (k < 100)
13596  {
13597  *buf++ = static_cast<char>('0' + k / 10);
13598  k %= 10;
13599  *buf++ = static_cast<char>('0' + k);
13600  }
13601  else
13602  {
13603  *buf++ = static_cast<char>('0' + k / 100);
13604  k %= 100;
13605  *buf++ = static_cast<char>('0' + k / 10);
13606  k %= 10;
13607  *buf++ = static_cast<char>('0' + k);
13608  }
13609 
13610  return buf;
13611 }
13612 
13624 inline char* format_buffer(char* buf, int len, int decimal_exponent,
13625  int min_exp, int max_exp)
13626 {
13627  assert(min_exp < 0);
13628  assert(max_exp > 0);
13629 
13630  const int k = len;
13631  const int n = len + decimal_exponent;
13632 
13633  // v = buf * 10^(n-k)
13634  // k is the length of the buffer (number of decimal digits)
13635  // n is the position of the decimal point relative to the start of the buffer.
13636 
13637  if (k <= n and n <= max_exp)
13638  {
13639  // digits[000]
13640  // len <= max_exp + 2
13641 
13642  std::memset(buf + k, '0', static_cast<size_t>(n - k));
13643  // Make it look like a floating-point number (#362, #378)
13644  buf[n + 0] = '.';
13645  buf[n + 1] = '0';
13646  return buf + (n + 2);
13647  }
13648 
13649  if (0 < n and n <= max_exp)
13650  {
13651  // dig.its
13652  // len <= max_digits10 + 1
13653 
13654  assert(k > n);
13655 
13656  std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
13657  buf[n] = '.';
13658  return buf + (k + 1);
13659  }
13660 
13661  if (min_exp < n and n <= 0)
13662  {
13663  // 0.[000]digits
13664  // len <= 2 + (-min_exp - 1) + max_digits10
13665 
13666  std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));
13667  buf[0] = '0';
13668  buf[1] = '.';
13669  std::memset(buf + 2, '0', static_cast<size_t>(-n));
13670  return buf + (2 + (-n) + k);
13671  }
13672 
13673  if (k == 1)
13674  {
13675  // dE+123
13676  // len <= 1 + 5
13677 
13678  buf += 1;
13679  }
13680  else
13681  {
13682  // d.igitsE+123
13683  // len <= max_digits10 + 1 + 5
13684 
13685  std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
13686  buf[1] = '.';
13687  buf += 1 + k;
13688  }
13689 
13690  *buf++ = 'e';
13691  return append_exponent(buf, n - 1);
13692 }
13693 
13694 } // namespace dtoa_impl
13695 
13706 template <typename FloatType>
13709 char* to_chars(char* first, const char* last, FloatType value)
13710 {
13711  static_cast<void>(last); // maybe unused - fix warning
13712  assert(std::isfinite(value));
13713 
13714  // Use signbit(value) instead of (value < 0) since signbit works for -0.
13715  if (std::signbit(value))
13716  {
13717  value = -value;
13718  *first++ = '-';
13719  }
13720 
13721  if (value == 0) // +-0
13722  {
13723  *first++ = '0';
13724  // Make it look like a floating-point number (#362, #378)
13725  *first++ = '.';
13726  *first++ = '0';
13727  return first;
13728  }
13729 
13730  assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
13731 
13732  // Compute v = buffer * 10^decimal_exponent.
13733  // The decimal digits are stored in the buffer, which needs to be interpreted
13734  // as an unsigned decimal integer.
13735  // len is the length of the buffer, i.e. the number of decimal digits.
13736  int len = 0;
13737  int decimal_exponent = 0;
13738  dtoa_impl::grisu2(first, len, decimal_exponent, value);
13739 
13740  assert(len <= std::numeric_limits<FloatType>::max_digits10);
13741 
13742  // Format the buffer like printf("%.*g", prec, value)
13743  constexpr int kMinExp = -4;
13744  // Use digits10 here to increase compatibility with version 2.
13745  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
13746 
13747  assert(last - first >= kMaxExp + 2);
13748  assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
13749  assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
13750 
13751  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
13752 }
13753 
13754 } // namespace detail
13755 } // namespace nlohmann
13756 
13757 // #include <nlohmann/detail/exceptions.hpp>
13758 
13759 // #include <nlohmann/detail/macro_scope.hpp>
13760 
13761 // #include <nlohmann/detail/meta/cpp_future.hpp>
13762 
13763 // #include <nlohmann/detail/output/binary_writer.hpp>
13764 
13765 // #include <nlohmann/detail/output/output_adapters.hpp>
13766 
13767 // #include <nlohmann/detail/value_t.hpp>
13768 
13769 
13770 namespace nlohmann
13771 {
13772 namespace detail
13773 {
13775 // serialization //
13777 
13780 {
13781  strict,
13782  replace,
13783  ignore
13784 };
13785 
13786 template<typename BasicJsonType>
13788 {
13789  using string_t = typename BasicJsonType::string_t;
13790  using number_float_t = typename BasicJsonType::number_float_t;
13791  using number_integer_t = typename BasicJsonType::number_integer_t;
13792  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
13793  static constexpr std::uint8_t UTF8_ACCEPT = 0;
13794  static constexpr std::uint8_t UTF8_REJECT = 1;
13795 
13796  public:
13803  error_handler_t error_handler_ = error_handler_t::strict)
13804  : o(std::move(s))
13805  , loc(std::localeconv())
13806  , thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep))
13807  , decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point))
13808  , indent_char(ichar)
13809  , indent_string(512, indent_char)
13810  , error_handler(error_handler_)
13811  {}
13812 
13813  // delete because of pointer members
13814  serializer(const serializer&) = delete;
13815  serializer& operator=(const serializer&) = delete;
13816  serializer(serializer&&) = delete;
13817  serializer& operator=(serializer&&) = delete;
13818  ~serializer() = default;
13819 
13837  void dump(const BasicJsonType& val, const bool pretty_print,
13838  const bool ensure_ascii,
13839  const unsigned int indent_step,
13840  const unsigned int current_indent = 0)
13841  {
13842  switch (val.m_type)
13843  {
13844  case value_t::object:
13845  {
13846  if (val.m_value.object->empty())
13847  {
13848  o->write_characters("{}", 2);
13849  return;
13850  }
13851 
13852  if (pretty_print)
13853  {
13854  o->write_characters("{\n", 2);
13855 
13856  // variable to hold indentation for recursive calls
13857  const auto new_indent = current_indent + indent_step;
13858  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
13859  {
13860  indent_string.resize(indent_string.size() * 2, ' ');
13861  }
13862 
13863  // first n-1 elements
13864  auto i = val.m_value.object->cbegin();
13865  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
13866  {
13867  o->write_characters(indent_string.c_str(), new_indent);
13868  o->write_character('\"');
13869  dump_escaped(i->first, ensure_ascii);
13870  o->write_characters("\": ", 3);
13871  dump(i->second, true, ensure_ascii, indent_step, new_indent);
13872  o->write_characters(",\n", 2);
13873  }
13874 
13875  // last element
13876  assert(i != val.m_value.object->cend());
13877  assert(std::next(i) == val.m_value.object->cend());
13878  o->write_characters(indent_string.c_str(), new_indent);
13879  o->write_character('\"');
13880  dump_escaped(i->first, ensure_ascii);
13881  o->write_characters("\": ", 3);
13882  dump(i->second, true, ensure_ascii, indent_step, new_indent);
13883 
13884  o->write_character('\n');
13885  o->write_characters(indent_string.c_str(), current_indent);
13886  o->write_character('}');
13887  }
13888  else
13889  {
13890  o->write_character('{');
13891 
13892  // first n-1 elements
13893  auto i = val.m_value.object->cbegin();
13894  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
13895  {
13896  o->write_character('\"');
13897  dump_escaped(i->first, ensure_ascii);
13898  o->write_characters("\":", 2);
13899  dump(i->second, false, ensure_ascii, indent_step, current_indent);
13900  o->write_character(',');
13901  }
13902 
13903  // last element
13904  assert(i != val.m_value.object->cend());
13905  assert(std::next(i) == val.m_value.object->cend());
13906  o->write_character('\"');
13907  dump_escaped(i->first, ensure_ascii);
13908  o->write_characters("\":", 2);
13909  dump(i->second, false, ensure_ascii, indent_step, current_indent);
13910 
13911  o->write_character('}');
13912  }
13913 
13914  return;
13915  }
13916 
13917  case value_t::array:
13918  {
13919  if (val.m_value.array->empty())
13920  {
13921  o->write_characters("[]", 2);
13922  return;
13923  }
13924 
13925  if (pretty_print)
13926  {
13927  o->write_characters("[\n", 2);
13928 
13929  // variable to hold indentation for recursive calls
13930  const auto new_indent = current_indent + indent_step;
13931  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
13932  {
13933  indent_string.resize(indent_string.size() * 2, ' ');
13934  }
13935 
13936  // first n-1 elements
13937  for (auto i = val.m_value.array->cbegin();
13938  i != val.m_value.array->cend() - 1; ++i)
13939  {
13940  o->write_characters(indent_string.c_str(), new_indent);
13941  dump(*i, true, ensure_ascii, indent_step, new_indent);
13942  o->write_characters(",\n", 2);
13943  }
13944 
13945  // last element
13946  assert(not val.m_value.array->empty());
13947  o->write_characters(indent_string.c_str(), new_indent);
13948  dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
13949 
13950  o->write_character('\n');
13951  o->write_characters(indent_string.c_str(), current_indent);
13952  o->write_character(']');
13953  }
13954  else
13955  {
13956  o->write_character('[');
13957 
13958  // first n-1 elements
13959  for (auto i = val.m_value.array->cbegin();
13960  i != val.m_value.array->cend() - 1; ++i)
13961  {
13962  dump(*i, false, ensure_ascii, indent_step, current_indent);
13963  o->write_character(',');
13964  }
13965 
13966  // last element
13967  assert(not val.m_value.array->empty());
13968  dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
13969 
13970  o->write_character(']');
13971  }
13972 
13973  return;
13974  }
13975 
13976  case value_t::string:
13977  {
13978  o->write_character('\"');
13979  dump_escaped(*val.m_value.string, ensure_ascii);
13980  o->write_character('\"');
13981  return;
13982  }
13983 
13984  case value_t::boolean:
13985  {
13986  if (val.m_value.boolean)
13987  {
13988  o->write_characters("true", 4);
13989  }
13990  else
13991  {
13992  o->write_characters("false", 5);
13993  }
13994  return;
13995  }
13996 
13997  case value_t::number_integer:
13998  {
13999  dump_integer(val.m_value.number_integer);
14000  return;
14001  }
14002 
14003  case value_t::number_unsigned:
14004  {
14005  dump_integer(val.m_value.number_unsigned);
14006  return;
14007  }
14008 
14009  case value_t::number_float:
14010  {
14011  dump_float(val.m_value.number_float);
14012  return;
14013  }
14014 
14015  case value_t::discarded:
14016  {
14017  o->write_characters("<discarded>", 11);
14018  return;
14019  }
14020 
14021  case value_t::null:
14022  {
14023  o->write_characters("null", 4);
14024  return;
14025  }
14026 
14027  default: // LCOV_EXCL_LINE
14028  assert(false); // LCOV_EXCL_LINE
14029  }
14030  }
14031 
14032  private:
14047  void dump_escaped(const string_t& s, const bool ensure_ascii)
14048  {
14049  std::uint32_t codepoint;
14050  std::uint8_t state = UTF8_ACCEPT;
14051  std::size_t bytes = 0; // number of bytes written to string_buffer
14052 
14053  // number of bytes written at the point of the last valid byte
14054  std::size_t bytes_after_last_accept = 0;
14055  std::size_t undumped_chars = 0;
14056 
14057  for (std::size_t i = 0; i < s.size(); ++i)
14058  {
14059  const auto byte = static_cast<uint8_t>(s[i]);
14060 
14061  switch (decode(state, codepoint, byte))
14062  {
14063  case UTF8_ACCEPT: // decode found a new code point
14064  {
14065  switch (codepoint)
14066  {
14067  case 0x08: // backspace
14068  {
14069  string_buffer[bytes++] = '\\';
14070  string_buffer[bytes++] = 'b';
14071  break;
14072  }
14073 
14074  case 0x09: // horizontal tab
14075  {
14076  string_buffer[bytes++] = '\\';
14077  string_buffer[bytes++] = 't';
14078  break;
14079  }
14080 
14081  case 0x0A: // newline
14082  {
14083  string_buffer[bytes++] = '\\';
14084  string_buffer[bytes++] = 'n';
14085  break;
14086  }
14087 
14088  case 0x0C: // formfeed
14089  {
14090  string_buffer[bytes++] = '\\';
14091  string_buffer[bytes++] = 'f';
14092  break;
14093  }
14094 
14095  case 0x0D: // carriage return
14096  {
14097  string_buffer[bytes++] = '\\';
14098  string_buffer[bytes++] = 'r';
14099  break;
14100  }
14101 
14102  case 0x22: // quotation mark
14103  {
14104  string_buffer[bytes++] = '\\';
14105  string_buffer[bytes++] = '\"';
14106  break;
14107  }
14108 
14109  case 0x5C: // reverse solidus
14110  {
14111  string_buffer[bytes++] = '\\';
14112  string_buffer[bytes++] = '\\';
14113  break;
14114  }
14115 
14116  default:
14117  {
14118  // escape control characters (0x00..0x1F) or, if
14119  // ensure_ascii parameter is used, non-ASCII characters
14120  if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
14121  {
14122  if (codepoint <= 0xFFFF)
14123  {
14124  (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
14125  static_cast<std::uint16_t>(codepoint));
14126  bytes += 6;
14127  }
14128  else
14129  {
14130  (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
14131  static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
14132  static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
14133  bytes += 12;
14134  }
14135  }
14136  else
14137  {
14138  // copy byte to buffer (all previous bytes
14139  // been copied have in default case above)
14140  string_buffer[bytes++] = s[i];
14141  }
14142  break;
14143  }
14144  }
14145 
14146  // write buffer and reset index; there must be 13 bytes
14147  // left, as this is the maximal number of bytes to be
14148  // written ("\uxxxx\uxxxx\0") for one code point
14149  if (string_buffer.size() - bytes < 13)
14150  {
14151  o->write_characters(string_buffer.data(), bytes);
14152  bytes = 0;
14153  }
14154 
14155  // remember the byte position of this accept
14156  bytes_after_last_accept = bytes;
14157  undumped_chars = 0;
14158  break;
14159  }
14160 
14161  case UTF8_REJECT: // decode found invalid UTF-8 byte
14162  {
14163  switch (error_handler)
14164  {
14165  case error_handler_t::strict:
14166  {
14167  std::string sn(3, '\0');
14168  (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
14169  JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
14170  }
14171 
14172  case error_handler_t::ignore:
14173  case error_handler_t::replace:
14174  {
14175  // in case we saw this character the first time, we
14176  // would like to read it again, because the byte
14177  // may be OK for itself, but just not OK for the
14178  // previous sequence
14179  if (undumped_chars > 0)
14180  {
14181  --i;
14182  }
14183 
14184  // reset length buffer to the last accepted index;
14185  // thus removing/ignoring the invalid characters
14186  bytes = bytes_after_last_accept;
14187 
14188  if (error_handler == error_handler_t::replace)
14189  {
14190  // add a replacement character
14191  if (ensure_ascii)
14192  {
14193  string_buffer[bytes++] = '\\';
14194  string_buffer[bytes++] = 'u';
14195  string_buffer[bytes++] = 'f';
14196  string_buffer[bytes++] = 'f';
14197  string_buffer[bytes++] = 'f';
14198  string_buffer[bytes++] = 'd';
14199  }
14200  else
14201  {
14202  string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
14203  string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
14204  string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
14205  }
14206 
14207  // write buffer and reset index; there must be 13 bytes
14208  // left, as this is the maximal number of bytes to be
14209  // written ("\uxxxx\uxxxx\0") for one code point
14210  if (string_buffer.size() - bytes < 13)
14211  {
14212  o->write_characters(string_buffer.data(), bytes);
14213  bytes = 0;
14214  }
14215 
14216  bytes_after_last_accept = bytes;
14217  }
14218 
14219  undumped_chars = 0;
14220 
14221  // continue processing the string
14222  state = UTF8_ACCEPT;
14223  break;
14224  }
14225 
14226  default: // LCOV_EXCL_LINE
14227  assert(false); // LCOV_EXCL_LINE
14228  }
14229  break;
14230  }
14231 
14232  default: // decode found yet incomplete multi-byte code point
14233  {
14234  if (not ensure_ascii)
14235  {
14236  // code point will not be escaped - copy byte to buffer
14237  string_buffer[bytes++] = s[i];
14238  }
14239  ++undumped_chars;
14240  break;
14241  }
14242  }
14243  }
14244 
14245  // we finished processing the string
14246  if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
14247  {
14248  // write buffer
14249  if (bytes > 0)
14250  {
14251  o->write_characters(string_buffer.data(), bytes);
14252  }
14253  }
14254  else
14255  {
14256  // we finish reading, but do not accept: string was incomplete
14257  switch (error_handler)
14258  {
14259  case error_handler_t::strict:
14260  {
14261  std::string sn(3, '\0');
14262  (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
14263  JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
14264  }
14265 
14266  case error_handler_t::ignore:
14267  {
14268  // write all accepted bytes
14269  o->write_characters(string_buffer.data(), bytes_after_last_accept);
14270  break;
14271  }
14272 
14273  case error_handler_t::replace:
14274  {
14275  // write all accepted bytes
14276  o->write_characters(string_buffer.data(), bytes_after_last_accept);
14277  // add a replacement character
14278  if (ensure_ascii)
14279  {
14280  o->write_characters("\\ufffd", 6);
14281  }
14282  else
14283  {
14284  o->write_characters("\xEF\xBF\xBD", 3);
14285  }
14286  break;
14287  }
14288 
14289  default: // LCOV_EXCL_LINE
14290  assert(false); // LCOV_EXCL_LINE
14291  }
14292  }
14293  }
14294 
14303  inline unsigned int count_digits(number_unsigned_t x) noexcept
14304  {
14305  unsigned int n_digits = 1;
14306  for (;;)
14307  {
14308  if (x < 10)
14309  {
14310  return n_digits;
14311  }
14312  if (x < 100)
14313  {
14314  return n_digits + 1;
14315  }
14316  if (x < 1000)
14317  {
14318  return n_digits + 2;
14319  }
14320  if (x < 10000)
14321  {
14322  return n_digits + 3;
14323  }
14324  x = x / 10000u;
14325  n_digits += 4;
14326  }
14327  }
14328 
14338  template<typename NumberType, detail::enable_if_t<
14341  int> = 0>
14342  void dump_integer(NumberType x)
14343  {
14344  static constexpr std::array<std::array<char, 2>, 100> digits_to_99
14345  {
14346  {
14347  {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
14348  {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
14349  {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
14350  {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
14351  {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
14352  {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
14353  {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
14354  {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
14355  {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
14356  {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
14357  }
14358  };
14359 
14360  // special case for "0"
14361  if (x == 0)
14362  {
14363  o->write_character('0');
14364  return;
14365  }
14366 
14367  // use a pointer to fill the buffer
14368  auto buffer_ptr = number_buffer.begin();
14369 
14370  const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not(x >= 0); // see issue #755
14371  number_unsigned_t abs_value;
14372 
14373  unsigned int n_chars;
14374 
14375  if (is_negative)
14376  {
14377  *buffer_ptr = '-';
14378  abs_value = remove_sign(x);
14379 
14380  // account one more byte for the minus sign
14381  n_chars = 1 + count_digits(abs_value);
14382  }
14383  else
14384  {
14385  abs_value = static_cast<number_unsigned_t>(x);
14386  n_chars = count_digits(abs_value);
14387  }
14388 
14389  // spare 1 byte for '\0'
14390  assert(n_chars < number_buffer.size() - 1);
14391 
14392  // jump to the end to generate the string from backward
14393  // so we later avoid reversing the result
14394  buffer_ptr += n_chars;
14395 
14396  // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
14397  // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
14398  while (abs_value >= 100)
14399  {
14400  const auto digits_index = static_cast<unsigned>((abs_value % 100));
14401  abs_value /= 100;
14402  *(--buffer_ptr) = digits_to_99[digits_index][1];
14403  *(--buffer_ptr) = digits_to_99[digits_index][0];
14404  }
14405 
14406  if (abs_value >= 10)
14407  {
14408  const auto digits_index = static_cast<unsigned>(abs_value);
14409  *(--buffer_ptr) = digits_to_99[digits_index][1];
14410  *(--buffer_ptr) = digits_to_99[digits_index][0];
14411  }
14412  else
14413  {
14414  *(--buffer_ptr) = static_cast<char>('0' + abs_value);
14415  }
14416 
14417  o->write_characters(number_buffer.data(), n_chars);
14418  }
14419 
14428  void dump_float(number_float_t x)
14429  {
14430  // NaN / inf
14431  if (not std::isfinite(x))
14432  {
14433  o->write_characters("null", 4);
14434  return;
14435  }
14436 
14437  // If number_float_t is an IEEE-754 single or double precision number,
14438  // use the Grisu2 algorithm to produce short numbers which are
14439  // guaranteed to round-trip, using strtof and strtod, resp.
14440  //
14441  // NB: The test below works if <long double> == <double>.
14442  static constexpr bool is_ieee_single_or_double
14443  = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
14444  (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
14445 
14446  dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
14447  }
14448 
14449  void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
14450  {
14451  char* begin = number_buffer.data();
14452  char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
14453 
14454  o->write_characters(begin, static_cast<size_t>(end - begin));
14455  }
14456 
14457  void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
14458  {
14459  // get number of digits for a float -> text -> float round-trip
14460  static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
14461 
14462  // the actual conversion
14463  std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
14464 
14465  // negative value indicates an error
14466  assert(len > 0);
14467  // check if buffer was large enough
14468  assert(static_cast<std::size_t>(len) < number_buffer.size());
14469 
14470  // erase thousands separator
14471  if (thousands_sep != '\0')
14472  {
14473  const auto end = std::remove(number_buffer.begin(),
14474  number_buffer.begin() + len, thousands_sep);
14475  std::fill(end, number_buffer.end(), '\0');
14476  assert((end - number_buffer.begin()) <= len);
14477  len = (end - number_buffer.begin());
14478  }
14479 
14480  // convert decimal point to '.'
14481  if (decimal_point != '\0' and decimal_point != '.')
14482  {
14483  const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
14484  if (dec_pos != number_buffer.end())
14485  {
14486  *dec_pos = '.';
14487  }
14488  }
14489 
14490  o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
14491 
14492  // determine if need to append ".0"
14493  const bool value_is_int_like =
14494  std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
14495  [](char c)
14496  {
14497  return c == '.' or c == 'e';
14498  });
14499 
14500  if (value_is_int_like)
14501  {
14502  o->write_characters(".0", 2);
14503  }
14504  }
14505 
14527  static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
14528  {
14529  static const std::array<std::uint8_t, 400> utf8d =
14530  {
14531  {
14532  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
14533  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
14534  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
14535  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
14536  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
14537  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
14538  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
14539  0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
14540  0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
14541  0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
14542  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
14543  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
14544  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
14545  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
14546  }
14547  };
14548 
14549  const std::uint8_t type = utf8d[byte];
14550 
14551  codep = (state != UTF8_ACCEPT)
14552  ? (byte & 0x3fu) | (codep << 6u)
14553  : (0xFFu >> type) & (byte);
14554 
14555  state = utf8d[256u + state * 16u + type];
14556  return state;
14557  }
14558 
14559  /*
14560  * Overload to make the compiler happy while it is instantiating
14561  * dump_integer for number_unsigned_t.
14562  * Must never be called.
14563  */
14565  {
14566  assert(false); // LCOV_EXCL_LINE
14567  return x; // LCOV_EXCL_LINE
14568  }
14569 
14570  /*
14571  * Helper function for dump_integer
14572  *
14573  * This function takes a negative signed integer and returns its absolute
14574  * value as unsigned integer. The plus/minus shuffling is necessary as we can
14575  * not directly remove the sign of an arbitrary signed integer as the
14576  * absolute values of INT_MIN and INT_MAX are usually not the same. See
14577  * #1708 for details.
14578  */
14579  inline number_unsigned_t remove_sign(number_integer_t x) noexcept
14580  {
14581  assert(x < 0 and x < (std::numeric_limits<number_integer_t>::max)());
14582  return static_cast<number_unsigned_t>(-(x + 1)) + 1;
14583  }
14584 
14585  private:
14588 
14590  std::array<char, 64> number_buffer{{}};
14591 
14593  const std::lconv* loc = nullptr;
14595  const char thousands_sep = '\0';
14597  const char decimal_point = '\0';
14598 
14600  std::array<char, 512> string_buffer{{}};
14601 
14603  const char indent_char;
14606 
14609 };
14610 } // namespace detail
14611 } // namespace nlohmann
14612 
14613 // #include <nlohmann/detail/value_t.hpp>
14614 
14615 // #include <nlohmann/json_fwd.hpp>
14616 
14617 
14623 namespace nlohmann
14624 {
14625 
14709 {
14710  private:
14711  template<detail::value_t> friend struct detail::external_constructor;
14712  friend ::nlohmann::json_pointer<basic_json>;
14713  friend ::nlohmann::detail::parser<basic_json>;
14714  friend ::nlohmann::detail::serializer<basic_json>;
14715  template<typename BasicJsonType>
14716  friend class ::nlohmann::detail::iter_impl;
14717  template<typename BasicJsonType, typename CharType>
14718  friend class ::nlohmann::detail::binary_writer;
14719  template<typename BasicJsonType, typename SAX>
14720  friend class ::nlohmann::detail::binary_reader;
14721  template<typename BasicJsonType>
14722  friend class ::nlohmann::detail::json_sax_dom_parser;
14723  template<typename BasicJsonType>
14724  friend class ::nlohmann::detail::json_sax_dom_callback_parser;
14725 
14728 
14729  // convenience aliases for types residing in namespace detail;
14732 
14734  template<typename BasicJsonType>
14736  template<typename BasicJsonType>
14738  template<typename Iterator>
14741 
14742  template<typename CharType>
14744 
14747 
14749 
14750  public:
14754  template<typename T, typename SFINAE>
14755  using json_serializer = JSONSerializer<T, SFINAE>;
14759  using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
14760 
14764 
14766  // exceptions //
14768 
14772 
14785 
14787 
14788 
14790  // container types //
14792 
14797 
14800 
14804  using const_reference = const value_type&;
14805 
14807  using difference_type = std::ptrdiff_t;
14809  using size_type = std::size_t;
14810 
14812  using allocator_type = AllocatorType<basic_json>;
14813 
14815  using pointer = typename std::allocator_traits<allocator_type>::pointer;
14817  using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
14818 
14827 
14829 
14830 
14834  static allocator_type get_allocator()
14835  {
14836  return allocator_type();
14837  }
14838 
14866  static basic_json meta()
14867  {
14868  basic_json result;
14869 
14870  result["copyright"] = "(C) 2013-2017 Niels Lohmann";
14871  result["name"] = "JSON for Modern C++";
14872  result["url"] = "https://github.com/nlohmann/json";
14873  result["version"]["string"] =
14877  result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
14878  result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
14879  result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
14880 
14881 #ifdef _WIN32
14882  result["platform"] = "win32";
14883 #elif defined __linux__
14884  result["platform"] = "linux";
14885 #elif defined __APPLE__
14886  result["platform"] = "apple";
14887 #elif defined __unix__
14888  result["platform"] = "unix";
14889 #else
14890  result["platform"] = "unknown";
14891 #endif
14892 
14893 #if defined(__ICC) || defined(__INTEL_COMPILER)
14894  result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
14895 #elif defined(__clang__)
14896  result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
14897 #elif defined(__GNUC__) || defined(__GNUG__)
14898  result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
14899 #elif defined(__HP_cc) || defined(__HP_aCC)
14900  result["compiler"] = "hp"
14901 #elif defined(__IBMCPP__)
14902  result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
14903 #elif defined(_MSC_VER)
14904  result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
14905 #elif defined(__PGI)
14906  result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
14907 #elif defined(__SUNPRO_CC)
14908  result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
14909 #else
14910  result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
14911 #endif
14912 
14913 #ifdef __cplusplus
14914  result["compiler"]["c++"] = std::to_string(__cplusplus);
14915 #else
14916  result["compiler"]["c++"] = "unknown";
14917 #endif
14918  return result;
14919  }
14920 
14921 
14923  // JSON value data types //
14925 
14930 
14931 #if defined(JSON_HAS_CPP_14)
14932  // Use transparent comparator if possible, combined with perfect forwarding
14933  // on find() and count() calls prevents unnecessary string construction.
14934  using object_comparator_t = std::less<>;
14935 #else
14936  using object_comparator_t = std::less<StringType>;
14937 #endif
14938 
15022  using object_t = ObjectType<StringType,
15023  basic_json,
15025  AllocatorType<std::pair<const StringType,
15027 
15072  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
15073 
15125  using string_t = StringType;
15126 
15151  using boolean_t = BooleanType;
15152 
15223  using number_integer_t = NumberIntegerType;
15224 
15294  using number_unsigned_t = NumberUnsignedType;
15295 
15362  using number_float_t = NumberFloatType;
15363 
15365 
15366  private:
15367 
15369  template<typename T, typename... Args>
15371  static T* create(Args&& ... args)
15372  {
15373  AllocatorType<T> alloc;
15374  using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
15375 
15376  auto deleter = [&](T * object)
15377  {
15378  AllocatorTraits::deallocate(alloc, object, 1);
15379  };
15380  std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
15381  AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
15382  assert(object != nullptr);
15383  return object.release();
15384  }
15385 
15387  // JSON value storage //
15389 
15415  {
15430 
15432  json_value() = default;
15434  json_value(boolean_t v) noexcept : boolean(v) {}
15436  json_value(number_integer_t v) noexcept : number_integer(v) {}
15438  json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
15440  json_value(number_float_t v) noexcept : number_float(v) {}
15443  {
15444  switch (t)
15445  {
15446  case value_t::object:
15447  {
15448  object = create<object_t>();
15449  break;
15450  }
15451 
15452  case value_t::array:
15453  {
15454  array = create<array_t>();
15455  break;
15456  }
15457 
15458  case value_t::string:
15459  {
15460  string = create<string_t>("");
15461  break;
15462  }
15463 
15464  case value_t::boolean:
15465  {
15466  boolean = boolean_t(false);
15467  break;
15468  }
15469 
15470  case value_t::number_integer:
15471  {
15472  number_integer = number_integer_t(0);
15473  break;
15474  }
15475 
15476  case value_t::number_unsigned:
15477  {
15478  number_unsigned = number_unsigned_t(0);
15479  break;
15480  }
15481 
15482  case value_t::number_float:
15483  {
15484  number_float = number_float_t(0.0);
15485  break;
15486  }
15487 
15488  case value_t::null:
15489  {
15490  object = nullptr; // silence warning, see #821
15491  break;
15492  }
15493 
15494  default:
15495  {
15496  object = nullptr; // silence warning, see #821
15497  if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
15498  {
15499  JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.7.3")); // LCOV_EXCL_LINE
15500  }
15501  break;
15502  }
15503  }
15504  }
15505 
15508  {
15509  string = create<string_t>(value);
15510  }
15511 
15514  {
15515  string = create<string_t>(std::move(value));
15516  }
15517 
15520  {
15521  object = create<object_t>(value);
15522  }
15523 
15526  {
15527  object = create<object_t>(std::move(value));
15528  }
15529 
15532  {
15533  array = create<array_t>(value);
15534  }
15535 
15538  {
15539  array = create<array_t>(std::move(value));
15540  }
15541 
15542  void destroy(value_t t) noexcept
15543  {
15544  // flatten the current json_value to a heap-allocated stack
15545  std::vector<basic_json> stack;
15546 
15547  // move the top-level items to stack
15548  if (t == value_t::array)
15549  {
15550  stack.reserve(array->size());
15551  std::move(array->begin(), array->end(), std::back_inserter(stack));
15552  }
15553  else if (t == value_t::object)
15554  {
15555  stack.reserve(object->size());
15556  for (auto&& it : *object)
15557  {
15558  stack.push_back(std::move(it.second));
15559  }
15560  }
15561 
15562  while (not stack.empty())
15563  {
15564  // move the last item to local variable to be processed
15565  basic_json current_item(std::move(stack.back()));
15566  stack.pop_back();
15567 
15568  // if current_item is array/object, move
15569  // its children to the stack to be processed later
15570  if (current_item.is_array())
15571  {
15572  std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
15573  std::back_inserter(stack));
15574 
15575  current_item.m_value.array->clear();
15576  }
15577  else if (current_item.is_object())
15578  {
15579  for (auto&& it : *current_item.m_value.object)
15580  {
15581  stack.push_back(std::move(it.second));
15582  }
15583 
15584  current_item.m_value.object->clear();
15585  }
15586 
15587  // it's now safe that current_item get destructed
15588  // since it doesn't have any children
15589  }
15590 
15591  switch (t)
15592  {
15593  case value_t::object:
15594  {
15595  AllocatorType<object_t> alloc;
15596  std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
15597  std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
15598  break;
15599  }
15600 
15601  case value_t::array:
15602  {
15603  AllocatorType<array_t> alloc;
15604  std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
15605  std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
15606  break;
15607  }
15608 
15609  case value_t::string:
15610  {
15611  AllocatorType<string_t> alloc;
15612  std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
15613  std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
15614  break;
15615  }
15616 
15617  default:
15618  {
15619  break;
15620  }
15621  }
15622  }
15623  };
15624 
15634  void assert_invariant() const noexcept
15635  {
15636  assert(m_type != value_t::object or m_value.object != nullptr);
15637  assert(m_type != value_t::array or m_value.array != nullptr);
15638  assert(m_type != value_t::string or m_value.string != nullptr);
15639  }
15640 
15641  public:
15643  // JSON parser callback //
15645 
15662 
15713 
15715  // constructors //
15717 
15722 
15753  : m_type(v), m_value(v)
15754  {
15755  assert_invariant();
15756  }
15757 
15776  basic_json(std::nullptr_t = nullptr) noexcept
15777  : basic_json(value_t::null)
15778  {
15779  assert_invariant();
15780  }
15781 
15839  template <typename CompatibleType,
15840  typename U = detail::uncvref_t<CompatibleType>,
15843  basic_json(CompatibleType && val) noexcept(noexcept(
15844  JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
15845  std::forward<CompatibleType>(val))))
15846  {
15847  JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
15848  assert_invariant();
15849  }
15850 
15877  template <typename BasicJsonType,
15880  basic_json(const BasicJsonType& val)
15881  {
15882  using other_boolean_t = typename BasicJsonType::boolean_t;
15883  using other_number_float_t = typename BasicJsonType::number_float_t;
15884  using other_number_integer_t = typename BasicJsonType::number_integer_t;
15885  using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
15886  using other_string_t = typename BasicJsonType::string_t;
15887  using other_object_t = typename BasicJsonType::object_t;
15888  using other_array_t = typename BasicJsonType::array_t;
15889 
15890  switch (val.type())
15891  {
15892  case value_t::boolean:
15893  JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
15894  break;
15895  case value_t::number_float:
15896  JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
15897  break;
15898  case value_t::number_integer:
15899  JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
15900  break;
15901  case value_t::number_unsigned:
15902  JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
15903  break;
15904  case value_t::string:
15905  JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
15906  break;
15907  case value_t::object:
15908  JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
15909  break;
15910  case value_t::array:
15911  JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
15912  break;
15913  case value_t::null:
15914  *this = nullptr;
15915  break;
15916  case value_t::discarded:
15917  m_type = value_t::discarded;
15918  break;
15919  default: // LCOV_EXCL_LINE
15920  assert(false); // LCOV_EXCL_LINE
15921  }
15922  assert_invariant();
15923  }
15924 
16000  bool type_deduction = true,
16001  value_t manual_type = value_t::array)
16002  {
16003  // check if each element is an array with two elements whose first
16004  // element is a string
16005  bool is_an_object = std::all_of(init.begin(), init.end(),
16006  [](const detail::json_ref<basic_json>& element_ref)
16007  {
16008  return element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string();
16009  });
16010 
16011  // adjust type if type deduction is not wanted
16012  if (not type_deduction)
16013  {
16014  // if array is wanted, do not create an object though possible
16015  if (manual_type == value_t::array)
16016  {
16017  is_an_object = false;
16018  }
16019 
16020  // if object is wanted but impossible, throw an exception
16021  if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object and not is_an_object))
16022  {
16023  JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
16024  }
16025  }
16026 
16027  if (is_an_object)
16028  {
16029  // the initializer list is a list of pairs -> create object
16030  m_type = value_t::object;
16031  m_value = value_t::object;
16032 
16033  std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
16034  {
16035  auto element = element_ref.moved_or_copied();
16036  m_value.object->emplace(
16037  std::move(*((*element.m_value.array)[0].m_value.string)),
16038  std::move((*element.m_value.array)[1]));
16039  });
16040  }
16041  else
16042  {
16043  // the initializer list describes an array -> create array
16044  m_type = value_t::array;
16045  m_value.array = create<array_t>(init.begin(), init.end());
16046  }
16047 
16048  assert_invariant();
16049  }
16050 
16090  {
16091  return basic_json(init, false, value_t::array);
16092  }
16093 
16133  static basic_json object(initializer_list_t init = {})
16134  {
16135  return basic_json(init, false, value_t::object);
16136  }
16137 
16161  : m_type(value_t::array)
16162  {
16163  m_value.array = create<array_t>(cnt, val);
16164  assert_invariant();
16165  }
16166 
16222  template<class InputIT, typename std::enable_if<
16225  basic_json(InputIT first, InputIT last)
16226  {
16227  assert(first.m_object != nullptr);
16228  assert(last.m_object != nullptr);
16229 
16230  // make sure iterator fits the current value
16231  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
16232  {
16233  JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
16234  }
16235 
16236  // copy type from first iterator
16237  m_type = first.m_object->m_type;
16238 
16239  // check if iterator range is complete for primitive values
16240  switch (m_type)
16241  {
16242  case value_t::boolean:
16243  case value_t::number_float:
16244  case value_t::number_integer:
16245  case value_t::number_unsigned:
16246  case value_t::string:
16247  {
16248  if (JSON_HEDLEY_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
16249  or not last.m_it.primitive_iterator.is_end()))
16250  {
16251  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
16252  }
16253  break;
16254  }
16255 
16256  default:
16257  break;
16258  }
16259 
16260  switch (m_type)
16261  {
16262  case value_t::number_integer:
16263  {
16264  m_value.number_integer = first.m_object->m_value.number_integer;
16265  break;
16266  }
16267 
16268  case value_t::number_unsigned:
16269  {
16270  m_value.number_unsigned = first.m_object->m_value.number_unsigned;
16271  break;
16272  }
16273 
16274  case value_t::number_float:
16275  {
16276  m_value.number_float = first.m_object->m_value.number_float;
16277  break;
16278  }
16279 
16280  case value_t::boolean:
16281  {
16282  m_value.boolean = first.m_object->m_value.boolean;
16283  break;
16284  }
16285 
16286  case value_t::string:
16287  {
16288  m_value = *first.m_object->m_value.string;
16289  break;
16290  }
16291 
16292  case value_t::object:
16293  {
16294  m_value.object = create<object_t>(first.m_it.object_iterator,
16295  last.m_it.object_iterator);
16296  break;
16297  }
16298 
16299  case value_t::array:
16300  {
16301  m_value.array = create<array_t>(first.m_it.array_iterator,
16302  last.m_it.array_iterator);
16303  break;
16304  }
16305 
16306  default:
16307  JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
16308  std::string(first.m_object->type_name())));
16309  }
16310 
16311  assert_invariant();
16312  }
16313 
16314 
16316  // other constructors and destructor //
16318 
16321  : basic_json(ref.moved_or_copied())
16322  {}
16323 
16349  basic_json(const basic_json& other)
16350  : m_type(other.m_type)
16351  {
16352  // check of passed value is valid
16353  other.assert_invariant();
16354 
16355  switch (m_type)
16356  {
16357  case value_t::object:
16358  {
16359  m_value = *other.m_value.object;
16360  break;
16361  }
16362 
16363  case value_t::array:
16364  {
16365  m_value = *other.m_value.array;
16366  break;
16367  }
16368 
16369  case value_t::string:
16370  {
16371  m_value = *other.m_value.string;
16372  break;
16373  }
16374 
16375  case value_t::boolean:
16376  {
16377  m_value = other.m_value.boolean;
16378  break;
16379  }
16380 
16381  case value_t::number_integer:
16382  {
16383  m_value = other.m_value.number_integer;
16384  break;
16385  }
16386 
16387  case value_t::number_unsigned:
16388  {
16389  m_value = other.m_value.number_unsigned;
16390  break;
16391  }
16392 
16393  case value_t::number_float:
16394  {
16395  m_value = other.m_value.number_float;
16396  break;
16397  }
16398 
16399  default:
16400  break;
16401  }
16402 
16403  assert_invariant();
16404  }
16405 
16432  basic_json(basic_json&& other) noexcept
16433  : m_type(std::move(other.m_type)),
16434  m_value(std::move(other.m_value))
16435  {
16436  // check that passed value is valid
16437  other.assert_invariant();
16438 
16439  // invalidate payload
16440  other.m_type = value_t::null;
16441  other.m_value = {};
16442 
16443  assert_invariant();
16444  }
16445 
16469  basic_json& operator=(basic_json other) noexcept (
16474  )
16475  {
16476  // check that passed value is valid
16477  other.assert_invariant();
16478 
16479  using std::swap;
16480  swap(m_type, other.m_type);
16481  swap(m_value, other.m_value);
16482 
16483  assert_invariant();
16484  return *this;
16485  }
16486 
16502  ~basic_json() noexcept
16503  {
16504  assert_invariant();
16505  m_value.destroy(m_type);
16506  }
16507 
16509 
16510  public:
16512  // object inspection //
16514 
16518 
16560  string_t dump(const int indent = -1,
16561  const char indent_char = ' ',
16562  const bool ensure_ascii = false,
16563  const error_handler_t error_handler = error_handler_t::strict) const
16564  {
16565  string_t result;
16566  serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
16567 
16568  if (indent >= 0)
16569  {
16570  s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
16571  }
16572  else
16573  {
16574  s.dump(*this, false, ensure_ascii, 0);
16575  }
16576 
16577  return result;
16578  }
16579 
16612  constexpr value_t type() const noexcept
16613  {
16614  return m_type;
16615  }
16616 
16642  constexpr bool is_primitive() const noexcept
16643  {
16644  return is_null() or is_string() or is_boolean() or is_number();
16645  }
16646 
16669  constexpr bool is_structured() const noexcept
16670  {
16671  return is_array() or is_object();
16672  }
16673 
16691  constexpr bool is_null() const noexcept
16692  {
16693  return m_type == value_t::null;
16694  }
16695 
16713  constexpr bool is_boolean() const noexcept
16714  {
16715  return m_type == value_t::boolean;
16716  }
16717 
16743  constexpr bool is_number() const noexcept
16744  {
16745  return is_number_integer() or is_number_float();
16746  }
16747 
16772  constexpr bool is_number_integer() const noexcept
16773  {
16774  return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
16775  }
16776 
16800  constexpr bool is_number_unsigned() const noexcept
16801  {
16802  return m_type == value_t::number_unsigned;
16803  }
16804 
16828  constexpr bool is_number_float() const noexcept
16829  {
16830  return m_type == value_t::number_float;
16831  }
16832 
16850  constexpr bool is_object() const noexcept
16851  {
16852  return m_type == value_t::object;
16853  }
16854 
16872  constexpr bool is_array() const noexcept
16873  {
16874  return m_type == value_t::array;
16875  }
16876 
16894  constexpr bool is_string() const noexcept
16895  {
16896  return m_type == value_t::string;
16897  }
16898 
16921  constexpr bool is_discarded() const noexcept
16922  {
16923  return m_type == value_t::discarded;
16924  }
16925 
16947  constexpr operator value_t() const noexcept
16948  {
16949  return m_type;
16950  }
16951 
16953 
16954  private:
16956  // value access //
16958 
16960  boolean_t get_impl(boolean_t* /*unused*/) const
16961  {
16962  if (JSON_HEDLEY_LIKELY(is_boolean()))
16963  {
16964  return m_value.boolean;
16965  }
16966 
16967  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
16968  }
16969 
16971  object_t* get_impl_ptr(object_t* /*unused*/) noexcept
16972  {
16973  return is_object() ? m_value.object : nullptr;
16974  }
16975 
16977  constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
16978  {
16979  return is_object() ? m_value.object : nullptr;
16980  }
16981 
16983  array_t* get_impl_ptr(array_t* /*unused*/) noexcept
16984  {
16985  return is_array() ? m_value.array : nullptr;
16986  }
16987 
16989  constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
16990  {
16991  return is_array() ? m_value.array : nullptr;
16992  }
16993 
16995  string_t* get_impl_ptr(string_t* /*unused*/) noexcept
16996  {
16997  return is_string() ? m_value.string : nullptr;
16998  }
16999 
17001  constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
17002  {
17003  return is_string() ? m_value.string : nullptr;
17004  }
17005 
17007  boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
17008  {
17009  return is_boolean() ? &m_value.boolean : nullptr;
17010  }
17011 
17013  constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
17014  {
17015  return is_boolean() ? &m_value.boolean : nullptr;
17016  }
17017 
17019  number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
17020  {
17021  return is_number_integer() ? &m_value.number_integer : nullptr;
17022  }
17023 
17025  constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
17026  {
17027  return is_number_integer() ? &m_value.number_integer : nullptr;
17028  }
17029 
17031  number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
17032  {
17033  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
17034  }
17035 
17037  constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
17038  {
17039  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
17040  }
17041 
17043  number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
17044  {
17045  return is_number_float() ? &m_value.number_float : nullptr;
17046  }
17047 
17049  constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
17050  {
17051  return is_number_float() ? &m_value.number_float : nullptr;
17052  }
17053 
17065  template<typename ReferenceType, typename ThisType>
17066  static ReferenceType get_ref_impl(ThisType& obj)
17067  {
17068  // delegate the call to get_ptr<>()
17069  auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
17070 
17071  if (JSON_HEDLEY_LIKELY(ptr != nullptr))
17072  {
17073  return *ptr;
17074  }
17075 
17076  JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
17077  }
17078 
17079  public:
17083 
17098  template<typename BasicJsonType, detail::enable_if_t<
17099  std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
17100  int> = 0>
17101  basic_json get() const
17102  {
17103  return *this;
17104  }
17105 
17121  template<typename BasicJsonType, detail::enable_if_t<
17124  BasicJsonType get() const
17125  {
17126  return *this;
17127  }
17128 
17168  template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
17169  detail::enable_if_t <
17170  not detail::is_basic_json<ValueType>::value and
17171  detail::has_from_json<basic_json_t, ValueType>::value and
17172  not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
17173  int> = 0>
17174  ValueType get() const noexcept(noexcept(
17175  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
17176  {
17177  // we cannot static_assert on ValueTypeCV being non-const, because
17178  // there is support for get<const basic_json_t>(), which is why we
17179  // still need the uncvref
17180  static_assert(not std::is_reference<ValueTypeCV>::value,
17181  "get() cannot be used with reference types, you might want to use get_ref()");
17183  "types must be DefaultConstructible when used with get()");
17184 
17185  ValueType ret;
17187  return ret;
17188  }
17189 
17221  template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
17222  detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
17223  detail::has_non_default_from_json<basic_json_t, ValueType>::value,
17224  int> = 0>
17225  ValueType get() const noexcept(noexcept(
17226  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
17227  {
17228  static_assert(not std::is_reference<ValueTypeCV>::value,
17229  "get() cannot be used with reference types, you might want to use get_ref()");
17231  }
17232 
17266  template<typename ValueType,
17270  int> = 0>
17271  ValueType & get_to(ValueType& v) const noexcept(noexcept(
17272  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
17273  {
17275  return v;
17276  }
17277 
17278  template <
17279  typename T, std::size_t N,
17280  typename Array = T (&)[N],
17283  Array get_to(T (&v)[N]) const
17284  noexcept(noexcept(JSONSerializer<Array>::from_json(
17285  std::declval<const basic_json_t&>(), v)))
17286  {
17288  return v;
17289  }
17290 
17291 
17318  template<typename PointerType, typename std::enable_if<
17319  std::is_pointer<PointerType>::value, int>::type = 0>
17320  auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
17321  {
17322  // delegate the call to get_impl_ptr<>()
17323  return get_impl_ptr(static_cast<PointerType>(nullptr));
17324  }
17325 
17330  template<typename PointerType, typename std::enable_if<
17332  std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
17333  constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
17334  {
17335  // delegate the call to get_impl_ptr<>() const
17336  return get_impl_ptr(static_cast<PointerType>(nullptr));
17337  }
17338 
17366  template<typename PointerType, typename std::enable_if<
17367  std::is_pointer<PointerType>::value, int>::type = 0>
17368  auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
17369  {
17370  // delegate the call to get_ptr
17371  return get_ptr<PointerType>();
17372  }
17373 
17378  template<typename PointerType, typename std::enable_if<
17379  std::is_pointer<PointerType>::value, int>::type = 0>
17380  constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
17381  {
17382  // delegate the call to get_ptr
17383  return get_ptr<PointerType>();
17384  }
17385 
17412  template<typename ReferenceType, typename std::enable_if<
17414  ReferenceType get_ref()
17415  {
17416  // delegate call to get_ref_impl
17417  return get_ref_impl<ReferenceType>(*this);
17418  }
17419 
17424  template<typename ReferenceType, typename std::enable_if<
17426  std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
17427  ReferenceType get_ref() const
17428  {
17429  // delegate call to get_ref_impl
17430  return get_ref_impl<ReferenceType>(*this);
17431  }
17432 
17462  template < typename ValueType, typename std::enable_if <
17464  not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
17467 
17468 #ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015
17469  and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
17470 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) and _MSC_VER <= 1914))
17472 #endif
17473 #endif
17475  , int >::type = 0 >
17476  operator ValueType() const
17477  {
17478  // delegate the call to get<>() const
17479  return get<ValueType>();
17480  }
17481 
17483 
17484 
17486  // element access //
17488 
17492 
17520  {
17521  // at only works for arrays
17522  if (JSON_HEDLEY_LIKELY(is_array()))
17523  {
17524  JSON_TRY
17525  {
17526  return m_value.array->at(idx);
17527  }
17528  JSON_CATCH (std::out_of_range&)
17529  {
17530  // create better exception explanation
17531  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
17532  }
17533  }
17534  else
17535  {
17536  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
17537  }
17538  }
17539 
17567  {
17568  // at only works for arrays
17569  if (JSON_HEDLEY_LIKELY(is_array()))
17570  {
17571  JSON_TRY
17572  {
17573  return m_value.array->at(idx);
17574  }
17575  JSON_CATCH (std::out_of_range&)
17576  {
17577  // create better exception explanation
17578  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
17579  }
17580  }
17581  else
17582  {
17583  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
17584  }
17585  }
17586 
17617  reference at(const typename object_t::key_type& key)
17618  {
17619  // at only works for objects
17620  if (JSON_HEDLEY_LIKELY(is_object()))
17621  {
17622  JSON_TRY
17623  {
17624  return m_value.object->at(key);
17625  }
17626  JSON_CATCH (std::out_of_range&)
17627  {
17628  // create better exception explanation
17629  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
17630  }
17631  }
17632  else
17633  {
17634  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
17635  }
17636  }
17637 
17668  const_reference at(const typename object_t::key_type& key) const
17669  {
17670  // at only works for objects
17671  if (JSON_HEDLEY_LIKELY(is_object()))
17672  {
17673  JSON_TRY
17674  {
17675  return m_value.object->at(key);
17676  }
17677  JSON_CATCH (std::out_of_range&)
17678  {
17679  // create better exception explanation
17680  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
17681  }
17682  }
17683  else
17684  {
17685  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
17686  }
17687  }
17688 
17715  {
17716  // implicitly convert null value to an empty array
17717  if (is_null())
17718  {
17719  m_type = value_t::array;
17720  m_value.array = create<array_t>();
17721  assert_invariant();
17722  }
17723 
17724  // operator[] only works for arrays
17725  if (JSON_HEDLEY_LIKELY(is_array()))
17726  {
17727  // fill up array with null values if given idx is outside range
17728  if (idx >= m_value.array->size())
17729  {
17730  m_value.array->insert(m_value.array->end(),
17731  idx - m_value.array->size() + 1,
17732  basic_json());
17733  }
17734 
17735  return m_value.array->operator[](idx);
17736  }
17737 
17738  JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
17739  }
17740 
17760  const_reference operator[](size_type idx) const
17761  {
17762  // const operator[] only works for arrays
17763  if (JSON_HEDLEY_LIKELY(is_array()))
17764  {
17765  return m_value.array->operator[](idx);
17766  }
17767 
17768  JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
17769  }
17770 
17798  reference operator[](const typename object_t::key_type& key)
17799  {
17800  // implicitly convert null value to an empty object
17801  if (is_null())
17802  {
17803  m_type = value_t::object;
17804  m_value.object = create<object_t>();
17805  assert_invariant();
17806  }
17807 
17808  // operator[] only works for objects
17809  if (JSON_HEDLEY_LIKELY(is_object()))
17810  {
17811  return m_value.object->operator[](key);
17812  }
17813 
17814  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
17815  }
17816 
17847  const_reference operator[](const typename object_t::key_type& key) const
17848  {
17849  // const operator[] only works for objects
17850  if (JSON_HEDLEY_LIKELY(is_object()))
17851  {
17852  assert(m_value.object->find(key) != m_value.object->end());
17853  return m_value.object->find(key)->second;
17854  }
17855 
17856  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
17857  }
17858 
17886  template<typename T>
17888  reference operator[](T* key)
17889  {
17890  // implicitly convert null to object
17891  if (is_null())
17892  {
17893  m_type = value_t::object;
17894  m_value = value_t::object;
17895  assert_invariant();
17896  }
17897 
17898  // at only works for objects
17899  if (JSON_HEDLEY_LIKELY(is_object()))
17900  {
17901  return m_value.object->operator[](key);
17902  }
17903 
17904  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
17905  }
17906 
17937  template<typename T>
17939  const_reference operator[](T* key) const
17940  {
17941  // at only works for objects
17942  if (JSON_HEDLEY_LIKELY(is_object()))
17943  {
17944  assert(m_value.object->find(key) != m_value.object->end());
17945  return m_value.object->find(key)->second;
17946  }
17947 
17948  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
17949  }
17950 
18001  template<class ValueType, typename std::enable_if<
18003  ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
18004  {
18005  // at only works for objects
18006  if (JSON_HEDLEY_LIKELY(is_object()))
18007  {
18008  // if key is found, return value and given default value otherwise
18009  const auto it = find(key);
18010  if (it != end())
18011  {
18012  return *it;
18013  }
18014 
18015  return default_value;
18016  }
18017 
18018  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
18019  }
18020 
18025  string_t value(const typename object_t::key_type& key, const char* default_value) const
18026  {
18027  return value(key, string_t(default_value));
18028  }
18029 
18073  template<class ValueType, typename std::enable_if<
18075  ValueType value(const json_pointer& ptr, const ValueType& default_value) const
18076  {
18077  // at only works for objects
18078  if (JSON_HEDLEY_LIKELY(is_object()))
18079  {
18080  // if pointer resolves a value, return it or use default value
18081  JSON_TRY
18082  {
18083  return ptr.get_checked(this);
18084  }
18086  {
18087  return default_value;
18088  }
18089  }
18090 
18091  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
18092  }
18093 
18099  string_t value(const json_pointer& ptr, const char* default_value) const
18100  {
18101  return value(ptr, string_t(default_value));
18102  }
18103 
18129  reference front()
18130  {
18131  return *begin();
18132  }
18133 
18137  const_reference front() const
18138  {
18139  return *cbegin();
18140  }
18141 
18173  reference back()
18174  {
18175  auto tmp = end();
18176  --tmp;
18177  return *tmp;
18178  }
18179 
18183  const_reference back() const
18184  {
18185  auto tmp = cend();
18186  --tmp;
18187  return *tmp;
18188  }
18189 
18236  template<class IteratorType, typename std::enable_if<
18239  = 0>
18240  IteratorType erase(IteratorType pos)
18241  {
18242  // make sure iterator fits the current value
18243  if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
18244  {
18245  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
18246  }
18247 
18248  IteratorType result = end();
18249 
18250  switch (m_type)
18251  {
18252  case value_t::boolean:
18253  case value_t::number_float:
18254  case value_t::number_integer:
18255  case value_t::number_unsigned:
18256  case value_t::string:
18257  {
18258  if (JSON_HEDLEY_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
18259  {
18260  JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
18261  }
18262 
18263  if (is_string())
18264  {
18265  AllocatorType<string_t> alloc;
18266  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
18267  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
18268  m_value.string = nullptr;
18269  }
18270 
18271  m_type = value_t::null;
18272  assert_invariant();
18273  break;
18274  }
18275 
18276  case value_t::object:
18277  {
18278  result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
18279  break;
18280  }
18281 
18282  case value_t::array:
18283  {
18284  result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
18285  break;
18286  }
18287 
18288  default:
18289  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
18290  }
18291 
18292  return result;
18293  }
18294 
18341  template<class IteratorType, typename std::enable_if<
18344  = 0>
18345  IteratorType erase(IteratorType first, IteratorType last)
18346  {
18347  // make sure iterator fits the current value
18348  if (JSON_HEDLEY_UNLIKELY(this != first.m_object or this != last.m_object))
18349  {
18350  JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
18351  }
18352 
18353  IteratorType result = end();
18354 
18355  switch (m_type)
18356  {
18357  case value_t::boolean:
18358  case value_t::number_float:
18359  case value_t::number_integer:
18360  case value_t::number_unsigned:
18361  case value_t::string:
18362  {
18363  if (JSON_HEDLEY_LIKELY(not first.m_it.primitive_iterator.is_begin()
18364  or not last.m_it.primitive_iterator.is_end()))
18365  {
18366  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
18367  }
18368 
18369  if (is_string())
18370  {
18371  AllocatorType<string_t> alloc;
18372  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
18373  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
18374  m_value.string = nullptr;
18375  }
18376 
18377  m_type = value_t::null;
18378  assert_invariant();
18379  break;
18380  }
18381 
18382  case value_t::object:
18383  {
18384  result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
18385  last.m_it.object_iterator);
18386  break;
18387  }
18388 
18389  case value_t::array:
18390  {
18391  result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
18392  last.m_it.array_iterator);
18393  break;
18394  }
18395 
18396  default:
18397  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
18398  }
18399 
18400  return result;
18401  }
18402 
18432  size_type erase(const typename object_t::key_type& key)
18433  {
18434  // this erase only works for objects
18435  if (JSON_HEDLEY_LIKELY(is_object()))
18436  {
18437  return m_value.object->erase(key);
18438  }
18439 
18440  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
18441  }
18442 
18467  void erase(const size_type idx)
18468  {
18469  // this erase only works for arrays
18470  if (JSON_HEDLEY_LIKELY(is_array()))
18471  {
18472  if (JSON_HEDLEY_UNLIKELY(idx >= size()))
18473  {
18474  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
18475  }
18476 
18477  m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
18478  }
18479  else
18480  {
18481  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
18482  }
18483  }
18484 
18486 
18487 
18489  // lookup //
18491 
18494 
18519  template<typename KeyT>
18520  iterator find(KeyT&& key)
18521  {
18522  auto result = end();
18523 
18524  if (is_object())
18525  {
18526  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
18527  }
18528 
18529  return result;
18530  }
18531 
18536  template<typename KeyT>
18537  const_iterator find(KeyT&& key) const
18538  {
18539  auto result = cend();
18540 
18541  if (is_object())
18542  {
18543  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
18544  }
18545 
18546  return result;
18547  }
18548 
18570  template<typename KeyT>
18571  size_type count(KeyT&& key) const
18572  {
18573  // return 0 for all nonobject types
18574  return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
18575  }
18576 
18602  template<typename KeyT, typename std::enable_if<
18603  not std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int>::type = 0>
18604  bool contains(KeyT && key) const
18605  {
18606  return is_object() and m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
18607  }
18608 
18635  bool contains(const json_pointer& ptr) const
18636  {
18637  return ptr.contains(this);
18638  }
18639 
18641 
18642 
18644  // iterators //
18646 
18649 
18674  iterator begin() noexcept
18675  {
18676  iterator result(this);
18677  result.set_begin();
18678  return result;
18679  }
18680 
18684  const_iterator begin() const noexcept
18685  {
18686  return cbegin();
18687  }
18688 
18714  const_iterator cbegin() const noexcept
18715  {
18716  const_iterator result(this);
18717  result.set_begin();
18718  return result;
18719  }
18720 
18745  iterator end() noexcept
18746  {
18747  iterator result(this);
18748  result.set_end();
18749  return result;
18750  }
18751 
18755  const_iterator end() const noexcept
18756  {
18757  return cend();
18758  }
18759 
18785  const_iterator cend() const noexcept
18786  {
18787  const_iterator result(this);
18788  result.set_end();
18789  return result;
18790  }
18791 
18815  reverse_iterator rbegin() noexcept
18816  {
18817  return reverse_iterator(end());
18818  }
18819 
18823  const_reverse_iterator rbegin() const noexcept
18824  {
18825  return crbegin();
18826  }
18827 
18852  reverse_iterator rend() noexcept
18853  {
18854  return reverse_iterator(begin());
18855  }
18856 
18860  const_reverse_iterator rend() const noexcept
18861  {
18862  return crend();
18863  }
18864 
18889  const_reverse_iterator crbegin() const noexcept
18890  {
18891  return const_reverse_iterator(cend());
18892  }
18893 
18918  const_reverse_iterator crend() const noexcept
18919  {
18920  return const_reverse_iterator(cbegin());
18921  }
18922 
18923  public:
18981  JSON_HEDLEY_DEPRECATED(3.1.0)
18982  static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
18983  {
18984  return ref.items();
18985  }
18986 
18990  JSON_HEDLEY_DEPRECATED(3.1.0)
18991  static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
18992  {
18993  return ref.items();
18994  }
18995 
19059  iteration_proxy<iterator> items() noexcept
19060  {
19061  return iteration_proxy<iterator>(*this);
19062  }
19063 
19067  iteration_proxy<const_iterator> items() const noexcept
19068  {
19069  return iteration_proxy<const_iterator>(*this);
19070  }
19071 
19073 
19074 
19076  // capacity //
19078 
19081 
19123  bool empty() const noexcept
19124  {
19125  switch (m_type)
19126  {
19127  case value_t::null:
19128  {
19129  // null values are empty
19130  return true;
19131  }
19132 
19133  case value_t::array:
19134  {
19135  // delegate call to array_t::empty()
19136  return m_value.array->empty();
19137  }
19138 
19139  case value_t::object:
19140  {
19141  // delegate call to object_t::empty()
19142  return m_value.object->empty();
19143  }
19144 
19145  default:
19146  {
19147  // all other types are nonempty
19148  return false;
19149  }
19150  }
19151  }
19152 
19195  size_type size() const noexcept
19196  {
19197  switch (m_type)
19198  {
19199  case value_t::null:
19200  {
19201  // null values are empty
19202  return 0;
19203  }
19204 
19205  case value_t::array:
19206  {
19207  // delegate call to array_t::size()
19208  return m_value.array->size();
19209  }
19210 
19211  case value_t::object:
19212  {
19213  // delegate call to object_t::size()
19214  return m_value.object->size();
19215  }
19216 
19217  default:
19218  {
19219  // all other types have size 1
19220  return 1;
19221  }
19222  }
19223  }
19224 
19265  size_type max_size() const noexcept
19266  {
19267  switch (m_type)
19268  {
19269  case value_t::array:
19270  {
19271  // delegate call to array_t::max_size()
19272  return m_value.array->max_size();
19273  }
19274 
19275  case value_t::object:
19276  {
19277  // delegate call to object_t::max_size()
19278  return m_value.object->max_size();
19279  }
19280 
19281  default:
19282  {
19283  // all other types have max_size() == size()
19284  return size();
19285  }
19286  }
19287  }
19288 
19290 
19291 
19293  // modifiers //
19295 
19298 
19335  void clear() noexcept
19336  {
19337  switch (m_type)
19338  {
19339  case value_t::number_integer:
19340  {
19341  m_value.number_integer = 0;
19342  break;
19343  }
19344 
19345  case value_t::number_unsigned:
19346  {
19347  m_value.number_unsigned = 0;
19348  break;
19349  }
19350 
19351  case value_t::number_float:
19352  {
19353  m_value.number_float = 0.0;
19354  break;
19355  }
19356 
19357  case value_t::boolean:
19358  {
19359  m_value.boolean = false;
19360  break;
19361  }
19362 
19363  case value_t::string:
19364  {
19365  m_value.string->clear();
19366  break;
19367  }
19368 
19369  case value_t::array:
19370  {
19371  m_value.array->clear();
19372  break;
19373  }
19374 
19375  case value_t::object:
19376  {
19377  m_value.object->clear();
19378  break;
19379  }
19380 
19381  default:
19382  break;
19383  }
19384  }
19385 
19406  void push_back(basic_json&& val)
19407  {
19408  // push_back only works for null objects or arrays
19409  if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
19410  {
19411  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
19412  }
19413 
19414  // transform null object into an array
19415  if (is_null())
19416  {
19417  m_type = value_t::array;
19418  m_value = value_t::array;
19419  assert_invariant();
19420  }
19421 
19422  // add element to array (move semantics)
19423  m_value.array->push_back(std::move(val));
19424  // invalidate object: mark it null so we do not call the destructor
19425  // cppcheck-suppress accessMoved
19426  val.m_type = value_t::null;
19427  }
19428 
19433  reference operator+=(basic_json&& val)
19434  {
19435  push_back(std::move(val));
19436  return *this;
19437  }
19438 
19443  void push_back(const basic_json& val)
19444  {
19445  // push_back only works for null objects or arrays
19446  if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
19447  {
19448  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
19449  }
19450 
19451  // transform null object into an array
19452  if (is_null())
19453  {
19454  m_type = value_t::array;
19455  m_value = value_t::array;
19456  assert_invariant();
19457  }
19458 
19459  // add element to array
19460  m_value.array->push_back(val);
19461  }
19462 
19467  reference operator+=(const basic_json& val)
19468  {
19469  push_back(val);
19470  return *this;
19471  }
19472 
19493  void push_back(const typename object_t::value_type& val)
19494  {
19495  // push_back only works for null objects or objects
19496  if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
19497  {
19498  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
19499  }
19500 
19501  // transform null object into an object
19502  if (is_null())
19503  {
19504  m_type = value_t::object;
19505  m_value = value_t::object;
19506  assert_invariant();
19507  }
19508 
19509  // add element to array
19510  m_value.object->insert(val);
19511  }
19512 
19517  reference operator+=(const typename object_t::value_type& val)
19518  {
19519  push_back(val);
19520  return *this;
19521  }
19522 
19548  void push_back(initializer_list_t init)
19549  {
19550  if (is_object() and init.size() == 2 and (*init.begin())->is_string())
19551  {
19552  basic_json&& key = init.begin()->moved_or_copied();
19553  push_back(typename object_t::value_type(
19554  std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
19555  }
19556  else
19557  {
19558  push_back(basic_json(init));
19559  }
19560  }
19561 
19567  {
19568  push_back(init);
19569  return *this;
19570  }
19571 
19595  template<class... Args>
19596  reference emplace_back(Args&& ... args)
19597  {
19598  // emplace_back only works for null objects or arrays
19599  if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
19600  {
19601  JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
19602  }
19603 
19604  // transform null object into an array
19605  if (is_null())
19606  {
19607  m_type = value_t::array;
19608  m_value = value_t::array;
19609  assert_invariant();
19610  }
19611 
19612  // add element to array (perfect forwarding)
19613 #ifdef JSON_HAS_CPP_17
19614  return m_value.array->emplace_back(std::forward<Args>(args)...);
19615 #else
19616  m_value.array->emplace_back(std::forward<Args>(args)...);
19617  return m_value.array->back();
19618 #endif
19619  }
19620 
19648  template<class... Args>
19649  std::pair<iterator, bool> emplace(Args&& ... args)
19650  {
19651  // emplace only works for null objects or arrays
19652  if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
19653  {
19654  JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
19655  }
19656 
19657  // transform null object into an object
19658  if (is_null())
19659  {
19660  m_type = value_t::object;
19661  m_value = value_t::object;
19662  assert_invariant();
19663  }
19664 
19665  // add element to array (perfect forwarding)
19666  auto res = m_value.object->emplace(std::forward<Args>(args)...);
19667  // create result iterator and set iterator to the result of emplace
19668  auto it = begin();
19669  it.m_it.object_iterator = res.first;
19670 
19671  // return pair of iterator and boolean
19672  return {it, res.second};
19673  }
19674 
19678  template<typename... Args>
19679  iterator insert_iterator(const_iterator pos, Args&& ... args)
19680  {
19681  iterator result(this);
19682  assert(m_value.array != nullptr);
19683 
19684  auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
19685  m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
19686  result.m_it.array_iterator = m_value.array->begin() + insert_pos;
19687 
19688  // This could have been written as:
19689  // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
19690  // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
19691 
19692  return result;
19693  }
19694 
19718  {
19719  // insert only works for arrays
19720  if (JSON_HEDLEY_LIKELY(is_array()))
19721  {
19722  // check if iterator pos fits to this JSON value
19723  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
19724  {
19725  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
19726  }
19727 
19728  // insert to array and return iterator
19729  return insert_iterator(pos, val);
19730  }
19731 
19732  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
19733  }
19734 
19740  {
19741  return insert(pos, val);
19742  }
19743 
19769  {
19770  // insert only works for arrays
19771  if (JSON_HEDLEY_LIKELY(is_array()))
19772  {
19773  // check if iterator pos fits to this JSON value
19774  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
19775  {
19776  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
19777  }
19778 
19779  // insert to array and return iterator
19780  return insert_iterator(pos, cnt, val);
19781  }
19782 
19783  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
19784  }
19785 
19817  {
19818  // insert only works for arrays
19819  if (JSON_HEDLEY_UNLIKELY(not is_array()))
19820  {
19821  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
19822  }
19823 
19824  // check if iterator pos fits to this JSON value
19825  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
19826  {
19827  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
19828  }
19829 
19830  // check if range iterators belong to the same JSON object
19831  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
19832  {
19833  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
19834  }
19835 
19836  if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
19837  {
19838  JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
19839  }
19840 
19841  // insert to array and return iterator
19842  return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
19843  }
19844 
19870  {
19871  // insert only works for arrays
19872  if (JSON_HEDLEY_UNLIKELY(not is_array()))
19873  {
19874  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
19875  }
19876 
19877  // check if iterator pos fits to this JSON value
19878  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
19879  {
19880  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
19881  }
19882 
19883  // insert to array and return iterator
19884  return insert_iterator(pos, ilist.begin(), ilist.end());
19885  }
19886 
19910  void insert(const_iterator first, const_iterator last)
19911  {
19912  // insert only works for objects
19913  if (JSON_HEDLEY_UNLIKELY(not is_object()))
19914  {
19915  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
19916  }
19917 
19918  // check if range iterators belong to the same JSON object
19919  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
19920  {
19921  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
19922  }
19923 
19924  // passed iterators must belong to objects
19925  if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()))
19926  {
19927  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
19928  }
19929 
19930  m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
19931  }
19932 
19953  {
19954  // implicitly convert null value to an empty object
19955  if (is_null())
19956  {
19957  m_type = value_t::object;
19958  m_value.object = create<object_t>();
19959  assert_invariant();
19960  }
19961 
19962  if (JSON_HEDLEY_UNLIKELY(not is_object()))
19963  {
19964  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
19965  }
19966  if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
19967  {
19968  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
19969  }
19970 
19971  for (auto it = j.cbegin(); it != j.cend(); ++it)
19972  {
19973  m_value.object->operator[](it.key()) = it.value();
19974  }
19975  }
19976 
20004  {
20005  // implicitly convert null value to an empty object
20006  if (is_null())
20007  {
20008  m_type = value_t::object;
20009  m_value.object = create<object_t>();
20010  assert_invariant();
20011  }
20012 
20013  if (JSON_HEDLEY_UNLIKELY(not is_object()))
20014  {
20015  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
20016  }
20017 
20018  // check if range iterators belong to the same JSON object
20019  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20020  {
20021  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
20022  }
20023 
20024  // passed iterators must belong to objects
20025  if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()
20026  or not last.m_object->is_object()))
20027  {
20028  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
20029  }
20030 
20031  for (auto it = first; it != last; ++it)
20032  {
20033  m_value.object->operator[](it.key()) = it.value();
20034  }
20035  }
20036 
20054  void swap(reference other) noexcept (
20059  )
20060  {
20061  std::swap(m_type, other.m_type);
20062  std::swap(m_value, other.m_value);
20063  assert_invariant();
20064  }
20065 
20086  void swap(array_t& other)
20087  {
20088  // swap only works for arrays
20089  if (JSON_HEDLEY_LIKELY(is_array()))
20090  {
20091  std::swap(*(m_value.array), other);
20092  }
20093  else
20094  {
20095  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
20096  }
20097  }
20098 
20119  void swap(object_t& other)
20120  {
20121  // swap only works for objects
20122  if (JSON_HEDLEY_LIKELY(is_object()))
20123  {
20124  std::swap(*(m_value.object), other);
20125  }
20126  else
20127  {
20128  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
20129  }
20130  }
20131 
20152  void swap(string_t& other)
20153  {
20154  // swap only works for strings
20155  if (JSON_HEDLEY_LIKELY(is_string()))
20156  {
20157  std::swap(*(m_value.string), other);
20158  }
20159  else
20160  {
20161  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
20162  }
20163  }
20164 
20166 
20167  public:
20169  // lexicographical comparison operators //
20171 
20174 
20214  friend bool operator==(const_reference lhs, const_reference rhs) noexcept
20215  {
20216  const auto lhs_type = lhs.type();
20217  const auto rhs_type = rhs.type();
20218 
20219  if (lhs_type == rhs_type)
20220  {
20221  switch (lhs_type)
20222  {
20223  case value_t::array:
20224  return *lhs.m_value.array == *rhs.m_value.array;
20225 
20226  case value_t::object:
20227  return *lhs.m_value.object == *rhs.m_value.object;
20228 
20229  case value_t::null:
20230  return true;
20231 
20232  case value_t::string:
20233  return *lhs.m_value.string == *rhs.m_value.string;
20234 
20235  case value_t::boolean:
20236  return lhs.m_value.boolean == rhs.m_value.boolean;
20237 
20238  case value_t::number_integer:
20239  return lhs.m_value.number_integer == rhs.m_value.number_integer;
20240 
20241  case value_t::number_unsigned:
20242  return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
20243 
20244  case value_t::number_float:
20245  return lhs.m_value.number_float == rhs.m_value.number_float;
20246 
20247  default:
20248  return false;
20249  }
20250  }
20251  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
20252  {
20253  return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
20254  }
20255  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
20256  {
20257  return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
20258  }
20259  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
20260  {
20261  return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
20262  }
20263  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
20264  {
20265  return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
20266  }
20267  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
20268  {
20269  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
20270  }
20271  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
20272  {
20273  return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
20274  }
20275 
20276  return false;
20277  }
20278 
20283  template<typename ScalarType, typename std::enable_if<
20284  std::is_scalar<ScalarType>::value, int>::type = 0>
20285  friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
20286  {
20287  return lhs == basic_json(rhs);
20288  }
20289 
20294  template<typename ScalarType, typename std::enable_if<
20295  std::is_scalar<ScalarType>::value, int>::type = 0>
20296  friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
20297  {
20298  return basic_json(lhs) == rhs;
20299  }
20300 
20319  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
20320  {
20321  return not (lhs == rhs);
20322  }
20323 
20328  template<typename ScalarType, typename std::enable_if<
20329  std::is_scalar<ScalarType>::value, int>::type = 0>
20330  friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
20331  {
20332  return lhs != basic_json(rhs);
20333  }
20334 
20339  template<typename ScalarType, typename std::enable_if<
20340  std::is_scalar<ScalarType>::value, int>::type = 0>
20341  friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
20342  {
20343  return basic_json(lhs) != rhs;
20344  }
20345 
20372  friend bool operator<(const_reference lhs, const_reference rhs) noexcept
20373  {
20374  const auto lhs_type = lhs.type();
20375  const auto rhs_type = rhs.type();
20376 
20377  if (lhs_type == rhs_type)
20378  {
20379  switch (lhs_type)
20380  {
20381  case value_t::array:
20382  // note parentheses are necessary, see
20383  // https://github.com/nlohmann/json/issues/1530
20384  return (*lhs.m_value.array) < (*rhs.m_value.array);
20385 
20386  case value_t::object:
20387  return (*lhs.m_value.object) < (*rhs.m_value.object);
20388 
20389  case value_t::null:
20390  return false;
20391 
20392  case value_t::string:
20393  return (*lhs.m_value.string) < (*rhs.m_value.string);
20394 
20395  case value_t::boolean:
20396  return (lhs.m_value.boolean) < (rhs.m_value.boolean);
20397 
20398  case value_t::number_integer:
20399  return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
20400 
20401  case value_t::number_unsigned:
20402  return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
20403 
20404  case value_t::number_float:
20405  return (lhs.m_value.number_float) < (rhs.m_value.number_float);
20406 
20407  default:
20408  return false;
20409  }
20410  }
20411  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
20412  {
20413  return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
20414  }
20415  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
20416  {
20417  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
20418  }
20419  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
20420  {
20421  return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
20422  }
20423  else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
20424  {
20425  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
20426  }
20427  else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
20428  {
20429  return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
20430  }
20431  else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
20432  {
20433  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
20434  }
20435 
20436  // We only reach this line if we cannot compare values. In that case,
20437  // we compare types. Note we have to call the operator explicitly,
20438  // because MSVC has problems otherwise.
20439  return operator<(lhs_type, rhs_type);
20440  }
20441 
20446  template<typename ScalarType, typename std::enable_if<
20447  std::is_scalar<ScalarType>::value, int>::type = 0>
20448  friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
20449  {
20450  return lhs < basic_json(rhs);
20451  }
20452 
20457  template<typename ScalarType, typename std::enable_if<
20458  std::is_scalar<ScalarType>::value, int>::type = 0>
20459  friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
20460  {
20461  return basic_json(lhs) < rhs;
20462  }
20463 
20483  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
20484  {
20485  return not (rhs < lhs);
20486  }
20487 
20492  template<typename ScalarType, typename std::enable_if<
20493  std::is_scalar<ScalarType>::value, int>::type = 0>
20494  friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
20495  {
20496  return lhs <= basic_json(rhs);
20497  }
20498 
20503  template<typename ScalarType, typename std::enable_if<
20504  std::is_scalar<ScalarType>::value, int>::type = 0>
20505  friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
20506  {
20507  return basic_json(lhs) <= rhs;
20508  }
20509 
20529  friend bool operator>(const_reference lhs, const_reference rhs) noexcept
20530  {
20531  return not (lhs <= rhs);
20532  }
20533 
20538  template<typename ScalarType, typename std::enable_if<
20539  std::is_scalar<ScalarType>::value, int>::type = 0>
20540  friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
20541  {
20542  return lhs > basic_json(rhs);
20543  }
20544 
20549  template<typename ScalarType, typename std::enable_if<
20550  std::is_scalar<ScalarType>::value, int>::type = 0>
20551  friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
20552  {
20553  return basic_json(lhs) > rhs;
20554  }
20555 
20575  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
20576  {
20577  return not (lhs < rhs);
20578  }
20579 
20584  template<typename ScalarType, typename std::enable_if<
20585  std::is_scalar<ScalarType>::value, int>::type = 0>
20586  friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
20587  {
20588  return lhs >= basic_json(rhs);
20589  }
20590 
20595  template<typename ScalarType, typename std::enable_if<
20596  std::is_scalar<ScalarType>::value, int>::type = 0>
20597  friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
20598  {
20599  return basic_json(lhs) >= rhs;
20600  }
20601 
20603 
20605  // serialization //
20607 
20610 
20642  friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
20643  {
20644  // read width member and use it as indentation parameter if nonzero
20645  const bool pretty_print = o.width() > 0;
20646  const auto indentation = pretty_print ? o.width() : 0;
20647 
20648  // reset width to 0 for subsequent calls to this stream
20649  o.width(0);
20650 
20651  // do the actual serialization
20653  s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
20654  return o;
20655  }
20656 
20665  JSON_HEDLEY_DEPRECATED(3.0.0)
20666  friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
20667  {
20668  return o << j;
20669  }
20670 
20672 
20673 
20675  // deserialization //
20677 
20680 
20746  const parser_callback_t cb = nullptr,
20747  const bool allow_exceptions = true)
20748  {
20749  basic_json result;
20750  parser(i, cb, allow_exceptions).parse(true, result);
20751  return result;
20752  }
20753 
20754  static bool accept(detail::input_adapter&& i)
20755  {
20756  return parser(i).accept(true);
20757  }
20758 
20812  template <typename SAX>
20814  static bool sax_parse(detail::input_adapter&& i, SAX* sax,
20816  const bool strict = true)
20817  {
20818  assert(sax);
20819  return format == input_format_t::json
20820  ? parser(std::move(i)).sax_parse(sax, strict)
20821  : detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
20822  }
20823 
20873  template<class IteratorType, typename std::enable_if<
20874  std::is_base_of<
20875  std::random_access_iterator_tag,
20876  typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
20877  static basic_json parse(IteratorType first, IteratorType last,
20878  const parser_callback_t cb = nullptr,
20879  const bool allow_exceptions = true)
20880  {
20881  basic_json result;
20882  parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result);
20883  return result;
20884  }
20885 
20886  template<class IteratorType, typename std::enable_if<
20887  std::is_base_of<
20888  std::random_access_iterator_tag,
20889  typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
20890  static bool accept(IteratorType first, IteratorType last)
20891  {
20892  return parser(detail::input_adapter(first, last)).accept(true);
20893  }
20894 
20895  template<class IteratorType, class SAX, typename std::enable_if<
20896  std::is_base_of<
20897  std::random_access_iterator_tag,
20898  typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
20900  static bool sax_parse(IteratorType first, IteratorType last, SAX* sax)
20901  {
20902  return parser(detail::input_adapter(first, last)).sax_parse(sax);
20903  }
20904 
20913  JSON_HEDLEY_DEPRECATED(3.0.0)
20914  friend std::istream& operator<<(basic_json& j, std::istream& i)
20915  {
20916  return operator>>(i, j);
20917  }
20918 
20944  friend std::istream& operator>>(std::istream& i, basic_json& j)
20945  {
20946  parser(detail::input_adapter(i)).parse(false, j);
20947  return i;
20948  }
20949 
20951 
20953  // convenience functions //
20955 
20987  const char* type_name() const noexcept
20988  {
20989  {
20990  switch (m_type)
20991  {
20992  case value_t::null:
20993  return "null";
20994  case value_t::object:
20995  return "object";
20996  case value_t::array:
20997  return "array";
20998  case value_t::string:
20999  return "string";
21000  case value_t::boolean:
21001  return "boolean";
21002  case value_t::discarded:
21003  return "discarded";
21004  default:
21005  return "number";
21006  }
21007  }
21008  }
21009 
21010 
21011  private:
21013  // member variables //
21015 
21017  value_t m_type = value_t::null;
21018 
21020  json_value m_value = {};
21021 
21023  // binary serialization/deserialization //
21025 
21028 
21029  public:
21118  static std::vector<uint8_t> to_cbor(const basic_json& j)
21119  {
21120  std::vector<uint8_t> result;
21121  to_cbor(j, result);
21122  return result;
21123  }
21124 
21125  static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
21126  {
21127  binary_writer<uint8_t>(o).write_cbor(j);
21128  }
21129 
21130  static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
21131  {
21132  binary_writer<char>(o).write_cbor(j);
21133  }
21134 
21214  static std::vector<uint8_t> to_msgpack(const basic_json& j)
21215  {
21216  std::vector<uint8_t> result;
21217  to_msgpack(j, result);
21218  return result;
21219  }
21220 
21221  static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
21222  {
21223  binary_writer<uint8_t>(o).write_msgpack(j);
21224  }
21225 
21226  static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
21227  {
21228  binary_writer<char>(o).write_msgpack(j);
21229  }
21230 
21311  static std::vector<uint8_t> to_ubjson(const basic_json& j,
21312  const bool use_size = false,
21313  const bool use_type = false)
21314  {
21315  std::vector<uint8_t> result;
21316  to_ubjson(j, result, use_size, use_type);
21317  return result;
21318  }
21319 
21320  static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
21321  const bool use_size = false, const bool use_type = false)
21322  {
21323  binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
21324  }
21325 
21326  static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
21327  const bool use_size = false, const bool use_type = false)
21328  {
21329  binary_writer<char>(o).write_ubjson(j, use_size, use_type);
21330  }
21331 
21332 
21388  static std::vector<uint8_t> to_bson(const basic_json& j)
21389  {
21390  std::vector<uint8_t> result;
21391  to_bson(j, result);
21392  return result;
21393  }
21394 
21403  static void to_bson(const basic_json& j, detail::output_adapter<uint8_t> o)
21404  {
21405  binary_writer<uint8_t>(o).write_bson(j);
21406  }
21407 
21411  static void to_bson(const basic_json& j, detail::output_adapter<char> o)
21412  {
21413  binary_writer<char>(o).write_bson(j);
21414  }
21415 
21416 
21517  static basic_json from_cbor(detail::input_adapter&& i,
21518  const bool strict = true,
21519  const bool allow_exceptions = true)
21520  {
21521  basic_json result;
21522  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21523  const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::cbor, &sdp, strict);
21524  return res ? result : basic_json(value_t::discarded);
21525  }
21526 
21530  template<typename A1, typename A2,
21533  static basic_json from_cbor(A1 && a1, A2 && a2,
21534  const bool strict = true,
21535  const bool allow_exceptions = true)
21536  {
21537  basic_json result;
21538  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21539  const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::cbor, &sdp, strict);
21540  return res ? result : basic_json(value_t::discarded);
21541  }
21542 
21626  static basic_json from_msgpack(detail::input_adapter&& i,
21627  const bool strict = true,
21628  const bool allow_exceptions = true)
21629  {
21630  basic_json result;
21631  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21632  const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::msgpack, &sdp, strict);
21633  return res ? result : basic_json(value_t::discarded);
21634  }
21635 
21639  template<typename A1, typename A2,
21642  static basic_json from_msgpack(A1 && a1, A2 && a2,
21643  const bool strict = true,
21644  const bool allow_exceptions = true)
21645  {
21646  basic_json result;
21647  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21648  const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::msgpack, &sdp, strict);
21649  return res ? result : basic_json(value_t::discarded);
21650  }
21651 
21714  static basic_json from_ubjson(detail::input_adapter&& i,
21715  const bool strict = true,
21716  const bool allow_exceptions = true)
21717  {
21718  basic_json result;
21719  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21720  const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::ubjson, &sdp, strict);
21721  return res ? result : basic_json(value_t::discarded);
21722  }
21723 
21727  template<typename A1, typename A2,
21730  static basic_json from_ubjson(A1 && a1, A2 && a2,
21731  const bool strict = true,
21732  const bool allow_exceptions = true)
21733  {
21734  basic_json result;
21735  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21736  const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::ubjson, &sdp, strict);
21737  return res ? result : basic_json(value_t::discarded);
21738  }
21739 
21801  static basic_json from_bson(detail::input_adapter&& i,
21802  const bool strict = true,
21803  const bool allow_exceptions = true)
21804  {
21805  basic_json result;
21806  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21807  const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::bson, &sdp, strict);
21808  return res ? result : basic_json(value_t::discarded);
21809  }
21810 
21814  template<typename A1, typename A2,
21817  static basic_json from_bson(A1 && a1, A2 && a2,
21818  const bool strict = true,
21819  const bool allow_exceptions = true)
21820  {
21821  basic_json result;
21822  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21823  const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::bson, &sdp, strict);
21824  return res ? result : basic_json(value_t::discarded);
21825  }
21826 
21827 
21828 
21830 
21832  // JSON Pointer support //
21834 
21837 
21871  reference operator[](const json_pointer& ptr)
21872  {
21873  return ptr.get_unchecked(this);
21874  }
21875 
21899  const_reference operator[](const json_pointer& ptr) const
21900  {
21901  return ptr.get_unchecked(this);
21902  }
21903 
21943  {
21944  return ptr.get_checked(this);
21945  }
21946 
21985  const_reference at(const json_pointer& ptr) const
21986  {
21987  return ptr.get_checked(this);
21988  }
21989 
22012  basic_json flatten() const
22013  {
22014  basic_json result(value_t::object);
22015  json_pointer::flatten("", *this, result);
22016  return result;
22017  }
22018 
22049  basic_json unflatten() const
22050  {
22051  return json_pointer::unflatten(*this);
22052  }
22053 
22055 
22057  // JSON Patch functions //
22059 
22062 
22110  basic_json patch(const basic_json& json_patch) const
22111  {
22112  // make a working copy to apply the patch to
22113  basic_json result = *this;
22114 
22115  // the valid JSON Patch operations
22116  enum class patch_operations {add, remove, replace, move, copy, test, invalid};
22117 
22118  const auto get_op = [](const std::string & op)
22119  {
22120  if (op == "add")
22121  {
22122  return patch_operations::add;
22123  }
22124  if (op == "remove")
22125  {
22126  return patch_operations::remove;
22127  }
22128  if (op == "replace")
22129  {
22130  return patch_operations::replace;
22131  }
22132  if (op == "move")
22133  {
22134  return patch_operations::move;
22135  }
22136  if (op == "copy")
22137  {
22138  return patch_operations::copy;
22139  }
22140  if (op == "test")
22141  {
22142  return patch_operations::test;
22143  }
22144 
22145  return patch_operations::invalid;
22146  };
22147 
22148  // wrapper for "add" operation; add value at ptr
22149  const auto operation_add = [&result](json_pointer & ptr, basic_json val)
22150  {
22151  // adding to the root of the target document means replacing it
22152  if (ptr.empty())
22153  {
22154  result = val;
22155  return;
22156  }
22157 
22158  // make sure the top element of the pointer exists
22159  json_pointer top_pointer = ptr.top();
22160  if (top_pointer != ptr)
22161  {
22162  result.at(top_pointer);
22163  }
22164 
22165  // get reference to parent of JSON pointer ptr
22166  const auto last_path = ptr.back();
22167  ptr.pop_back();
22168  basic_json& parent = result[ptr];
22169 
22170  switch (parent.m_type)
22171  {
22172  case value_t::null:
22173  case value_t::object:
22174  {
22175  // use operator[] to add value
22176  parent[last_path] = val;
22177  break;
22178  }
22179 
22180  case value_t::array:
22181  {
22182  if (last_path == "-")
22183  {
22184  // special case: append to back
22185  parent.push_back(val);
22186  }
22187  else
22188  {
22189  const auto idx = json_pointer::array_index(last_path);
22190  if (JSON_HEDLEY_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
22191  {
22192  // avoid undefined behavior
22193  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
22194  }
22195 
22196  // default case: insert add offset
22197  parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
22198  }
22199  break;
22200  }
22201 
22202  // if there exists a parent it cannot be primitive
22203  default: // LCOV_EXCL_LINE
22204  assert(false); // LCOV_EXCL_LINE
22205  }
22206  };
22207 
22208  // wrapper for "remove" operation; remove value at ptr
22209  const auto operation_remove = [&result](json_pointer & ptr)
22210  {
22211  // get reference to parent of JSON pointer ptr
22212  const auto last_path = ptr.back();
22213  ptr.pop_back();
22214  basic_json& parent = result.at(ptr);
22215 
22216  // remove child
22217  if (parent.is_object())
22218  {
22219  // perform range check
22220  auto it = parent.find(last_path);
22221  if (JSON_HEDLEY_LIKELY(it != parent.end()))
22222  {
22223  parent.erase(it);
22224  }
22225  else
22226  {
22227  JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
22228  }
22229  }
22230  else if (parent.is_array())
22231  {
22232  // note erase performs range check
22233  parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
22234  }
22235  };
22236 
22237  // type check: top level value must be an array
22238  if (JSON_HEDLEY_UNLIKELY(not json_patch.is_array()))
22239  {
22240  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
22241  }
22242 
22243  // iterate and apply the operations
22244  for (const auto& val : json_patch)
22245  {
22246  // wrapper to get a value for an operation
22247  const auto get_value = [&val](const std::string & op,
22248  const std::string & member,
22249  bool string_type) -> basic_json &
22250  {
22251  // find value
22252  auto it = val.m_value.object->find(member);
22253 
22254  // context-sensitive error message
22255  const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
22256 
22257  // check if desired value is present
22258  if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
22259  {
22260  JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
22261  }
22262 
22263  // check if result is of type string
22264  if (JSON_HEDLEY_UNLIKELY(string_type and not it->second.is_string()))
22265  {
22266  JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
22267  }
22268 
22269  // no error: return value
22270  return it->second;
22271  };
22272 
22273  // type check: every element of the array must be an object
22274  if (JSON_HEDLEY_UNLIKELY(not val.is_object()))
22275  {
22276  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
22277  }
22278 
22279  // collect mandatory members
22280  const std::string op = get_value("op", "op", true);
22281  const std::string path = get_value(op, "path", true);
22282  json_pointer ptr(path);
22283 
22284  switch (get_op(op))
22285  {
22286  case patch_operations::add:
22287  {
22288  operation_add(ptr, get_value("add", "value", false));
22289  break;
22290  }
22291 
22292  case patch_operations::remove:
22293  {
22294  operation_remove(ptr);
22295  break;
22296  }
22297 
22298  case patch_operations::replace:
22299  {
22300  // the "path" location must exist - use at()
22301  result.at(ptr) = get_value("replace", "value", false);
22302  break;
22303  }
22304 
22305  case patch_operations::move:
22306  {
22307  const std::string from_path = get_value("move", "from", true);
22308  json_pointer from_ptr(from_path);
22309 
22310  // the "from" location must exist - use at()
22311  basic_json v = result.at(from_ptr);
22312 
22313  // The move operation is functionally identical to a
22314  // "remove" operation on the "from" location, followed
22315  // immediately by an "add" operation at the target
22316  // location with the value that was just removed.
22317  operation_remove(from_ptr);
22318  operation_add(ptr, v);
22319  break;
22320  }
22321 
22323  {
22324  const std::string from_path = get_value("copy", "from", true);
22325  const json_pointer from_ptr(from_path);
22326 
22327  // the "from" location must exist - use at()
22328  basic_json v = result.at(from_ptr);
22329 
22330  // The copy is functionally identical to an "add"
22331  // operation at the target location using the value
22332  // specified in the "from" member.
22333  operation_add(ptr, v);
22334  break;
22335  }
22336 
22338  {
22339  bool success = false;
22340  JSON_TRY
22341  {
22342  // check if "value" matches the one at "path"
22343  // the "path" location must exist - use at()
22344  success = (result.at(ptr) == get_value("test", "value", false));
22345  }
22347  {
22348  // ignore out of range errors: success remains false
22349  }
22350 
22351  // throw an exception if test fails
22352  if (JSON_HEDLEY_UNLIKELY(not success))
22353  {
22354  JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
22355  }
22356 
22357  break;
22358  }
22359 
22360  default:
22361  {
22362  // op must be "add", "remove", "replace", "move", "copy", or
22363  // "test"
22364  JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
22365  }
22366  }
22367  }
22368 
22369  return result;
22370  }
22371 
22406  static basic_json diff(const basic_json& source, const basic_json& target,
22407  const std::string& path = "")
22408  {
22409  // the patch
22410  basic_json result(value_t::array);
22411 
22412  // if the values are the same, return empty patch
22413  if (source == target)
22414  {
22415  return result;
22416  }
22417 
22418  if (source.type() != target.type())
22419  {
22420  // different types: replace value
22421  result.push_back(
22422  {
22423  {"op", "replace"}, {"path", path}, {"value", target}
22424  });
22425  return result;
22426  }
22427 
22428  switch (source.type())
22429  {
22430  case value_t::array:
22431  {
22432  // first pass: traverse common elements
22433  std::size_t i = 0;
22434  while (i < source.size() and i < target.size())
22435  {
22436  // recursive call to compare array values at index i
22437  auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
22438  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
22439  ++i;
22440  }
22441 
22442  // i now reached the end of at least one array
22443  // in a second pass, traverse the remaining elements
22444 
22445  // remove my remaining elements
22446  const auto end_index = static_cast<difference_type>(result.size());
22447  while (i < source.size())
22448  {
22449  // add operations in reverse order to avoid invalid
22450  // indices
22451  result.insert(result.begin() + end_index, object(
22452  {
22453  {"op", "remove"},
22454  {"path", path + "/" + std::to_string(i)}
22455  }));
22456  ++i;
22457  }
22458 
22459  // add other remaining elements
22460  while (i < target.size())
22461  {
22462  result.push_back(
22463  {
22464  {"op", "add"},
22465  {"path", path + "/" + std::to_string(i)},
22466  {"value", target[i]}
22467  });
22468  ++i;
22469  }
22470 
22471  break;
22472  }
22473 
22474  case value_t::object:
22475  {
22476  // first pass: traverse this object's elements
22477  for (auto it = source.cbegin(); it != source.cend(); ++it)
22478  {
22479  // escape the key name to be used in a JSON patch
22480  const auto key = json_pointer::escape(it.key());
22481 
22482  if (target.find(it.key()) != target.end())
22483  {
22484  // recursive call to compare object values at key it
22485  auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
22486  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
22487  }
22488  else
22489  {
22490  // found a key that is not in o -> remove it
22491  result.push_back(object(
22492  {
22493  {"op", "remove"}, {"path", path + "/" + key}
22494  }));
22495  }
22496  }
22497 
22498  // second pass: traverse other object's elements
22499  for (auto it = target.cbegin(); it != target.cend(); ++it)
22500  {
22501  if (source.find(it.key()) == source.end())
22502  {
22503  // found a key that is not in this -> add it
22504  const auto key = json_pointer::escape(it.key());
22505  result.push_back(
22506  {
22507  {"op", "add"}, {"path", path + "/" + key},
22508  {"value", it.value()}
22509  });
22510  }
22511  }
22512 
22513  break;
22514  }
22515 
22516  default:
22517  {
22518  // both primitive type: replace value
22519  result.push_back(
22520  {
22521  {"op", "replace"}, {"path", path}, {"value", target}
22522  });
22523  break;
22524  }
22525  }
22526 
22527  return result;
22528  }
22529 
22531 
22533  // JSON Merge Patch functions //
22535 
22538 
22581  void merge_patch(const basic_json& apply_patch)
22582  {
22583  if (apply_patch.is_object())
22584  {
22585  if (not is_object())
22586  {
22587  *this = object();
22588  }
22589  for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
22590  {
22591  if (it.value().is_null())
22592  {
22593  erase(it.key());
22594  }
22595  else
22596  {
22597  operator[](it.key()).merge_patch(it.value());
22598  }
22599  }
22600  }
22601  else
22602  {
22603  *this = apply_patch;
22604  }
22605  }
22606 
22608 };
22609 
22620 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
22621 {
22622  return j.dump();
22623 }
22624 } // namespace nlohmann
22625 
22627 // nonmember support //
22629 
22630 // specialization of std::swap, and std::hash
22631 namespace std
22632 {
22633 
22635 template<>
22636 struct hash<nlohmann::json>
22637 {
22643  std::size_t operator()(const nlohmann::json& j) const
22644  {
22645  // a naive hashing via the string representation
22646  const auto& h = hash<nlohmann::json::string_t>();
22647  return h(j.dump());
22648  }
22649 };
22650 
22654 template<>
22656 {
22661  bool operator()(nlohmann::detail::value_t lhs,
22662  nlohmann::detail::value_t rhs) const noexcept
22663  {
22664  return nlohmann::detail::operator<(lhs, rhs);
22665  }
22666 };
22667 
22673 template<>
22674 inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
22677 )
22678 {
22679  j1.swap(j2);
22680 }
22681 
22682 } // namespace std
22683 
22698 inline nlohmann::json operator "" _json(const char* s, std::size_t n)
22699 {
22700  return nlohmann::json::parse(s, s + n);
22701 }
22702 
22717 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
22718 {
22719  return nlohmann::json::json_pointer(std::string(s, n));
22720 }
22721 
22722 // #include <nlohmann/detail/macro_unscope.hpp>
22723 
22724 
22725 // restore GCC/clang diagnostic settings
22726 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
22727  #pragma GCC diagnostic pop
22728 #endif
22729 #if defined(__clang__)
22730  #pragma GCC diagnostic pop
22731 #endif
22732 
22733 // clean up
22734 #undef JSON_INTERNAL_CATCH
22735 #undef JSON_CATCH
22736 #undef JSON_THROW
22737 #undef JSON_TRY
22738 #undef JSON_HAS_CPP_14
22739 #undef JSON_HAS_CPP_17
22740 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
22741 #undef NLOHMANN_BASIC_JSON_TPL
22742 
22743 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
22744 #undef JSON_HEDLEY_ALWAYS_INLINE
22745 #undef JSON_HEDLEY_ARM_VERSION
22746 #undef JSON_HEDLEY_ARM_VERSION_CHECK
22747 #undef JSON_HEDLEY_ARRAY_PARAM
22748 #undef JSON_HEDLEY_ASSUME
22749 #undef JSON_HEDLEY_BEGIN_C_DECLS
22750 #undef JSON_HEDLEY_C_DECL
22751 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
22752 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
22753 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
22754 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
22755 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
22756 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
22757 #undef JSON_HEDLEY_CLANG_HAS_WARNING
22758 #undef JSON_HEDLEY_COMPCERT_VERSION
22759 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
22760 #undef JSON_HEDLEY_CONCAT
22761 #undef JSON_HEDLEY_CONCAT_EX
22762 #undef JSON_HEDLEY_CONST
22763 #undef JSON_HEDLEY_CONST_CAST
22764 #undef JSON_HEDLEY_CONSTEXPR
22765 #undef JSON_HEDLEY_CPP_CAST
22766 #undef JSON_HEDLEY_CRAY_VERSION
22767 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
22768 #undef JSON_HEDLEY_DEPRECATED
22769 #undef JSON_HEDLEY_DEPRECATED_FOR
22770 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
22771 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
22772 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
22773 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
22774 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
22775 #undef JSON_HEDLEY_DIAGNOSTIC_POP
22776 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
22777 #undef JSON_HEDLEY_DMC_VERSION
22778 #undef JSON_HEDLEY_DMC_VERSION_CHECK
22779 #undef JSON_HEDLEY_EMPTY_BASES
22780 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
22781 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
22782 #undef JSON_HEDLEY_END_C_DECLS
22783 #undef JSON_HEDLEY_FALL_THROUGH
22784 #undef JSON_HEDLEY_FLAGS
22785 #undef JSON_HEDLEY_FLAGS_CAST
22786 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
22787 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
22788 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
22789 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
22790 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
22791 #undef JSON_HEDLEY_GCC_HAS_FEATURE
22792 #undef JSON_HEDLEY_GCC_HAS_WARNING
22793 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
22794 #undef JSON_HEDLEY_GCC_VERSION
22795 #undef JSON_HEDLEY_GCC_VERSION_CHECK
22796 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
22797 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
22798 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
22799 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
22800 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
22801 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
22802 #undef JSON_HEDLEY_GNUC_HAS_WARNING
22803 #undef JSON_HEDLEY_GNUC_VERSION
22804 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
22805 #undef JSON_HEDLEY_HAS_ATTRIBUTE
22806 #undef JSON_HEDLEY_HAS_BUILTIN
22807 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
22808 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
22809 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
22810 #undef JSON_HEDLEY_HAS_EXTENSION
22811 #undef JSON_HEDLEY_HAS_FEATURE
22812 #undef JSON_HEDLEY_HAS_WARNING
22813 #undef JSON_HEDLEY_IAR_VERSION
22814 #undef JSON_HEDLEY_IAR_VERSION_CHECK
22815 #undef JSON_HEDLEY_IBM_VERSION
22816 #undef JSON_HEDLEY_IBM_VERSION_CHECK
22817 #undef JSON_HEDLEY_IMPORT
22818 #undef JSON_HEDLEY_INLINE
22819 #undef JSON_HEDLEY_INTEL_VERSION
22820 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
22821 #undef JSON_HEDLEY_IS_CONSTANT
22822 #undef JSON_HEDLEY_IS_CONSTEXPR_
22823 #undef JSON_HEDLEY_LIKELY
22824 #undef JSON_HEDLEY_MALLOC
22825 #undef JSON_HEDLEY_MESSAGE
22826 #undef JSON_HEDLEY_MSVC_VERSION
22827 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
22828 #undef JSON_HEDLEY_NEVER_INLINE
22829 #undef JSON_HEDLEY_NO_ESCAPE
22830 #undef JSON_HEDLEY_NON_NULL
22831 #undef JSON_HEDLEY_NO_RETURN
22832 #undef JSON_HEDLEY_NO_THROW
22833 #undef JSON_HEDLEY_NULL
22834 #undef JSON_HEDLEY_PELLES_VERSION
22835 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
22836 #undef JSON_HEDLEY_PGI_VERSION
22837 #undef JSON_HEDLEY_PGI_VERSION_CHECK
22838 #undef JSON_HEDLEY_PREDICT
22839 #undef JSON_HEDLEY_PRINTF_FORMAT
22840 #undef JSON_HEDLEY_PRIVATE
22841 #undef JSON_HEDLEY_PUBLIC
22842 #undef JSON_HEDLEY_PURE
22843 #undef JSON_HEDLEY_REINTERPRET_CAST
22844 #undef JSON_HEDLEY_REQUIRE
22845 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
22846 #undef JSON_HEDLEY_REQUIRE_MSG
22847 #undef JSON_HEDLEY_RESTRICT
22848 #undef JSON_HEDLEY_RETURNS_NON_NULL
22849 #undef JSON_HEDLEY_SENTINEL
22850 #undef JSON_HEDLEY_STATIC_ASSERT
22851 #undef JSON_HEDLEY_STATIC_CAST
22852 #undef JSON_HEDLEY_STRINGIFY
22853 #undef JSON_HEDLEY_STRINGIFY_EX
22854 #undef JSON_HEDLEY_SUNPRO_VERSION
22855 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
22856 #undef JSON_HEDLEY_TINYC_VERSION
22857 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
22858 #undef JSON_HEDLEY_TI_VERSION
22859 #undef JSON_HEDLEY_TI_VERSION_CHECK
22860 #undef JSON_HEDLEY_UNAVAILABLE
22861 #undef JSON_HEDLEY_UNLIKELY
22862 #undef JSON_HEDLEY_UNPREDICTABLE
22863 #undef JSON_HEDLEY_UNREACHABLE
22864 #undef JSON_HEDLEY_UNREACHABLE_RETURN
22865 #undef JSON_HEDLEY_VERSION
22866 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
22867 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
22868 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
22869 #undef JSON_HEDLEY_VERSION_ENCODE
22870 #undef JSON_HEDLEY_WARNING
22871 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
22872 
22873 
22874 
22875 #endif // INCLUDE_NLOHMANN_JSON_HPP_