gitweb.ps.run Git - autorec/blob - src/json.hpp

   1 /*
   2     __ _____ _____ _____
   3  __|  |   __|     |   | |  JSON for Modern C++
   4 |  |  |__   |  |  | | | |  version 3.10.5
   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-2022 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 /****************************************************************************\
  31  * Note on documentation: The source files contain links to the online      *
  32  * documentation of the public API at https://json.nlohmann.me. This URL    *
  33  * contains the most recent documentation and should also be applicable to  *
  34  * previous versions; documentation for deprecated functions is not         *
  35  * removed, but marked deprecated. See "Generate documentation" section in  *
  36  * file doc/README.md.                                                      *
  37 \****************************************************************************/
  38
  39 #ifndef INCLUDE_NLOHMANN_JSON_HPP_
  40 #define INCLUDE_NLOHMANN_JSON_HPP_
  41
  42 #define NLOHMANN_JSON_VERSION_MAJOR 3
  43 #define NLOHMANN_JSON_VERSION_MINOR 10
  44 #define NLOHMANN_JSON_VERSION_PATCH 5
  45
  46 #include <algorithm> // all_of, find, for_each
  47 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
  48 #include <functional> // hash, less
  49 #include <initializer_list> // initializer_list
  50 #ifndef JSON_NO_IO
  51     #include <iosfwd> // istream, ostream
  52 #endif  // JSON_NO_IO
  53 #include <iterator> // random_access_iterator_tag
  54 #include <memory> // unique_ptr
  55 #include <numeric> // accumulate
  56 #include <string> // string, stoi, to_string
  57 #include <utility> // declval, forward, move, pair, swap
  58 #include <vector> // vector
  59
  60 // #include <nlohmann/adl_serializer.hpp>
  61
  62
  63 #include <type_traits>
  64 #include <utility>
  65
  66 // #include <nlohmann/detail/conversions/from_json.hpp>
  67
  68
  69 #include <algorithm> // transform
  70 #include <array> // array
  71 #include <forward_list> // forward_list
  72 #include <iterator> // inserter, front_inserter, end
  73 #include <map> // map
  74 #include <string> // string
  75 #include <tuple> // tuple, make_tuple
  76 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
  77 #include <unordered_map> // unordered_map
  78 #include <utility> // pair, declval
  79 #include <valarray> // valarray
  80
  81 // #include <nlohmann/detail/exceptions.hpp>
  82
  83
  84 #include <exception> // exception
  85 #include <stdexcept> // runtime_error
  86 #include <string> // to_string
  87 #include <vector> // vector
  88
  89 // #include <nlohmann/detail/value_t.hpp>
  90
  91
  92 #include <array> // array
  93 #include <cstddef> // size_t
  94 #include <cstdint> // uint8_t
  95 #include <string> // string
  96
  97 namespace nlohmann
  98 {
  99 namespace detail
 100 {
 101 ///////////////////////////
 102 // JSON type enumeration //
 103 ///////////////////////////
 104
 105 /*!
 106 @brief the JSON type enumeration
 107
 108 This enumeration collects the different JSON types. It is internally used to
 109 distinguish the stored values, and the functions @ref basic_json::is_null(),
 110 @ref basic_json::is_object(), @ref basic_json::is_array(),
 111 @ref basic_json::is_string(), @ref basic_json::is_boolean(),
 112 @ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
 113 @ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
 114 @ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
 115 @ref basic_json::is_structured() rely on it.
 116
 117 @note There are three enumeration entries (number_integer, number_unsigned, and
 118 number_float), because the library distinguishes these three types for numbers:
 119 @ref basic_json::number_unsigned_t is used for unsigned integers,
 120 @ref basic_json::number_integer_t is used for signed integers, and
 121 @ref basic_json::number_float_t is used for floating-point numbers or to
 122 approximate integers which do not fit in the limits of their respective type.
 123
 124 @sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
 125 value with the default value for a given type
 126
 127 @since version 1.0.0
 128 */
 129 enum class value_t : std::uint8_t
 130 {
 131     null,             ///< null value
 132     object,           ///< object (unordered set of name/value pairs)
 133     array,            ///< array (ordered collection of values)
 134     string,           ///< string value
 135     boolean,          ///< boolean value
 136     number_integer,   ///< number value (signed integer)
 137     number_unsigned,  ///< number value (unsigned integer)
 138     number_float,     ///< number value (floating-point)
 139     binary,           ///< binary array (ordered collection of bytes)
 140     discarded         ///< discarded by the parser callback function
 141 };
 142
 143 /*!
 144 @brief comparison operator for JSON types
 145
 146 Returns an ordering that is similar to Python:
 147 - order: null < boolean < number < object < array < string < binary
 148 - furthermore, each type is not smaller than itself
 149 - discarded values are not comparable
 150 - binary is represented as a b"" string in python and directly comparable to a
 151   string; however, making a binary array directly comparable with a string would
 152   be surprising behavior in a JSON file.
 153
 154 @since version 1.0.0
 155 */
 156 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
 157 {
 158     static constexpr std::array<std::uint8_t, 9> order = {{
 159             0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
 160             1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
 161             6 /* binary */
 162         }
 163     };
 164
 165     const auto l_index = static_cast<std::size_t>(lhs);
 166     const auto r_index = static_cast<std::size_t>(rhs);
 167     return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
 168 }
 169 }  // namespace detail
 170 }  // namespace nlohmann
 171
 172 // #include <nlohmann/detail/string_escape.hpp>
 173
 174
 175 #include <string>
 176 // #include <nlohmann/detail/macro_scope.hpp>
 177
 178
 179 #include <utility> // declval, pair
 180 // #include <nlohmann/thirdparty/hedley/hedley.hpp>
 181
 182
 183 /* Hedley - https://nemequ.github.io/hedley
 184  * Created by Evan Nemerson <evan@nemerson.com>
 185  *
 186  * To the extent possible under law, the author(s) have dedicated all
 187  * copyright and related and neighboring rights to this software to
 188  * the public domain worldwide. This software is distributed without
 189  * any warranty.
 190  *
 191  * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 192  * SPDX-License-Identifier: CC0-1.0
 193  */
 194
 195 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
 196 #if defined(JSON_HEDLEY_VERSION)
 197     #undef JSON_HEDLEY_VERSION
 198 #endif
 199 #define JSON_HEDLEY_VERSION 15
 200
 201 #if defined(JSON_HEDLEY_STRINGIFY_EX)
 202     #undef JSON_HEDLEY_STRINGIFY_EX
 203 #endif
 204 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
 205
 206 #if defined(JSON_HEDLEY_STRINGIFY)
 207     #undef JSON_HEDLEY_STRINGIFY
 208 #endif
 209 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
 210
 211 #if defined(JSON_HEDLEY_CONCAT_EX)
 212     #undef JSON_HEDLEY_CONCAT_EX
 213 #endif
 214 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
 215
 216 #if defined(JSON_HEDLEY_CONCAT)
 217     #undef JSON_HEDLEY_CONCAT
 218 #endif
 219 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
 220
 221 #if defined(JSON_HEDLEY_CONCAT3_EX)
 222     #undef JSON_HEDLEY_CONCAT3_EX
 223 #endif
 224 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
 225
 226 #if defined(JSON_HEDLEY_CONCAT3)
 227     #undef JSON_HEDLEY_CONCAT3
 228 #endif
 229 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
 230
 231 #if defined(JSON_HEDLEY_VERSION_ENCODE)
 232     #undef JSON_HEDLEY_VERSION_ENCODE
 233 #endif
 234 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
 235
 236 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
 237     #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
 238 #endif
 239 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
 240
 241 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
 242     #undef JSON_HEDLEY_VERSION_DECODE_MINOR
 243 #endif
 244 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
 245
 246 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
 247     #undef JSON_HEDLEY_VERSION_DECODE_REVISION
 248 #endif
 249 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
 250
 251 #if defined(JSON_HEDLEY_GNUC_VERSION)
 252     #undef JSON_HEDLEY_GNUC_VERSION
 253 #endif
 254 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
 255     #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 256 #elif defined(__GNUC__)
 257     #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
 258 #endif
 259
 260 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
 261     #undef JSON_HEDLEY_GNUC_VERSION_CHECK
 262 #endif
 263 #if defined(JSON_HEDLEY_GNUC_VERSION)
 264     #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 265 #else
 266     #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
 267 #endif
 268
 269 #if defined(JSON_HEDLEY_MSVC_VERSION)
 270     #undef JSON_HEDLEY_MSVC_VERSION
 271 #endif
 272 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
 273     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
 274 #elif defined(_MSC_FULL_VER) && !defined(__ICL)
 275     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
 276 #elif defined(_MSC_VER) && !defined(__ICL)
 277     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
 278 #endif
 279
 280 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
 281     #undef JSON_HEDLEY_MSVC_VERSION_CHECK
 282 #endif
 283 #if !defined(JSON_HEDLEY_MSVC_VERSION)
 284     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
 285 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
 286     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
 287 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
 288     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
 289 #else
 290     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
 291 #endif
 292
 293 #if defined(JSON_HEDLEY_INTEL_VERSION)
 294     #undef JSON_HEDLEY_INTEL_VERSION
 295 #endif
 296 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
 297     #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
 298 #elif defined(__INTEL_COMPILER) && !defined(__ICL)
 299     #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
 300 #endif
 301
 302 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
 303     #undef JSON_HEDLEY_INTEL_VERSION_CHECK
 304 #endif
 305 #if defined(JSON_HEDLEY_INTEL_VERSION)
 306     #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 307 #else
 308     #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
 309 #endif
 310
 311 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
 312     #undef JSON_HEDLEY_INTEL_CL_VERSION
 313 #endif
 314 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
 315     #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
 316 #endif
 317
 318 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
 319     #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
 320 #endif
 321 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
 322     #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 323 #else
 324     #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
 325 #endif
 326
 327 #if defined(JSON_HEDLEY_PGI_VERSION)
 328     #undef JSON_HEDLEY_PGI_VERSION
 329 #endif
 330 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
 331     #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
 332 #endif
 333
 334 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
 335     #undef JSON_HEDLEY_PGI_VERSION_CHECK
 336 #endif
 337 #if defined(JSON_HEDLEY_PGI_VERSION)
 338     #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 339 #else
 340     #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
 341 #endif
 342
 343 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
 344     #undef JSON_HEDLEY_SUNPRO_VERSION
 345 #endif
 346 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
 347     #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)
 348 #elif defined(__SUNPRO_C)
 349     #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
 350 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
 351     #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)
 352 #elif defined(__SUNPRO_CC)
 353     #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
 354 #endif
 355
 356 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
 357     #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
 358 #endif
 359 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
 360     #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 361 #else
 362     #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
 363 #endif
 364
 365 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
 366     #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
 367 #endif
 368 #if defined(__EMSCRIPTEN__)
 369     #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
 370 #endif
 371
 372 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
 373     #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
 374 #endif
 375 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
 376     #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 377 #else
 378     #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
 379 #endif
 380
 381 #if defined(JSON_HEDLEY_ARM_VERSION)
 382     #undef JSON_HEDLEY_ARM_VERSION
 383 #endif
 384 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
 385     #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
 386 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
 387     #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
 388 #endif
 389
 390 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
 391     #undef JSON_HEDLEY_ARM_VERSION_CHECK
 392 #endif
 393 #if defined(JSON_HEDLEY_ARM_VERSION)
 394     #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 395 #else
 396     #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
 397 #endif
 398
 399 #if defined(JSON_HEDLEY_IBM_VERSION)
 400     #undef JSON_HEDLEY_IBM_VERSION
 401 #endif
 402 #if defined(__ibmxl__)
 403     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
 404 #elif defined(__xlC__) && defined(__xlC_ver__)
 405     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
 406 #elif defined(__xlC__)
 407     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
 408 #endif
 409
 410 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
 411     #undef JSON_HEDLEY_IBM_VERSION_CHECK
 412 #endif
 413 #if defined(JSON_HEDLEY_IBM_VERSION)
 414     #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 415 #else
 416     #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
 417 #endif
 418
 419 #if defined(JSON_HEDLEY_TI_VERSION)
 420     #undef JSON_HEDLEY_TI_VERSION
 421 #endif
 422 #if \
 423     defined(__TI_COMPILER_VERSION__) && \
 424     ( \
 425       defined(__TMS470__) || defined(__TI_ARM__) || \
 426       defined(__MSP430__) || \
 427       defined(__TMS320C2000__) \
 428     )
 429 #if (__TI_COMPILER_VERSION__ >= 16000000)
 430     #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 431 #endif
 432 #endif
 433
 434 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
 435     #undef JSON_HEDLEY_TI_VERSION_CHECK
 436 #endif
 437 #if defined(JSON_HEDLEY_TI_VERSION)
 438     #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 439 #else
 440     #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
 441 #endif
 442
 443 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
 444     #undef JSON_HEDLEY_TI_CL2000_VERSION
 445 #endif
 446 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
 447     #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 448 #endif
 449
 450 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
 451     #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
 452 #endif
 453 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
 454     #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 455 #else
 456     #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
 457 #endif
 458
 459 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
 460     #undef JSON_HEDLEY_TI_CL430_VERSION
 461 #endif
 462 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
 463     #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 464 #endif
 465
 466 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
 467     #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
 468 #endif
 469 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
 470     #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 471 #else
 472     #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
 473 #endif
 474
 475 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
 476     #undef JSON_HEDLEY_TI_ARMCL_VERSION
 477 #endif
 478 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
 479     #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 480 #endif
 481
 482 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
 483     #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
 484 #endif
 485 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
 486     #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 487 #else
 488     #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
 489 #endif
 490
 491 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
 492     #undef JSON_HEDLEY_TI_CL6X_VERSION
 493 #endif
 494 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
 495     #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 496 #endif
 497
 498 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
 499     #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
 500 #endif
 501 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
 502     #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 503 #else
 504     #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
 505 #endif
 506
 507 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
 508     #undef JSON_HEDLEY_TI_CL7X_VERSION
 509 #endif
 510 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
 511     #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 512 #endif
 513
 514 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
 515     #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
 516 #endif
 517 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
 518     #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 519 #else
 520     #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
 521 #endif
 522
 523 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
 524     #undef JSON_HEDLEY_TI_CLPRU_VERSION
 525 #endif
 526 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
 527     #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 528 #endif
 529
 530 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
 531     #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
 532 #endif
 533 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
 534     #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 535 #else
 536     #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
 537 #endif
 538
 539 #if defined(JSON_HEDLEY_CRAY_VERSION)
 540     #undef JSON_HEDLEY_CRAY_VERSION
 541 #endif
 542 #if defined(_CRAYC)
 543     #if defined(_RELEASE_PATCHLEVEL)
 544         #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
 545     #else
 546         #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
 547     #endif
 548 #endif
 549
 550 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
 551     #undef JSON_HEDLEY_CRAY_VERSION_CHECK
 552 #endif
 553 #if defined(JSON_HEDLEY_CRAY_VERSION)
 554     #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 555 #else
 556     #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
 557 #endif
 558
 559 #if defined(JSON_HEDLEY_IAR_VERSION)
 560     #undef JSON_HEDLEY_IAR_VERSION
 561 #endif
 562 #if defined(__IAR_SYSTEMS_ICC__)
 563     #if __VER__ > 1000
 564         #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
 565     #else
 566         #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
 567     #endif
 568 #endif
 569
 570 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
 571     #undef JSON_HEDLEY_IAR_VERSION_CHECK
 572 #endif
 573 #if defined(JSON_HEDLEY_IAR_VERSION)
 574     #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 575 #else
 576     #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
 577 #endif
 578
 579 #if defined(JSON_HEDLEY_TINYC_VERSION)
 580     #undef JSON_HEDLEY_TINYC_VERSION
 581 #endif
 582 #if defined(__TINYC__)
 583     #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
 584 #endif
 585
 586 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
 587     #undef JSON_HEDLEY_TINYC_VERSION_CHECK
 588 #endif
 589 #if defined(JSON_HEDLEY_TINYC_VERSION)
 590     #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 591 #else
 592     #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
 593 #endif
 594
 595 #if defined(JSON_HEDLEY_DMC_VERSION)
 596     #undef JSON_HEDLEY_DMC_VERSION
 597 #endif
 598 #if defined(__DMC__)
 599     #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
 600 #endif
 601
 602 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
 603     #undef JSON_HEDLEY_DMC_VERSION_CHECK
 604 #endif
 605 #if defined(JSON_HEDLEY_DMC_VERSION)
 606     #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 607 #else
 608     #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
 609 #endif
 610
 611 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
 612     #undef JSON_HEDLEY_COMPCERT_VERSION
 613 #endif
 614 #if defined(__COMPCERT_VERSION__)
 615     #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
 616 #endif
 617
 618 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
 619     #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
 620 #endif
 621 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
 622     #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 623 #else
 624     #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
 625 #endif
 626
 627 #if defined(JSON_HEDLEY_PELLES_VERSION)
 628     #undef JSON_HEDLEY_PELLES_VERSION
 629 #endif
 630 #if defined(__POCC__)
 631     #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
 632 #endif
 633
 634 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
 635     #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 636 #endif
 637 #if defined(JSON_HEDLEY_PELLES_VERSION)
 638     #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 639 #else
 640     #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
 641 #endif
 642
 643 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
 644     #undef JSON_HEDLEY_MCST_LCC_VERSION
 645 #endif
 646 #if defined(__LCC__) && defined(__LCC_MINOR__)
 647     #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
 648 #endif
 649
 650 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
 651     #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
 652 #endif
 653 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
 654     #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 655 #else
 656     #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
 657 #endif
 658
 659 #if defined(JSON_HEDLEY_GCC_VERSION)
 660     #undef JSON_HEDLEY_GCC_VERSION
 661 #endif
 662 #if \
 663     defined(JSON_HEDLEY_GNUC_VERSION) && \
 664     !defined(__clang__) && \
 665     !defined(JSON_HEDLEY_INTEL_VERSION) && \
 666     !defined(JSON_HEDLEY_PGI_VERSION) && \
 667     !defined(JSON_HEDLEY_ARM_VERSION) && \
 668     !defined(JSON_HEDLEY_CRAY_VERSION) && \
 669     !defined(JSON_HEDLEY_TI_VERSION) && \
 670     !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
 671     !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
 672     !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
 673     !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
 674     !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
 675     !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
 676     !defined(__COMPCERT__) && \
 677     !defined(JSON_HEDLEY_MCST_LCC_VERSION)
 678     #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
 679 #endif
 680
 681 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
 682     #undef JSON_HEDLEY_GCC_VERSION_CHECK
 683 #endif
 684 #if defined(JSON_HEDLEY_GCC_VERSION)
 685     #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 686 #else
 687     #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
 688 #endif
 689
 690 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
 691     #undef JSON_HEDLEY_HAS_ATTRIBUTE
 692 #endif
 693 #if \
 694   defined(__has_attribute) && \
 695   ( \
 696     (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
 697   )
 698 #  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
 699 #else
 700 #  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
 701 #endif
 702
 703 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
 704     #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
 705 #endif
 706 #if defined(__has_attribute)
 707     #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
 708 #else
 709     #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 710 #endif
 711
 712 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
 713     #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
 714 #endif
 715 #if defined(__has_attribute)
 716     #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
 717 #else
 718     #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 719 #endif
 720
 721 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
 722     #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
 723 #endif
 724 #if \
 725     defined(__has_cpp_attribute) && \
 726     defined(__cplusplus) && \
 727     (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
 728     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
 729 #else
 730     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
 731 #endif
 732
 733 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
 734     #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
 735 #endif
 736 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
 737     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
 738 #elif \
 739     !defined(JSON_HEDLEY_PGI_VERSION) && \
 740     !defined(JSON_HEDLEY_IAR_VERSION) && \
 741     (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
 742     (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
 743     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
 744 #else
 745     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
 746 #endif
 747
 748 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
 749     #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
 750 #endif
 751 #if defined(__has_cpp_attribute) && defined(__cplusplus)
 752     #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
 753 #else
 754     #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 755 #endif
 756
 757 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
 758     #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
 759 #endif
 760 #if defined(__has_cpp_attribute) && defined(__cplusplus)
 761     #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
 762 #else
 763     #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 764 #endif
 765
 766 #if defined(JSON_HEDLEY_HAS_BUILTIN)
 767     #undef JSON_HEDLEY_HAS_BUILTIN
 768 #endif
 769 #if defined(__has_builtin)
 770     #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
 771 #else
 772     #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
 773 #endif
 774
 775 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
 776     #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
 777 #endif
 778 #if defined(__has_builtin)
 779     #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
 780 #else
 781     #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 782 #endif
 783
 784 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
 785     #undef JSON_HEDLEY_GCC_HAS_BUILTIN
 786 #endif
 787 #if defined(__has_builtin)
 788     #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
 789 #else
 790     #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 791 #endif
 792
 793 #if defined(JSON_HEDLEY_HAS_FEATURE)
 794     #undef JSON_HEDLEY_HAS_FEATURE
 795 #endif
 796 #if defined(__has_feature)
 797     #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
 798 #else
 799     #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
 800 #endif
 801
 802 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
 803     #undef JSON_HEDLEY_GNUC_HAS_FEATURE
 804 #endif
 805 #if defined(__has_feature)
 806     #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
 807 #else
 808     #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 809 #endif
 810
 811 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
 812     #undef JSON_HEDLEY_GCC_HAS_FEATURE
 813 #endif
 814 #if defined(__has_feature)
 815     #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
 816 #else
 817     #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 818 #endif
 819
 820 #if defined(JSON_HEDLEY_HAS_EXTENSION)
 821     #undef JSON_HEDLEY_HAS_EXTENSION
 822 #endif
 823 #if defined(__has_extension)
 824     #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
 825 #else
 826     #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
 827 #endif
 828
 829 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
 830     #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
 831 #endif
 832 #if defined(__has_extension)
 833     #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
 834 #else
 835     #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 836 #endif
 837
 838 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
 839     #undef JSON_HEDLEY_GCC_HAS_EXTENSION
 840 #endif
 841 #if defined(__has_extension)
 842     #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
 843 #else
 844     #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 845 #endif
 846
 847 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
 848     #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
 849 #endif
 850 #if defined(__has_declspec_attribute)
 851     #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
 852 #else
 853     #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
 854 #endif
 855
 856 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
 857     #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
 858 #endif
 859 #if defined(__has_declspec_attribute)
 860     #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
 861 #else
 862     #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 863 #endif
 864
 865 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
 866     #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
 867 #endif
 868 #if defined(__has_declspec_attribute)
 869     #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
 870 #else
 871     #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 872 #endif
 873
 874 #if defined(JSON_HEDLEY_HAS_WARNING)
 875     #undef JSON_HEDLEY_HAS_WARNING
 876 #endif
 877 #if defined(__has_warning)
 878     #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
 879 #else
 880     #define JSON_HEDLEY_HAS_WARNING(warning) (0)
 881 #endif
 882
 883 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
 884     #undef JSON_HEDLEY_GNUC_HAS_WARNING
 885 #endif
 886 #if defined(__has_warning)
 887     #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
 888 #else
 889     #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 890 #endif
 891
 892 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
 893     #undef JSON_HEDLEY_GCC_HAS_WARNING
 894 #endif
 895 #if defined(__has_warning)
 896     #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
 897 #else
 898     #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 899 #endif
 900
 901 #if \
 902     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
 903     defined(__clang__) || \
 904     JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
 905     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
 906     JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
 907     JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
 908     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
 909     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
 910     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
 911     JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
 912     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
 913     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
 914     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
 915     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
 916     JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
 917     JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
 918     JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
 919     (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
 920     #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
 921 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
 922     #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
 923 #else
 924     #define JSON_HEDLEY_PRAGMA(value)
 925 #endif
 926
 927 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
 928     #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
 929 #endif
 930 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
 931     #undef JSON_HEDLEY_DIAGNOSTIC_POP
 932 #endif
 933 #if defined(__clang__)
 934     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
 935     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
 936 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
 937     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
 938     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
 939 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
 940     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
 941     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
 942 #elif \
 943     JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
 944     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
 945     #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
 946     #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
 947 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
 948     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
 949     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
 950 #elif \
 951     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
 952     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
 953     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
 954     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
 955     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
 956     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
 957     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
 958     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
 959 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
 960     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
 961     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
 962 #else
 963     #define JSON_HEDLEY_DIAGNOSTIC_PUSH
 964     #define JSON_HEDLEY_DIAGNOSTIC_POP
 965 #endif
 966
 967 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
 968    HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
 969 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
 970     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
 971 #endif
 972 #if defined(__cplusplus)
 973 #  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
 974 #    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
 975 #      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
 976 #        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
 977     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 978     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
 979     _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
 980     _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
 981     xpr \
 982     JSON_HEDLEY_DIAGNOSTIC_POP
 983 #      else
 984 #        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
 985     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 986     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
 987     _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
 988     xpr \
 989     JSON_HEDLEY_DIAGNOSTIC_POP
 990 #      endif
 991 #    else
 992 #      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
 993     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 994     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
 995     xpr \
 996     JSON_HEDLEY_DIAGNOSTIC_POP
 997 #    endif
 998 #  endif
 999 #endif
1000 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
1001     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
1002 #endif
1003
1004 #if defined(JSON_HEDLEY_CONST_CAST)
1005     #undef JSON_HEDLEY_CONST_CAST
1006 #endif
1007 #if defined(__cplusplus)
1008 #  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1009 #elif \
1010   JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1011   JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1012   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1013 #  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1014         JSON_HEDLEY_DIAGNOSTIC_PUSH \
1015         JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1016         ((T) (expr)); \
1017         JSON_HEDLEY_DIAGNOSTIC_POP \
1018     }))
1019 #else
1020 #  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1021 #endif
1022
1023 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
1024     #undef JSON_HEDLEY_REINTERPRET_CAST
1025 #endif
1026 #if defined(__cplusplus)
1027     #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1028 #else
1029     #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
1030 #endif
1031
1032 #if defined(JSON_HEDLEY_STATIC_CAST)
1033     #undef JSON_HEDLEY_STATIC_CAST
1034 #endif
1035 #if defined(__cplusplus)
1036     #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1037 #else
1038     #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1039 #endif
1040
1041 #if defined(JSON_HEDLEY_CPP_CAST)
1042     #undef JSON_HEDLEY_CPP_CAST
1043 #endif
1044 #if defined(__cplusplus)
1045 #  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
1046 #    define JSON_HEDLEY_CPP_CAST(T, expr) \
1047     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1048     _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
1049     ((T) (expr)) \
1050     JSON_HEDLEY_DIAGNOSTIC_POP
1051 #  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
1052 #    define JSON_HEDLEY_CPP_CAST(T, expr) \
1053     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1054     _Pragma("diag_suppress=Pe137") \
1055     JSON_HEDLEY_DIAGNOSTIC_POP
1056 #  else
1057 #    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
1058 #  endif
1059 #else
1060 #  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1061 #endif
1062
1063 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
1064     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1065 #endif
1066 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
1067     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
1068 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1069     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
1070 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1071     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
1072 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1073     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
1074 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1075     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1076 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1077     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1078 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1079     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
1080 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1081     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
1082 #elif \
1083     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1084     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1085     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1086     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1087     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1088     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1089     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1090     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1091     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1092     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1093     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1094     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
1095 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
1096     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
1097 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
1098     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
1099 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1100     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
1101 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
1102     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
1103 #else
1104     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
1105 #endif
1106
1107 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
1108     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1109 #endif
1110 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1111     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
1112 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1113     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
1114 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1115     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
1116 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1117     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
1118 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
1119     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
1120 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1121     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
1122 #elif \
1123     JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
1124     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1125     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1126     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1127     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1128 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
1129     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
1130 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1131     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1132 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1133     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
1134 #else
1135     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1136 #endif
1137
1138 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1139     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1140 #endif
1141 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1142     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1143 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1144     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1145 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1146     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1147 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1148     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
1149 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1150     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1151 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
1152     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
1153 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1154     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1155 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1156     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1157 #elif \
1158     JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1159     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1160     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1161     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1162 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1163     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1164 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1165     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1166 #else
1167     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1168 #endif
1169
1170 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1171     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1172 #endif
1173 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1174     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1175 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1176     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1177 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1178     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1179 #else
1180     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1181 #endif
1182
1183 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1184     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1185 #endif
1186 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1187     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1188 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1189     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1190 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1191     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1192 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1193     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1194 #else
1195     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1196 #endif
1197
1198 #if defined(JSON_HEDLEY_DEPRECATED)
1199     #undef JSON_HEDLEY_DEPRECATED
1200 #endif
1201 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1202     #undef JSON_HEDLEY_DEPRECATED_FOR
1203 #endif
1204 #if \
1205     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1206     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1207     #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1208     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1209 #elif \
1210     (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1211     JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1212     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1213     JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1214     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1215     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1216     JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1217     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1218     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1219     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1220     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1221     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1222     #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1223     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1224 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1225     #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1226     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1227 #elif \
1228     JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1229     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1230     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1231     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1232     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1233     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1234     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1235     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1236     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1237     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1238     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1239     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1240     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1241     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1242     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1243     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1244     #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1245     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1246 #elif \
1247     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1248     JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1249     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1250     #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1251     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1252 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1253     #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1254     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1255 #else
1256     #define JSON_HEDLEY_DEPRECATED(since)
1257     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1258 #endif
1259
1260 #if defined(JSON_HEDLEY_UNAVAILABLE)
1261     #undef JSON_HEDLEY_UNAVAILABLE
1262 #endif
1263 #if \
1264     JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1265     JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1266     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1267     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1268     #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1269 #else
1270     #define JSON_HEDLEY_UNAVAILABLE(available_since)
1271 #endif
1272
1273 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1274     #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1275 #endif
1276 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1277     #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1278 #endif
1279 #if \
1280     JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1281     JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1282     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1283     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1284     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1285     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1286     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1287     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1288     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1289     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1290     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1291     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1292     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1293     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1294     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1295     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1296     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1297     #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1298     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1299 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1300     #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1301     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1302 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1303     #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1304     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1305 #elif defined(_Check_return_) /* SAL */
1306     #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1307     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1308 #else
1309     #define JSON_HEDLEY_WARN_UNUSED_RESULT
1310     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1311 #endif
1312
1313 #if defined(JSON_HEDLEY_SENTINEL)
1314     #undef JSON_HEDLEY_SENTINEL
1315 #endif
1316 #if \
1317     JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1318     JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1319     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1320     JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1321     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1322     #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1323 #else
1324     #define JSON_HEDLEY_SENTINEL(position)
1325 #endif
1326
1327 #if defined(JSON_HEDLEY_NO_RETURN)
1328     #undef JSON_HEDLEY_NO_RETURN
1329 #endif
1330 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1331     #define JSON_HEDLEY_NO_RETURN __noreturn
1332 #elif \
1333     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1334     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1335     #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1336 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1337     #define JSON_HEDLEY_NO_RETURN _Noreturn
1338 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1339     #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1340 #elif \
1341     JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1342     JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1343     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1344     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1345     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1346     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1347     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1348     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1349     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1350     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1351     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1352     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1353     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1354     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1355     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1356     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1357     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1358     #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1359 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1360     #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1361 #elif \
1362     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1363     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1364     #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1365 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1366     #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1367 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1368     #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1369 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1370     #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1371 #else
1372     #define JSON_HEDLEY_NO_RETURN
1373 #endif
1374
1375 #if defined(JSON_HEDLEY_NO_ESCAPE)
1376     #undef JSON_HEDLEY_NO_ESCAPE
1377 #endif
1378 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1379     #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1380 #else
1381     #define JSON_HEDLEY_NO_ESCAPE
1382 #endif
1383
1384 #if defined(JSON_HEDLEY_UNREACHABLE)
1385     #undef JSON_HEDLEY_UNREACHABLE
1386 #endif
1387 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1388     #undef JSON_HEDLEY_UNREACHABLE_RETURN
1389 #endif
1390 #if defined(JSON_HEDLEY_ASSUME)
1391     #undef JSON_HEDLEY_ASSUME
1392 #endif
1393 #if \
1394     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1395     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1396     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1397     #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1398 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1399     #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1400 #elif \
1401     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1402     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1403     #if defined(__cplusplus)
1404         #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1405     #else
1406         #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1407     #endif
1408 #endif
1409 #if \
1410     (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1411     JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1412     JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1413     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1414     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1415     JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1416     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1417     #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1418 #elif defined(JSON_HEDLEY_ASSUME)
1419     #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1420 #endif
1421 #if !defined(JSON_HEDLEY_ASSUME)
1422     #if defined(JSON_HEDLEY_UNREACHABLE)
1423         #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1424     #else
1425         #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1426     #endif
1427 #endif
1428 #if defined(JSON_HEDLEY_UNREACHABLE)
1429     #if  \
1430         JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1431         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1432         #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1433     #else
1434         #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1435     #endif
1436 #else
1437     #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1438 #endif
1439 #if !defined(JSON_HEDLEY_UNREACHABLE)
1440     #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1441 #endif
1442
1443 JSON_HEDLEY_DIAGNOSTIC_PUSH
1444 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1445     #pragma clang diagnostic ignored "-Wpedantic"
1446 #endif
1447 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1448     #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1449 #endif
1450 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1451     #if defined(__clang__)
1452         #pragma clang diagnostic ignored "-Wvariadic-macros"
1453     #elif defined(JSON_HEDLEY_GCC_VERSION)
1454         #pragma GCC diagnostic ignored "-Wvariadic-macros"
1455     #endif
1456 #endif
1457 #if defined(JSON_HEDLEY_NON_NULL)
1458     #undef JSON_HEDLEY_NON_NULL
1459 #endif
1460 #if \
1461     JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1462     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1463     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1464     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1465     #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1466 #else
1467     #define JSON_HEDLEY_NON_NULL(...)
1468 #endif
1469 JSON_HEDLEY_DIAGNOSTIC_POP
1470
1471 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1472     #undef JSON_HEDLEY_PRINTF_FORMAT
1473 #endif
1474 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1475     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1476 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1477     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1478 #elif \
1479     JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1480     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1481     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1482     JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1483     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1484     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1485     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1486     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1487     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1488     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1489     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1490     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1491     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1492     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1493     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1494     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1495     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1496     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1497 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1498     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1499 #else
1500     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1501 #endif
1502
1503 #if defined(JSON_HEDLEY_CONSTEXPR)
1504     #undef JSON_HEDLEY_CONSTEXPR
1505 #endif
1506 #if defined(__cplusplus)
1507     #if __cplusplus >= 201103L
1508         #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1509     #endif
1510 #endif
1511 #if !defined(JSON_HEDLEY_CONSTEXPR)
1512     #define JSON_HEDLEY_CONSTEXPR
1513 #endif
1514
1515 #if defined(JSON_HEDLEY_PREDICT)
1516     #undef JSON_HEDLEY_PREDICT
1517 #endif
1518 #if defined(JSON_HEDLEY_LIKELY)
1519     #undef JSON_HEDLEY_LIKELY
1520 #endif
1521 #if defined(JSON_HEDLEY_UNLIKELY)
1522     #undef JSON_HEDLEY_UNLIKELY
1523 #endif
1524 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1525     #undef JSON_HEDLEY_UNPREDICTABLE
1526 #endif
1527 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1528     #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1529 #endif
1530 #if \
1531   (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1532   JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1533   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1534 #  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
1535 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
1536 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
1537 #  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
1538 #  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
1539 #elif \
1540   (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1541   JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1542   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1543   (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1544   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1545   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1546   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1547   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1548   JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1549   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1550   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1551   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1552   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1553   JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1554   JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1555   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1556 #  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1557     (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1558 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1559     (__extension__ ({ \
1560         double hedley_probability_ = (probability); \
1561         ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1562     }))
1563 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1564     (__extension__ ({ \
1565         double hedley_probability_ = (probability); \
1566         ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1567     }))
1568 #  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
1569 #  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1570 #else
1571 #  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1572 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1573 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1574 #  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1575 #  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1576 #endif
1577 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1578     #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1579 #endif
1580
1581 #if defined(JSON_HEDLEY_MALLOC)
1582     #undef JSON_HEDLEY_MALLOC
1583 #endif
1584 #if \
1585     JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1586     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1587     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1588     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1589     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1590     JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1591     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1592     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1593     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1594     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1595     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1596     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1597     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1598     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1599     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1600     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1601     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1602     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1603     #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1604 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1605     #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1606 #elif \
1607     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1608     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1609     #define JSON_HEDLEY_MALLOC __declspec(restrict)
1610 #else
1611     #define JSON_HEDLEY_MALLOC
1612 #endif
1613
1614 #if defined(JSON_HEDLEY_PURE)
1615     #undef JSON_HEDLEY_PURE
1616 #endif
1617 #if \
1618   JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1619   JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1620   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1621   JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1622   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1623   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1624   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1625   (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1626   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1627   (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1628   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1629   (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1630   JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1631   (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1632   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1633   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1634   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1635   JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1636   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1637 #  define JSON_HEDLEY_PURE __attribute__((__pure__))
1638 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1639 #  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1640 #elif defined(__cplusplus) && \
1641     ( \
1642       JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1643       JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1644       JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1645     )
1646 #  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1647 #else
1648 #  define JSON_HEDLEY_PURE
1649 #endif
1650
1651 #if defined(JSON_HEDLEY_CONST)
1652     #undef JSON_HEDLEY_CONST
1653 #endif
1654 #if \
1655     JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1656     JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1657     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1658     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1659     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1660     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1661     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1662     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1663     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1664     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1665     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1666     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1667     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1668     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1669     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1670     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1671     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1672     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1673     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1674     #define JSON_HEDLEY_CONST __attribute__((__const__))
1675 #elif \
1676     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1677     #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1678 #else
1679     #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1680 #endif
1681
1682 #if defined(JSON_HEDLEY_RESTRICT)
1683     #undef JSON_HEDLEY_RESTRICT
1684 #endif
1685 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1686     #define JSON_HEDLEY_RESTRICT restrict
1687 #elif \
1688     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1689     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1690     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1691     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1692     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1693     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1694     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1695     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1696     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1697     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1698     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1699     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1700     JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1701     defined(__clang__) || \
1702     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1703     #define JSON_HEDLEY_RESTRICT __restrict
1704 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1705     #define JSON_HEDLEY_RESTRICT _Restrict
1706 #else
1707     #define JSON_HEDLEY_RESTRICT
1708 #endif
1709
1710 #if defined(JSON_HEDLEY_INLINE)
1711     #undef JSON_HEDLEY_INLINE
1712 #endif
1713 #if \
1714     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1715     (defined(__cplusplus) && (__cplusplus >= 199711L))
1716     #define JSON_HEDLEY_INLINE inline
1717 #elif \
1718     defined(JSON_HEDLEY_GCC_VERSION) || \
1719     JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1720     #define JSON_HEDLEY_INLINE __inline__
1721 #elif \
1722     JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1723     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1724     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1725     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1726     JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1727     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1728     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1729     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1730     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1731     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1732     #define JSON_HEDLEY_INLINE __inline
1733 #else
1734     #define JSON_HEDLEY_INLINE
1735 #endif
1736
1737 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1738     #undef JSON_HEDLEY_ALWAYS_INLINE
1739 #endif
1740 #if \
1741   JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1742   JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1743   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1744   JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1745   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1746   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1747   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1748   (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1749   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1750   (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1751   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1752   (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1753   JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1754   (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1755   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1756   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1757   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1758   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1759   JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1760 #  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1761 #elif \
1762   JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1763   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1764 #  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1765 #elif defined(__cplusplus) && \
1766     ( \
1767       JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1768       JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1769       JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1770       JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1771       JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1772       JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1773     )
1774 #  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1775 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1776 #  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1777 #else
1778 #  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1779 #endif
1780
1781 #if defined(JSON_HEDLEY_NEVER_INLINE)
1782     #undef JSON_HEDLEY_NEVER_INLINE
1783 #endif
1784 #if \
1785     JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1786     JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1787     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1788     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1789     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1790     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1791     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1792     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1793     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1794     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1795     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1796     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1797     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1798     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1799     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1800     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1801     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1802     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1803     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1804     #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1805 #elif \
1806     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1807     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1808     #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1809 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1810     #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1811 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1812     #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1813 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1814     #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1815 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1816     #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1817 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1818     #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1819 #else
1820     #define JSON_HEDLEY_NEVER_INLINE
1821 #endif
1822
1823 #if defined(JSON_HEDLEY_PRIVATE)
1824     #undef JSON_HEDLEY_PRIVATE
1825 #endif
1826 #if defined(JSON_HEDLEY_PUBLIC)
1827     #undef JSON_HEDLEY_PUBLIC
1828 #endif
1829 #if defined(JSON_HEDLEY_IMPORT)
1830     #undef JSON_HEDLEY_IMPORT
1831 #endif
1832 #if defined(_WIN32) || defined(__CYGWIN__)
1833 #  define JSON_HEDLEY_PRIVATE
1834 #  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
1835 #  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
1836 #else
1837 #  if \
1838     JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1839     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1840     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1841     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1842     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1843     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1844     ( \
1845       defined(__TI_EABI__) && \
1846       ( \
1847         (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1848         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1849       ) \
1850     ) || \
1851     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1852 #    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1853 #    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
1854 #  else
1855 #    define JSON_HEDLEY_PRIVATE
1856 #    define JSON_HEDLEY_PUBLIC
1857 #  endif
1858 #  define JSON_HEDLEY_IMPORT    extern
1859 #endif
1860
1861 #if defined(JSON_HEDLEY_NO_THROW)
1862     #undef JSON_HEDLEY_NO_THROW
1863 #endif
1864 #if \
1865     JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1866     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1867     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1868     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1869     #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1870 #elif \
1871     JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1872     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1873     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1874     #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1875 #else
1876     #define JSON_HEDLEY_NO_THROW
1877 #endif
1878
1879 #if defined(JSON_HEDLEY_FALL_THROUGH)
1880     #undef JSON_HEDLEY_FALL_THROUGH
1881 #endif
1882 #if \
1883     JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1884     JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
1885     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1886     #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1887 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1888     #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1889 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1890     #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1891 #elif defined(__fallthrough) /* SAL */
1892     #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1893 #else
1894     #define JSON_HEDLEY_FALL_THROUGH
1895 #endif
1896
1897 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1898     #undef JSON_HEDLEY_RETURNS_NON_NULL
1899 #endif
1900 #if \
1901     JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1902     JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1903     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1904     #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1905 #elif defined(_Ret_notnull_) /* SAL */
1906     #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1907 #else
1908     #define JSON_HEDLEY_RETURNS_NON_NULL
1909 #endif
1910
1911 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1912     #undef JSON_HEDLEY_ARRAY_PARAM
1913 #endif
1914 #if \
1915     defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1916     !defined(__STDC_NO_VLA__) && \
1917     !defined(__cplusplus) && \
1918     !defined(JSON_HEDLEY_PGI_VERSION) && \
1919     !defined(JSON_HEDLEY_TINYC_VERSION)
1920     #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1921 #else
1922     #define JSON_HEDLEY_ARRAY_PARAM(name)
1923 #endif
1924
1925 #if defined(JSON_HEDLEY_IS_CONSTANT)
1926     #undef JSON_HEDLEY_IS_CONSTANT
1927 #endif
1928 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1929     #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1930 #endif
1931 /* JSON_HEDLEY_IS_CONSTEXPR_ is for
1932    HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
1933 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1934     #undef JSON_HEDLEY_IS_CONSTEXPR_
1935 #endif
1936 #if \
1937     JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1938     JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1939     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1940     JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1941     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1942     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1943     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1944     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1945     JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1946     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1947     #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1948 #endif
1949 #if !defined(__cplusplus)
1950 #  if \
1951        JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1952        JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1953        JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1954        JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1955        JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1956        JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1957        JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1958 #if defined(__INTPTR_TYPE__)
1959     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1960 #else
1961     #include <stdint.h>
1962     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1963 #endif
1964 #  elif \
1965        ( \
1966           defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1967           !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1968           !defined(JSON_HEDLEY_PGI_VERSION) && \
1969           !defined(JSON_HEDLEY_IAR_VERSION)) || \
1970        (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1971        JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1972        JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1973        JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1974        JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1975 #if defined(__INTPTR_TYPE__)
1976     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1977 #else
1978     #include <stdint.h>
1979     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1980 #endif
1981 #  elif \
1982        defined(JSON_HEDLEY_GCC_VERSION) || \
1983        defined(JSON_HEDLEY_INTEL_VERSION) || \
1984        defined(JSON_HEDLEY_TINYC_VERSION) || \
1985        defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1986        JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1987        defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1988        defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1989        defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1990        defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1991        defined(__clang__)
1992 #    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1993         sizeof(void) != \
1994         sizeof(*( \
1995                   1 ? \
1996                   ((void*) ((expr) * 0L) ) : \
1997 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1998                 ) \
1999               ) \
2000                                             )
2001 #  endif
2002 #endif
2003 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
2004     #if !defined(JSON_HEDLEY_IS_CONSTANT)
2005         #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
2006     #endif
2007     #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
2008 #else
2009     #if !defined(JSON_HEDLEY_IS_CONSTANT)
2010         #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
2011     #endif
2012     #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
2013 #endif
2014
2015 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
2016     #undef JSON_HEDLEY_BEGIN_C_DECLS
2017 #endif
2018 #if defined(JSON_HEDLEY_END_C_DECLS)
2019     #undef JSON_HEDLEY_END_C_DECLS
2020 #endif
2021 #if defined(JSON_HEDLEY_C_DECL)
2022     #undef JSON_HEDLEY_C_DECL
2023 #endif
2024 #if defined(__cplusplus)
2025     #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
2026     #define JSON_HEDLEY_END_C_DECLS }
2027     #define JSON_HEDLEY_C_DECL extern "C"
2028 #else
2029     #define JSON_HEDLEY_BEGIN_C_DECLS
2030     #define JSON_HEDLEY_END_C_DECLS
2031     #define JSON_HEDLEY_C_DECL
2032 #endif
2033
2034 #if defined(JSON_HEDLEY_STATIC_ASSERT)
2035     #undef JSON_HEDLEY_STATIC_ASSERT
2036 #endif
2037 #if \
2038   !defined(__cplusplus) && ( \
2039       (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
2040       (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
2041       JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
2042       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
2043       defined(_Static_assert) \
2044     )
2045 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
2046 #elif \
2047   (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
2048   JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
2049   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2050 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
2051 #else
2052 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
2053 #endif
2054
2055 #if defined(JSON_HEDLEY_NULL)
2056     #undef JSON_HEDLEY_NULL
2057 #endif
2058 #if defined(__cplusplus)
2059     #if __cplusplus >= 201103L
2060         #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
2061     #elif defined(NULL)
2062         #define JSON_HEDLEY_NULL NULL
2063     #else
2064         #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
2065     #endif
2066 #elif defined(NULL)
2067     #define JSON_HEDLEY_NULL NULL
2068 #else
2069     #define JSON_HEDLEY_NULL ((void*) 0)
2070 #endif
2071
2072 #if defined(JSON_HEDLEY_MESSAGE)
2073     #undef JSON_HEDLEY_MESSAGE
2074 #endif
2075 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2076 #  define JSON_HEDLEY_MESSAGE(msg) \
2077     JSON_HEDLEY_DIAGNOSTIC_PUSH \
2078     JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2079     JSON_HEDLEY_PRAGMA(message msg) \
2080     JSON_HEDLEY_DIAGNOSTIC_POP
2081 #elif \
2082   JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
2083   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2084 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
2085 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
2086 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
2087 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
2088 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2089 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
2090 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
2091 #else
2092 #  define JSON_HEDLEY_MESSAGE(msg)
2093 #endif
2094
2095 #if defined(JSON_HEDLEY_WARNING)
2096     #undef JSON_HEDLEY_WARNING
2097 #endif
2098 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
2099 #  define JSON_HEDLEY_WARNING(msg) \
2100     JSON_HEDLEY_DIAGNOSTIC_PUSH \
2101     JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
2102     JSON_HEDLEY_PRAGMA(clang warning msg) \
2103     JSON_HEDLEY_DIAGNOSTIC_POP
2104 #elif \
2105   JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
2106   JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
2107   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
2108 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
2109 #elif \
2110   JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
2111   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2112 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
2113 #else
2114 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
2115 #endif
2116
2117 #if defined(JSON_HEDLEY_REQUIRE)
2118     #undef JSON_HEDLEY_REQUIRE
2119 #endif
2120 #if defined(JSON_HEDLEY_REQUIRE_MSG)
2121     #undef JSON_HEDLEY_REQUIRE_MSG
2122 #endif
2123 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
2124 #  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
2125 #    define JSON_HEDLEY_REQUIRE(expr) \
2126     JSON_HEDLEY_DIAGNOSTIC_PUSH \
2127     _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2128     __attribute__((diagnose_if(!(expr), #expr, "error"))) \
2129     JSON_HEDLEY_DIAGNOSTIC_POP
2130 #    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
2131     JSON_HEDLEY_DIAGNOSTIC_PUSH \
2132     _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
2133     __attribute__((diagnose_if(!(expr), msg, "error"))) \
2134     JSON_HEDLEY_DIAGNOSTIC_POP
2135 #  else
2136 #    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
2137 #    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
2138 #  endif
2139 #else
2140 #  define JSON_HEDLEY_REQUIRE(expr)
2141 #  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
2142 #endif
2143
2144 #if defined(JSON_HEDLEY_FLAGS)
2145     #undef JSON_HEDLEY_FLAGS
2146 #endif
2147 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
2148     #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
2149 #else
2150     #define JSON_HEDLEY_FLAGS
2151 #endif
2152
2153 #if defined(JSON_HEDLEY_FLAGS_CAST)
2154     #undef JSON_HEDLEY_FLAGS_CAST
2155 #endif
2156 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
2157 #  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
2158         JSON_HEDLEY_DIAGNOSTIC_PUSH \
2159         _Pragma("warning(disable:188)") \
2160         ((T) (expr)); \
2161         JSON_HEDLEY_DIAGNOSTIC_POP \
2162     }))
2163 #else
2164 #  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
2165 #endif
2166
2167 #if defined(JSON_HEDLEY_EMPTY_BASES)
2168     #undef JSON_HEDLEY_EMPTY_BASES
2169 #endif
2170 #if \
2171     (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
2172     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
2173     #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
2174 #else
2175     #define JSON_HEDLEY_EMPTY_BASES
2176 #endif
2177
2178 /* Remaining macros are deprecated. */
2179
2180 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2181     #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2182 #endif
2183 #if defined(__clang__)
2184     #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2185 #else
2186     #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2187 #endif
2188
2189 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2190     #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2191 #endif
2192 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2193
2194 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2195     #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2196 #endif
2197 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2198
2199 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2200     #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2201 #endif
2202 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2203
2204 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2205     #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2206 #endif
2207 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2208
2209 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2210     #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2211 #endif
2212 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2213
2214 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2215     #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2216 #endif
2217 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2218
2219 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2220     #undef JSON_HEDLEY_CLANG_HAS_WARNING
2221 #endif
2222 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2223
2224 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2225
2226 // #include <nlohmann/detail/meta/detected.hpp>
2227
2228
2229 #include <type_traits>
2230
2231 // #include <nlohmann/detail/meta/void_t.hpp>
2232
2233
2234 namespace nlohmann
2235 {
2236 namespace detail
2237 {
2238 template<typename ...Ts> struct make_void
2239 {
2240     using type = void;
2241 };
2242 template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
2243 } // namespace detail
2244 }  // namespace nlohmann
2245
2246
2247 // https://en.cppreference.com/w/cpp/experimental/is_detected
2248 namespace nlohmann
2249 {
2250 namespace detail
2251 {
2252 struct nonesuch
2253 {
2254     nonesuch() = delete;
2255     ~nonesuch() = delete;
2256     nonesuch(nonesuch const&) = delete;
2257     nonesuch(nonesuch const&&) = delete;
2258     void operator=(nonesuch const&) = delete;
2259     void operator=(nonesuch&&) = delete;
2260 };
2261
2262 template<class Default,
2263          class AlwaysVoid,
2264          template<class...> class Op,
2265          class... Args>
2266 struct detector
2267 {
2268     using value_t = std::false_type;
2269     using type = Default;
2270 };
2271
2272 template<class Default, template<class...> class Op, class... Args>
2273 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2274 {
2275     using value_t = std::true_type;
2276     using type = Op<Args...>;
2277 };
2278
2279 template<template<class...> class Op, class... Args>
2280 using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
2281
2282 template<template<class...> class Op, class... Args>
2283 struct is_detected_lazy : is_detected<Op, Args...> { };
2284
2285 template<template<class...> class Op, class... Args>
2286 using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
2287
2288 template<class Default, template<class...> class Op, class... Args>
2289 using detected_or = detector<Default, void, Op, Args...>;
2290
2291 template<class Default, template<class...> class Op, class... Args>
2292 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
2293
2294 template<class Expected, template<class...> class Op, class... Args>
2295 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2296
2297 template<class To, template<class...> class Op, class... Args>
2298 using is_detected_convertible =
2299     std::is_convertible<detected_t<Op, Args...>, To>;
2300 }  // namespace detail
2301 }  // namespace nlohmann
2302
2303
2304 // This file contains all internal macro definitions
2305 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2306
2307 // exclude unsupported compilers
2308 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2309     #if defined(__clang__)
2310         #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2311             #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2312         #endif
2313     #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2314         #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2315             #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2316         #endif
2317     #endif
2318 #endif
2319
2320 // C++ language standard detection
2321 // if the user manually specified the used c++ version this is skipped
2322 #if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
2323     #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2324         #define JSON_HAS_CPP_20
2325         #define JSON_HAS_CPP_17
2326         #define JSON_HAS_CPP_14
2327     #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2328         #define JSON_HAS_CPP_17
2329         #define JSON_HAS_CPP_14
2330     #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2331         #define JSON_HAS_CPP_14
2332     #endif
2333     // the cpp 11 flag is always specified because it is the minimal required version
2334     #define JSON_HAS_CPP_11
2335 #endif
2336
2337 #if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
2338     #ifdef JSON_HAS_CPP_17
2339         #if defined(__cpp_lib_filesystem)
2340             #define JSON_HAS_FILESYSTEM 1
2341         #elif defined(__cpp_lib_experimental_filesystem)
2342             #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2343         #elif !defined(__has_include)
2344             #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2345         #elif __has_include(<filesystem>)
2346             #define JSON_HAS_FILESYSTEM 1
2347         #elif __has_include(<experimental/filesystem>)
2348             #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
2349         #endif
2350
2351         // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
2352         #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
2353             #undef JSON_HAS_FILESYSTEM
2354             #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2355         #endif
2356
2357         // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
2358         #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
2359             #undef JSON_HAS_FILESYSTEM
2360             #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2361         #endif
2362
2363         // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
2364         #if defined(__clang_major__) && __clang_major__ < 7
2365             #undef JSON_HAS_FILESYSTEM
2366             #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2367         #endif
2368
2369         // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
2370         #if defined(_MSC_VER) && _MSC_VER < 1940
2371             #undef JSON_HAS_FILESYSTEM
2372             #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2373         #endif
2374
2375         // no filesystem support before iOS 13
2376         #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
2377             #undef JSON_HAS_FILESYSTEM
2378             #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2379         #endif
2380
2381         // no filesystem support before macOS Catalina
2382         #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
2383             #undef JSON_HAS_FILESYSTEM
2384             #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2385         #endif
2386     #endif
2387 #endif
2388
2389 #ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
2390     #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
2391 #endif
2392
2393 #ifndef JSON_HAS_FILESYSTEM
2394     #define JSON_HAS_FILESYSTEM 0
2395 #endif
2396
2397 // disable documentation warnings on clang
2398 #if defined(__clang__)
2399     #pragma clang diagnostic push
2400     #pragma clang diagnostic ignored "-Wdocumentation"
2401     #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
2402 #endif
2403
2404 // allow disabling exceptions
2405 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2406     #define JSON_THROW(exception) throw exception
2407     #define JSON_TRY try
2408     #define JSON_CATCH(exception) catch(exception)
2409     #define JSON_INTERNAL_CATCH(exception) catch(exception)
2410 #else
2411     #include <cstdlib>
2412     #define JSON_THROW(exception) std::abort()
2413     #define JSON_TRY if(true)
2414     #define JSON_CATCH(exception) if(false)
2415     #define JSON_INTERNAL_CATCH(exception) if(false)
2416 #endif
2417
2418 // override exception macros
2419 #if defined(JSON_THROW_USER)
2420     #undef JSON_THROW
2421     #define JSON_THROW JSON_THROW_USER
2422 #endif
2423 #if defined(JSON_TRY_USER)
2424     #undef JSON_TRY
2425     #define JSON_TRY JSON_TRY_USER
2426 #endif
2427 #if defined(JSON_CATCH_USER)
2428     #undef JSON_CATCH
2429     #define JSON_CATCH JSON_CATCH_USER
2430     #undef JSON_INTERNAL_CATCH
2431     #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2432 #endif
2433 #if defined(JSON_INTERNAL_CATCH_USER)
2434     #undef JSON_INTERNAL_CATCH
2435     #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2436 #endif
2437
2438 // allow overriding assert
2439 #if !defined(JSON_ASSERT)
2440     #include <cassert> // assert
2441     #define JSON_ASSERT(x) assert(x)
2442 #endif
2443
2444 // allow to access some private functions (needed by the test suite)
2445 #if defined(JSON_TESTS_PRIVATE)
2446     #define JSON_PRIVATE_UNLESS_TESTED public
2447 #else
2448     #define JSON_PRIVATE_UNLESS_TESTED private
2449 #endif
2450
2451 /*!
2452 @brief macro to briefly define a mapping between an enum and JSON
2453 @def NLOHMANN_JSON_SERIALIZE_ENUM
2454 @since version 3.4.0
2455 */
2456 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
2457     template<typename BasicJsonType>                                                            \
2458     inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
2459     {                                                                                           \
2460         static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2461         static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2462         auto it = std::find_if(std::begin(m), std::end(m),                                      \
2463                                [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
2464         {                                                                                       \
2465             return ej_pair.first == e;                                                          \
2466         });                                                                                     \
2467         j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
2468     }                                                                                           \
2469     template<typename BasicJsonType>                                                            \
2470     inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
2471     {                                                                                           \
2472         static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
2473         static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
2474         auto it = std::find_if(std::begin(m), std::end(m),                                      \
2475                                [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2476         {                                                                                       \
2477             return ej_pair.second == j;                                                         \
2478         });                                                                                     \
2479         e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
2480     }
2481
2482 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2483 // may be removed in the future once the class is split.
2484
2485 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
2486     template<template<typename, typename, typename...> class ObjectType,   \
2487              template<typename, typename...> class ArrayType,              \
2488              class StringType, class BooleanType, class NumberIntegerType, \
2489              class NumberUnsignedType, class NumberFloatType,              \
2490              template<typename> class AllocatorType,                       \
2491              template<typename, typename = void> class JSONSerializer,     \
2492              class BinaryType>
2493
2494 #define NLOHMANN_BASIC_JSON_TPL                                            \
2495     basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
2496     NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
2497     AllocatorType, JSONSerializer, BinaryType>
2498
2499 // Macros to simplify conversion from/to types
2500
2501 #define NLOHMANN_JSON_EXPAND( x ) x
2502 #define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
2503 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2504         NLOHMANN_JSON_PASTE64, \
2505         NLOHMANN_JSON_PASTE63, \
2506         NLOHMANN_JSON_PASTE62, \
2507         NLOHMANN_JSON_PASTE61, \
2508         NLOHMANN_JSON_PASTE60, \
2509         NLOHMANN_JSON_PASTE59, \
2510         NLOHMANN_JSON_PASTE58, \
2511         NLOHMANN_JSON_PASTE57, \
2512         NLOHMANN_JSON_PASTE56, \
2513         NLOHMANN_JSON_PASTE55, \
2514         NLOHMANN_JSON_PASTE54, \
2515         NLOHMANN_JSON_PASTE53, \
2516         NLOHMANN_JSON_PASTE52, \
2517         NLOHMANN_JSON_PASTE51, \
2518         NLOHMANN_JSON_PASTE50, \
2519         NLOHMANN_JSON_PASTE49, \
2520         NLOHMANN_JSON_PASTE48, \
2521         NLOHMANN_JSON_PASTE47, \
2522         NLOHMANN_JSON_PASTE46, \
2523         NLOHMANN_JSON_PASTE45, \
2524         NLOHMANN_JSON_PASTE44, \
2525         NLOHMANN_JSON_PASTE43, \
2526         NLOHMANN_JSON_PASTE42, \
2527         NLOHMANN_JSON_PASTE41, \
2528         NLOHMANN_JSON_PASTE40, \
2529         NLOHMANN_JSON_PASTE39, \
2530         NLOHMANN_JSON_PASTE38, \
2531         NLOHMANN_JSON_PASTE37, \
2532         NLOHMANN_JSON_PASTE36, \
2533         NLOHMANN_JSON_PASTE35, \
2534         NLOHMANN_JSON_PASTE34, \
2535         NLOHMANN_JSON_PASTE33, \
2536         NLOHMANN_JSON_PASTE32, \
2537         NLOHMANN_JSON_PASTE31, \
2538         NLOHMANN_JSON_PASTE30, \
2539         NLOHMANN_JSON_PASTE29, \
2540         NLOHMANN_JSON_PASTE28, \
2541         NLOHMANN_JSON_PASTE27, \
2542         NLOHMANN_JSON_PASTE26, \
2543         NLOHMANN_JSON_PASTE25, \
2544         NLOHMANN_JSON_PASTE24, \
2545         NLOHMANN_JSON_PASTE23, \
2546         NLOHMANN_JSON_PASTE22, \
2547         NLOHMANN_JSON_PASTE21, \
2548         NLOHMANN_JSON_PASTE20, \
2549         NLOHMANN_JSON_PASTE19, \
2550         NLOHMANN_JSON_PASTE18, \
2551         NLOHMANN_JSON_PASTE17, \
2552         NLOHMANN_JSON_PASTE16, \
2553         NLOHMANN_JSON_PASTE15, \
2554         NLOHMANN_JSON_PASTE14, \
2555         NLOHMANN_JSON_PASTE13, \
2556         NLOHMANN_JSON_PASTE12, \
2557         NLOHMANN_JSON_PASTE11, \
2558         NLOHMANN_JSON_PASTE10, \
2559         NLOHMANN_JSON_PASTE9, \
2560         NLOHMANN_JSON_PASTE8, \
2561         NLOHMANN_JSON_PASTE7, \
2562         NLOHMANN_JSON_PASTE6, \
2563         NLOHMANN_JSON_PASTE5, \
2564         NLOHMANN_JSON_PASTE4, \
2565         NLOHMANN_JSON_PASTE3, \
2566         NLOHMANN_JSON_PASTE2, \
2567         NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2568 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2569 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2570 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2571 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2572 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2573 #define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
2574 #define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
2575 #define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
2576 #define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
2577 #define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
2578 #define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
2579 #define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
2580 #define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
2581 #define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
2582 #define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
2583 #define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
2584 #define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
2585 #define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
2586 #define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
2587 #define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
2588 #define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
2589 #define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
2590 #define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
2591 #define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
2592 #define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
2593 #define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
2594 #define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
2595 #define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
2596 #define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
2597 #define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
2598 #define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
2599 #define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
2600 #define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
2601 #define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
2602 #define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
2603 #define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
2604 #define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
2605 #define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
2606 #define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
2607 #define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
2608 #define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
2609 #define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
2610 #define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
2611 #define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
2612 #define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
2613 #define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
2614 #define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
2615 #define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
2616 #define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
2617 #define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
2618 #define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
2619 #define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
2620 #define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
2621 #define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
2622 #define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
2623 #define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
2624 #define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
2625 #define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
2626 #define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
2627 #define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
2628 #define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
2629 #define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
2630 #define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
2631
2632 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2633 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2634
2635 /*!
2636 @brief macro
2637 @def NLOHMANN_DEFINE_TYPE_INTRUSIVE
2638 @since version 3.9.0
2639 */
2640 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
2641     friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2642     friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2643
2644 /*!
2645 @brief macro
2646 @def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
2647 @since version 3.9.0
2648 */
2649 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
2650     inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2651     inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2652
2653
2654 // inspired from https://stackoverflow.com/a/26745591
2655 // allows to call any std function as if (e.g. with begin):
2656 // using std::begin; begin(x);
2657 //
2658 // it allows using the detected idiom to retrieve the return type
2659 // of such an expression
2660 #define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
2661     namespace detail {                                                            \
2662     using std::std_name;                                                          \
2663     \
2664     template<typename... T>                                                       \
2665     using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2666     }                                                                             \
2667     \
2668     namespace detail2 {                                                           \
2669     struct std_name##_tag                                                         \
2670     {                                                                             \
2671     };                                                                            \
2672     \
2673     template<typename... T>                                                       \
2674     std_name##_tag std_name(T&&...);                                              \
2675     \
2676     template<typename... T>                                                       \
2677     using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
2678     \
2679     template<typename... T>                                                       \
2680     struct would_call_std_##std_name                                              \
2681     {                                                                             \
2682         static constexpr auto const value = ::nlohmann::detail::                  \
2683                                             is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
2684     };                                                                            \
2685     } /* namespace detail2 */ \
2686     \
2687     template<typename... T>                                                       \
2688     struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
2689     {                                                                             \
2690     }
2691
2692 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2693     #define JSON_USE_IMPLICIT_CONVERSIONS 1
2694 #endif
2695
2696 #if JSON_USE_IMPLICIT_CONVERSIONS
2697     #define JSON_EXPLICIT
2698 #else
2699     #define JSON_EXPLICIT explicit
2700 #endif
2701
2702 #ifndef JSON_DIAGNOSTICS
2703     #define JSON_DIAGNOSTICS 0
2704 #endif
2705
2706
2707 namespace nlohmann
2708 {
2709 namespace detail
2710 {
2711
2712 /*!
2713 @brief replace all occurrences of a substring by another string
2714
2715 @param[in,out] s  the string to manipulate; changed so that all
2716                occurrences of @a f are replaced with @a t
2717 @param[in]     f  the substring to replace with @a t
2718 @param[in]     t  the string to replace @a f
2719
2720 @pre The search string @a f must not be empty. **This precondition is
2721 enforced with an assertion.**
2722
2723 @since version 2.0.0
2724 */
2725 inline void replace_substring(std::string& s, const std::string& f,
2726                               const std::string& t)
2727 {
2728     JSON_ASSERT(!f.empty());
2729     for (auto pos = s.find(f);                // find first occurrence of f
2730             pos != std::string::npos;         // make sure f was found
2731             s.replace(pos, f.size(), t),      // replace with t, and
2732             pos = s.find(f, pos + t.size()))  // find next occurrence of f
2733     {}
2734 }
2735
2736 /*!
2737  * @brief string escaping as described in RFC 6901 (Sect. 4)
2738  * @param[in] s string to escape
2739  * @return    escaped string
2740  *
2741  * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
2742  */
2743 inline std::string escape(std::string s)
2744 {
2745     replace_substring(s, "~", "~0");
2746     replace_substring(s, "/", "~1");
2747     return s;
2748 }
2749
2750 /*!
2751  * @brief string unescaping as described in RFC 6901 (Sect. 4)
2752  * @param[in] s string to unescape
2753  * @return    unescaped string
2754  *
2755  * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
2756  */
2757 static void unescape(std::string& s)
2758 {
2759     replace_substring(s, "~1", "/");
2760     replace_substring(s, "~0", "~");
2761 }
2762
2763 } // namespace detail
2764 } // namespace nlohmann
2765
2766 // #include <nlohmann/detail/input/position_t.hpp>
2767
2768
2769 #include <cstddef> // size_t
2770
2771 namespace nlohmann
2772 {
2773 namespace detail
2774 {
2775 /// struct to capture the start position of the current token
2776 struct position_t
2777 {
2778     /// the total number of characters read
2779     std::size_t chars_read_total = 0;
2780     /// the number of characters read in the current line
2781     std::size_t chars_read_current_line = 0;
2782     /// the number of lines read
2783     std::size_t lines_read = 0;
2784
2785     /// conversion to size_t to preserve SAX interface
2786     constexpr operator size_t() const
2787     {
2788         return chars_read_total;
2789     }
2790 };
2791
2792 } // namespace detail
2793 } // namespace nlohmann
2794
2795 // #include <nlohmann/detail/macro_scope.hpp>
2796
2797
2798 namespace nlohmann
2799 {
2800 namespace detail
2801 {
2802 ////////////////
2803 // exceptions //
2804 ////////////////
2805
2806 /// @brief general exception of the @ref basic_json class
2807 /// @sa https://json.nlohmann.me/api/basic_json/exception/
2808 class exception : public std::exception
2809 {
2810   public:
2811     /// returns the explanatory string
2812     const char* what() const noexcept override
2813     {
2814         return m.what();
2815     }
2816
2817     /// the id of the exception
2818     const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
2819
2820   protected:
2821     JSON_HEDLEY_NON_NULL(3)
2822     exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
2823
2824     static std::string name(const std::string& ename, int id_)
2825     {
2826         return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
2827     }
2828
2829     template<typename BasicJsonType>
2830     static std::string diagnostics(const BasicJsonType& leaf_element)
2831     {
2832 #if JSON_DIAGNOSTICS
2833         std::vector<std::string> tokens;
2834         for (const auto* current = &leaf_element; current->m_parent != nullptr; current = current->m_parent)
2835         {
2836             switch (current->m_parent->type())
2837             {
2838                 case value_t::array:
2839                 {
2840                     for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
2841                     {
2842                         if (&current->m_parent->m_value.array->operator[](i) == current)
2843                         {
2844                             tokens.emplace_back(std::to_string(i));
2845                             break;
2846                         }
2847                     }
2848                     break;
2849                 }
2850
2851                 case value_t::object:
2852                 {
2853                     for (const auto& element : *current->m_parent->m_value.object)
2854                     {
2855                         if (&element.second == current)
2856                         {
2857                             tokens.emplace_back(element.first.c_str());
2858                             break;
2859                         }
2860                     }
2861                     break;
2862                 }
2863
2864                 case value_t::null: // LCOV_EXCL_LINE
2865                 case value_t::string: // LCOV_EXCL_LINE
2866                 case value_t::boolean: // LCOV_EXCL_LINE
2867                 case value_t::number_integer: // LCOV_EXCL_LINE
2868                 case value_t::number_unsigned: // LCOV_EXCL_LINE
2869                 case value_t::number_float: // LCOV_EXCL_LINE
2870                 case value_t::binary: // LCOV_EXCL_LINE
2871                 case value_t::discarded: // LCOV_EXCL_LINE
2872                 default:   // LCOV_EXCL_LINE
2873                     break; // LCOV_EXCL_LINE
2874             }
2875         }
2876
2877         if (tokens.empty())
2878         {
2879             return "";
2880         }
2881
2882         return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
2883                                      [](const std::string & a, const std::string & b)
2884         {
2885             return a + "/" + detail::escape(b);
2886         }) + ") ";
2887 #else
2888         static_cast<void>(leaf_element);
2889         return "";
2890 #endif
2891     }
2892
2893   private:
2894     /// an exception object as storage for error messages
2895     std::runtime_error m;
2896 };
2897
2898 /// @brief exception indicating a parse error
2899 /// @sa https://json.nlohmann.me/api/basic_json/parse_error/
2900 class parse_error : public exception
2901 {
2902   public:
2903     /*!
2904     @brief create a parse error exception
2905     @param[in] id_       the id of the exception
2906     @param[in] pos       the position where the error occurred (or with
2907                          chars_read_total=0 if the position cannot be
2908                          determined)
2909     @param[in] what_arg  the explanatory string
2910     @return parse_error object
2911     */
2912     template<typename BasicJsonType>
2913     static parse_error create(int id_, const position_t& pos, const std::string& what_arg, const BasicJsonType& context)
2914     {
2915         std::string w = exception::name("parse_error", id_) + "parse error" +
2916                         position_string(pos) + ": " + exception::diagnostics(context) + what_arg;
2917         return {id_, pos.chars_read_total, w.c_str()};
2918     }
2919
2920     template<typename BasicJsonType>
2921     static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, const BasicJsonType& context)
2922     {
2923         std::string w = exception::name("parse_error", id_) + "parse error" +
2924                         (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
2925                         ": " + exception::diagnostics(context) + what_arg;
2926         return {id_, byte_, w.c_str()};
2927     }
2928
2929     /*!
2930     @brief byte index of the parse error
2931
2932     The byte index of the last read character in the input file.
2933
2934     @note For an input with n bytes, 1 is the index of the first character and
2935           n+1 is the index of the terminating null byte or the end of file.
2936           This also holds true when reading a byte vector (CBOR or MessagePack).
2937     */
2938     const std::size_t byte;
2939
2940   private:
2941     parse_error(int id_, std::size_t byte_, const char* what_arg)
2942         : exception(id_, what_arg), byte(byte_) {}
2943
2944     static std::string position_string(const position_t& pos)
2945     {
2946         return " at line " + std::to_string(pos.lines_read + 1) +
2947                ", column " + std::to_string(pos.chars_read_current_line);
2948     }
2949 };
2950
2951 /// @brief exception indicating errors with iterators
2952 /// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
2953 class invalid_iterator : public exception
2954 {
2955   public:
2956     template<typename BasicJsonType>
2957     static invalid_iterator create(int id_, const std::string& what_arg, const BasicJsonType& context)
2958     {
2959         std::string w = exception::name("invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
2960         return {id_, w.c_str()};
2961     }
2962
2963   private:
2964     JSON_HEDLEY_NON_NULL(3)
2965     invalid_iterator(int id_, const char* what_arg)
2966         : exception(id_, what_arg) {}
2967 };
2968
2969 /// @brief exception indicating executing a member function with a wrong type
2970 /// @sa https://json.nlohmann.me/api/basic_json/type_error/
2971 class type_error : public exception
2972 {
2973   public:
2974     template<typename BasicJsonType>
2975     static type_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
2976     {
2977         std::string w = exception::name("type_error", id_) + exception::diagnostics(context) + what_arg;
2978         return {id_, w.c_str()};
2979     }
2980
2981   private:
2982     JSON_HEDLEY_NON_NULL(3)
2983     type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2984 };
2985
2986 /// @brief exception indicating access out of the defined range
2987 /// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
2988 class out_of_range : public exception
2989 {
2990   public:
2991     template<typename BasicJsonType>
2992     static out_of_range create(int id_, const std::string& what_arg, const BasicJsonType& context)
2993     {
2994         std::string w = exception::name("out_of_range", id_) + exception::diagnostics(context) + what_arg;
2995         return {id_, w.c_str()};
2996     }
2997
2998   private:
2999     JSON_HEDLEY_NON_NULL(3)
3000     out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
3001 };
3002
3003 /// @brief exception indicating other library errors
3004 /// @sa https://json.nlohmann.me/api/basic_json/other_error/
3005 class other_error : public exception
3006 {
3007   public:
3008     template<typename BasicJsonType>
3009     static other_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
3010     {
3011         std::string w = exception::name("other_error", id_) + exception::diagnostics(context) + what_arg;
3012         return {id_, w.c_str()};
3013     }
3014
3015   private:
3016     JSON_HEDLEY_NON_NULL(3)
3017     other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
3018 };
3019
3020 }  // namespace detail
3021 }  // namespace nlohmann
3022
3023 // #include <nlohmann/detail/macro_scope.hpp>
3024
3025 // #include <nlohmann/detail/meta/cpp_future.hpp>
3026
3027
3028 #include <cstddef> // size_t
3029 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
3030 #include <utility> // index_sequence, make_index_sequence, index_sequence_for
3031
3032 // #include <nlohmann/detail/macro_scope.hpp>
3033
3034
3035 namespace nlohmann
3036 {
3037 namespace detail
3038 {
3039
3040 template<typename T>
3041 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3042
3043 #ifdef JSON_HAS_CPP_14
3044
3045 // the following utilities are natively available in C++14
3046 using std::enable_if_t;
3047 using std::index_sequence;
3048 using std::make_index_sequence;
3049 using std::index_sequence_for;
3050
3051 #else
3052
3053 // alias templates to reduce boilerplate
3054 template<bool B, typename T = void>
3055 using enable_if_t = typename std::enable_if<B, T>::type;
3056
3057 // The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
3058 // which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
3059
3060 //// START OF CODE FROM GOOGLE ABSEIL
3061
3062 // integer_sequence
3063 //
3064 // Class template representing a compile-time integer sequence. An instantiation
3065 // of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
3066 // type through its template arguments (which is a common need when
3067 // working with C++11 variadic templates). `absl::integer_sequence` is designed
3068 // to be a drop-in replacement for C++14's `std::integer_sequence`.
3069 //
3070 // Example:
3071 //
3072 //   template< class T, T... Ints >
3073 //   void user_function(integer_sequence<T, Ints...>);
3074 //
3075 //   int main()
3076 //   {
3077 //     // user_function's `T` will be deduced to `int` and `Ints...`
3078 //     // will be deduced to `0, 1, 2, 3, 4`.
3079 //     user_function(make_integer_sequence<int, 5>());
3080 //   }
3081 template <typename T, T... Ints>
3082 struct integer_sequence
3083 {
3084     using value_type = T;
3085     static constexpr std::size_t size() noexcept
3086     {
3087         return sizeof...(Ints);
3088     }
3089 };
3090
3091 // index_sequence
3092 //
3093 // A helper template for an `integer_sequence` of `size_t`,
3094 // `absl::index_sequence` is designed to be a drop-in replacement for C++14's
3095 // `std::index_sequence`.
3096 template <size_t... Ints>
3097 using index_sequence = integer_sequence<size_t, Ints...>;
3098
3099 namespace utility_internal
3100 {
3101
3102 template <typename Seq, size_t SeqSize, size_t Rem>
3103 struct Extend;
3104
3105 // Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
3106 template <typename T, T... Ints, size_t SeqSize>
3107 struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
3108 {
3109     using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
3110 };
3111
3112 template <typename T, T... Ints, size_t SeqSize>
3113 struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
3114 {
3115     using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
3116 };
3117
3118 // Recursion helper for 'make_integer_sequence<T, N>'.
3119 // 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
3120 template <typename T, size_t N>
3121 struct Gen
3122 {
3123     using type =
3124         typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
3125 };
3126
3127 template <typename T>
3128 struct Gen<T, 0>
3129 {
3130     using type = integer_sequence<T>;
3131 };
3132
3133 }  // namespace utility_internal
3134
3135 // Compile-time sequences of integers
3136
3137 // make_integer_sequence
3138 //
3139 // This template alias is equivalent to
3140 // `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
3141 // replacement for C++14's `std::make_integer_sequence`.
3142 template <typename T, T N>
3143 using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
3144
3145 // make_index_sequence
3146 //
3147 // This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
3148 // and is designed to be a drop-in replacement for C++14's
3149 // `std::make_index_sequence`.
3150 template <size_t N>
3151 using make_index_sequence = make_integer_sequence<size_t, N>;
3152
3153 // index_sequence_for
3154 //
3155 // Converts a typename pack into an index sequence of the same length, and
3156 // is designed to be a drop-in replacement for C++14's
3157 // `std::index_sequence_for()`
3158 template <typename... Ts>
3159 using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
3160
3161 //// END OF CODE FROM GOOGLE ABSEIL
3162
3163 #endif
3164
3165 // dispatch utility (taken from ranges-v3)
3166 template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
3167 template<> struct priority_tag<0> {};
3168
3169 // taken from ranges-v3
3170 template<typename T>
3171 struct static_const
3172 {
3173     static constexpr T value{};
3174 };
3175
3176 template<typename T>
3177 constexpr T static_const<T>::value; // NOLINT(readability-redundant-declaration)
3178
3179 }  // namespace detail
3180 }  // namespace nlohmann
3181
3182 // #include <nlohmann/detail/meta/identity_tag.hpp>
3183
3184
3185 namespace nlohmann
3186 {
3187 namespace detail
3188 {
3189 // dispatching helper struct
3190 template <class T> struct identity_tag {};
3191 }  // namespace detail
3192 }  // namespace nlohmann
3193
3194 // #include <nlohmann/detail/meta/type_traits.hpp>
3195
3196
3197 #include <limits> // numeric_limits
3198 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
3199 #include <utility> // declval
3200 #include <tuple> // tuple
3201
3202 // #include <nlohmann/detail/macro_scope.hpp>
3203
3204
3205 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
3206
3207
3208 #include <iterator> // random_access_iterator_tag
3209
3210 // #include <nlohmann/detail/meta/void_t.hpp>
3211
3212 // #include <nlohmann/detail/meta/cpp_future.hpp>
3213
3214
3215 namespace nlohmann
3216 {
3217 namespace detail
3218 {
3219 template<typename It, typename = void>
3220 struct iterator_types {};
3221
3222 template<typename It>
3223 struct iterator_types <
3224     It,
3225     void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
3226     typename It::reference, typename It::iterator_category >>
3227 {
3228     using difference_type = typename It::difference_type;
3229     using value_type = typename It::value_type;
3230     using pointer = typename It::pointer;
3231     using reference = typename It::reference;
3232     using iterator_category = typename It::iterator_category;
3233 };
3234
3235 // This is required as some compilers implement std::iterator_traits in a way that
3236 // doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
3237 template<typename T, typename = void>
3238 struct iterator_traits
3239 {
3240 };
3241
3242 template<typename T>
3243 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3244             : iterator_types<T>
3245 {
3246 };
3247
3248 template<typename T>
3249 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3250 {
3251     using iterator_category = std::random_access_iterator_tag;
3252     using value_type = T;
3253     using difference_type = ptrdiff_t;
3254     using pointer = T*;
3255     using reference = T&;
3256 };
3257 } // namespace detail
3258 } // namespace nlohmann
3259
3260 // #include <nlohmann/detail/meta/call_std/begin.hpp>
3261
3262
3263 // #include <nlohmann/detail/macro_scope.hpp>
3264
3265
3266 namespace nlohmann
3267 {
3268 NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
3269 } // namespace nlohmann
3270
3271 // #include <nlohmann/detail/meta/call_std/end.hpp>
3272
3273
3274 // #include <nlohmann/detail/macro_scope.hpp>
3275
3276
3277 namespace nlohmann
3278 {
3279 NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
3280 }  // namespace nlohmann
3281
3282 // #include <nlohmann/detail/meta/cpp_future.hpp>
3283
3284 // #include <nlohmann/detail/meta/detected.hpp>
3285
3286 // #include <nlohmann/json_fwd.hpp>
3287 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
3288 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
3289
3290 #include <cstdint> // int64_t, uint64_t
3291 #include <map> // map
3292 #include <memory> // allocator
3293 #include <string> // string
3294 #include <vector> // vector
3295
3296 /*!
3297 @brief namespace for Niels Lohmann
3298 @see https://github.com/nlohmann
3299 @since version 1.0.0
3300 */
3301 namespace nlohmann
3302 {
3303 /*!
3304 @brief default JSONSerializer template argument
3305
3306 This serializer ignores the template arguments and uses ADL
3307 ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
3308 for serialization.
3309 */
3310 template<typename T = void, typename SFINAE = void>
3311 struct adl_serializer;
3312
3313 /// a class to store JSON values
3314 /// @sa https://json.nlohmann.me/api/basic_json/
3315 template<template<typename U, typename V, typename... Args> class ObjectType =
3316          std::map,
3317          template<typename U, typename... Args> class ArrayType = std::vector,
3318          class StringType = std::string, class BooleanType = bool,
3319          class NumberIntegerType = std::int64_t,
3320          class NumberUnsignedType = std::uint64_t,
3321          class NumberFloatType = double,
3322          template<typename U> class AllocatorType = std::allocator,
3323          template<typename T, typename SFINAE = void> class JSONSerializer =
3324          adl_serializer,
3325          class BinaryType = std::vector<std::uint8_t>>
3326 class basic_json;
3327
3328 /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
3329 /// @sa https://json.nlohmann.me/api/json_pointer/
3330 template<typename BasicJsonType>
3331 class json_pointer;
3332
3333 /*!
3334 @brief default specialization
3335 @sa https://json.nlohmann.me/api/json/
3336 */
3337 using json = basic_json<>;
3338
3339 /// @brief a minimal map-like container that preserves insertion order
3340 /// @sa https://json.nlohmann.me/api/ordered_map/
3341 template<class Key, class T, class IgnoredLess, class Allocator>
3342 struct ordered_map;
3343
3344 /// @brief specialization that maintains the insertion order of object keys
3345 /// @sa https://json.nlohmann.me/api/ordered_json/
3346 using ordered_json = basic_json<nlohmann::ordered_map>;
3347
3348 }  // namespace nlohmann
3349
3350 #endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
3351
3352
3353 namespace nlohmann
3354 {
3355 /*!
3356 @brief detail namespace with internal helper functions
3357
3358 This namespace collects functions that should not be exposed,
3359 implementations of some @ref basic_json methods, and meta-programming helpers.
3360
3361 @since version 2.1.0
3362 */
3363 namespace detail
3364 {
3365 /////////////
3366 // helpers //
3367 /////////////
3368
3369 // Note to maintainers:
3370 //
3371 // Every trait in this file expects a non CV-qualified type.
3372 // The only exceptions are in the 'aliases for detected' section
3373 // (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
3374 //
3375 // In this case, T has to be properly CV-qualified to constraint the function arguments
3376 // (e.g. to_json(BasicJsonType&, const T&))
3377
3378 template<typename> struct is_basic_json : std::false_type {};
3379
3380 NLOHMANN_BASIC_JSON_TPL_DECLARATION
3381 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3382
3383 //////////////////////
3384 // json_ref helpers //
3385 //////////////////////
3386
3387 template<typename>
3388 class json_ref;
3389
3390 template<typename>
3391 struct is_json_ref : std::false_type {};
3392
3393 template<typename T>
3394 struct is_json_ref<json_ref<T>> : std::true_type {};
3395
3396 //////////////////////////
3397 // aliases for detected //
3398 //////////////////////////
3399
3400 template<typename T>
3401 using mapped_type_t = typename T::mapped_type;
3402
3403 template<typename T>
3404 using key_type_t = typename T::key_type;
3405
3406 template<typename T>
3407 using value_type_t = typename T::value_type;
3408
3409 template<typename T>
3410 using difference_type_t = typename T::difference_type;
3411
3412 template<typename T>
3413 using pointer_t = typename T::pointer;
3414
3415 template<typename T>
3416 using reference_t = typename T::reference;
3417
3418 template<typename T>
3419 using iterator_category_t = typename T::iterator_category;
3420
3421 template<typename T, typename... Args>
3422 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3423
3424 template<typename T, typename... Args>
3425 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3426
3427 template<typename T, typename U>
3428 using get_template_function = decltype(std::declval<T>().template get<U>());
3429
3430 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3431 template<typename BasicJsonType, typename T, typename = void>
3432 struct has_from_json : std::false_type {};
3433
3434 // trait checking if j.get<T> is valid
3435 // use this trait instead of std::is_constructible or std::is_convertible,
3436 // both rely on, or make use of implicit conversions, and thus fail when T
3437 // has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3438 template <typename BasicJsonType, typename T>
3439 struct is_getable
3440 {
3441     static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3442 };
3443
3444 template<typename BasicJsonType, typename T>
3445 struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3446 {
3447     using serializer = typename BasicJsonType::template json_serializer<T, void>;
3448
3449     static constexpr bool value =
3450         is_detected_exact<void, from_json_function, serializer,
3451         const BasicJsonType&, T&>::value;
3452 };
3453
3454 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
3455 // this overload is used for non-default-constructible user-defined-types
3456 template<typename BasicJsonType, typename T, typename = void>
3457 struct has_non_default_from_json : std::false_type {};
3458
3459 template<typename BasicJsonType, typename T>
3460 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3461 {
3462     using serializer = typename BasicJsonType::template json_serializer<T, void>;
3463
3464     static constexpr bool value =
3465         is_detected_exact<T, from_json_function, serializer,
3466         const BasicJsonType&>::value;
3467 };
3468
3469 // This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3470 // Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3471 template<typename BasicJsonType, typename T, typename = void>
3472 struct has_to_json : std::false_type {};
3473
3474 template<typename BasicJsonType, typename T>
3475 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3476 {
3477     using serializer = typename BasicJsonType::template json_serializer<T, void>;
3478
3479     static constexpr bool value =
3480         is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3481         T>::value;
3482 };
3483
3484
3485 ///////////////////
3486 // is_ functions //
3487 ///////////////////
3488
3489 // https://en.cppreference.com/w/cpp/types/conjunction
3490 template<class...> struct conjunction : std::true_type { };
3491 template<class B1> struct conjunction<B1> : B1 { };
3492 template<class B1, class... Bn>
3493 struct conjunction<B1, Bn...>
3494 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3495
3496 // https://en.cppreference.com/w/cpp/types/negation
3497 template<class B> struct negation : std::integral_constant < bool, !B::value > { };
3498
3499 // Reimplementation of is_constructible and is_default_constructible, due to them being broken for
3500 // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
3501 // This causes compile errors in e.g. clang 3.5 or gcc 4.9.
3502 template <typename T>
3503 struct is_default_constructible : std::is_default_constructible<T> {};
3504
3505 template <typename T1, typename T2>
3506 struct is_default_constructible<std::pair<T1, T2>>
3507             : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3508
3509 template <typename T1, typename T2>
3510 struct is_default_constructible<const std::pair<T1, T2>>
3511             : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
3512
3513 template <typename... Ts>
3514 struct is_default_constructible<std::tuple<Ts...>>
3515             : conjunction<is_default_constructible<Ts>...> {};
3516
3517 template <typename... Ts>
3518 struct is_default_constructible<const std::tuple<Ts...>>
3519             : conjunction<is_default_constructible<Ts>...> {};
3520
3521
3522 template <typename T, typename... Args>
3523 struct is_constructible : std::is_constructible<T, Args...> {};
3524
3525 template <typename T1, typename T2>
3526 struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3527
3528 template <typename T1, typename T2>
3529 struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3530
3531 template <typename... Ts>
3532 struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3533
3534 template <typename... Ts>
3535 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3536
3537
3538 template<typename T, typename = void>
3539 struct is_iterator_traits : std::false_type {};
3540
3541 template<typename T>
3542 struct is_iterator_traits<iterator_traits<T>>
3543 {
3544   private:
3545     using traits = iterator_traits<T>;
3546
3547   public:
3548     static constexpr auto value =
3549         is_detected<value_type_t, traits>::value &&
3550         is_detected<difference_type_t, traits>::value &&
3551         is_detected<pointer_t, traits>::value &&
3552         is_detected<iterator_category_t, traits>::value &&
3553         is_detected<reference_t, traits>::value;
3554 };
3555
3556 template<typename T>
3557 struct is_range
3558 {
3559   private:
3560     using t_ref = typename std::add_lvalue_reference<T>::type;
3561
3562     using iterator = detected_t<result_of_begin, t_ref>;
3563     using sentinel = detected_t<result_of_end, t_ref>;
3564
3565     // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
3566     // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
3567     // but reimplementing these would be too much work, as a lot of other concepts are used underneath
3568     static constexpr auto is_iterator_begin =
3569         is_iterator_traits<iterator_traits<iterator>>::value;
3570
3571   public:
3572     static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
3573 };
3574
3575 template<typename R>
3576 using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3577
3578 template<typename T>
3579 using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
3580
3581 // The following implementation of is_complete_type is taken from
3582 // https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
3583 // and is written by Xiang Fan who agreed to using it in this library.
3584
3585 template<typename T, typename = void>
3586 struct is_complete_type : std::false_type {};
3587
3588 template<typename T>
3589 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3590
3591 template<typename BasicJsonType, typename CompatibleObjectType,
3592          typename = void>
3593 struct is_compatible_object_type_impl : std::false_type {};
3594
3595 template<typename BasicJsonType, typename CompatibleObjectType>
3596 struct is_compatible_object_type_impl <
3597     BasicJsonType, CompatibleObjectType,
3598     enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3599     is_detected<key_type_t, CompatibleObjectType>::value >>
3600 {
3601     using object_t = typename BasicJsonType::object_t;
3602
3603     // macOS's is_constructible does not play well with nonesuch...
3604     static constexpr bool value =
3605         is_constructible<typename object_t::key_type,
3606         typename CompatibleObjectType::key_type>::value &&
3607         is_constructible<typename object_t::mapped_type,
3608         typename CompatibleObjectType::mapped_type>::value;
3609 };
3610
3611 template<typename BasicJsonType, typename CompatibleObjectType>
3612 struct is_compatible_object_type
3613     : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3614
3615 template<typename BasicJsonType, typename ConstructibleObjectType,
3616          typename = void>
3617 struct is_constructible_object_type_impl : std::false_type {};
3618
3619 template<typename BasicJsonType, typename ConstructibleObjectType>
3620 struct is_constructible_object_type_impl <
3621     BasicJsonType, ConstructibleObjectType,
3622     enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3623     is_detected<key_type_t, ConstructibleObjectType>::value >>
3624 {
3625     using object_t = typename BasicJsonType::object_t;
3626
3627     static constexpr bool value =
3628         (is_default_constructible<ConstructibleObjectType>::value &&
3629          (std::is_move_assignable<ConstructibleObjectType>::value ||
3630           std::is_copy_assignable<ConstructibleObjectType>::value) &&
3631          (is_constructible<typename ConstructibleObjectType::key_type,
3632           typename object_t::key_type>::value &&
3633           std::is_same <
3634           typename object_t::mapped_type,
3635           typename ConstructibleObjectType::mapped_type >::value)) ||
3636         (has_from_json<BasicJsonType,
3637          typename ConstructibleObjectType::mapped_type>::value ||
3638          has_non_default_from_json <
3639          BasicJsonType,
3640          typename ConstructibleObjectType::mapped_type >::value);
3641 };
3642
3643 template<typename BasicJsonType, typename ConstructibleObjectType>
3644 struct is_constructible_object_type
3645     : is_constructible_object_type_impl<BasicJsonType,
3646       ConstructibleObjectType> {};
3647
3648 template<typename BasicJsonType, typename CompatibleStringType>
3649 struct is_compatible_string_type
3650 {
3651     static constexpr auto value =
3652         is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3653 };
3654
3655 template<typename BasicJsonType, typename ConstructibleStringType>
3656 struct is_constructible_string_type
3657 {
3658     static constexpr auto value =
3659         is_constructible<ConstructibleStringType,
3660         typename BasicJsonType::string_t>::value;
3661 };
3662
3663 template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3664 struct is_compatible_array_type_impl : std::false_type {};
3665
3666 template<typename BasicJsonType, typename CompatibleArrayType>
3667 struct is_compatible_array_type_impl <
3668     BasicJsonType, CompatibleArrayType,
3669     enable_if_t <
3670     is_detected<iterator_t, CompatibleArrayType>::value&&
3671     is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
3672 // special case for types like std::filesystem::path whose iterator's value_type are themselves
3673 // c.f. https://github.com/nlohmann/json/pull/3073
3674     !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3675 {
3676     static constexpr bool value =
3677         is_constructible<BasicJsonType,
3678         range_value_t<CompatibleArrayType>>::value;
3679 };
3680
3681 template<typename BasicJsonType, typename CompatibleArrayType>
3682 struct is_compatible_array_type
3683     : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3684
3685 template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3686 struct is_constructible_array_type_impl : std::false_type {};
3687
3688 template<typename BasicJsonType, typename ConstructibleArrayType>
3689 struct is_constructible_array_type_impl <
3690     BasicJsonType, ConstructibleArrayType,
3691     enable_if_t<std::is_same<ConstructibleArrayType,
3692     typename BasicJsonType::value_type>::value >>
3693             : std::true_type {};
3694
3695 template<typename BasicJsonType, typename ConstructibleArrayType>
3696 struct is_constructible_array_type_impl <
3697     BasicJsonType, ConstructibleArrayType,
3698     enable_if_t < !std::is_same<ConstructibleArrayType,
3699     typename BasicJsonType::value_type>::value&&
3700     !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3701     is_default_constructible<ConstructibleArrayType>::value&&
3702 (std::is_move_assignable<ConstructibleArrayType>::value ||
3703  std::is_copy_assignable<ConstructibleArrayType>::value)&&
3704 is_detected<iterator_t, ConstructibleArrayType>::value&&
3705 is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
3706 is_detected<range_value_t, ConstructibleArrayType>::value&&
3707 // special case for types like std::filesystem::path whose iterator's value_type are themselves
3708 // c.f. https://github.com/nlohmann/json/pull/3073
3709 !std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
3710         is_complete_type <
3711         detected_t<range_value_t, ConstructibleArrayType >>::value >>
3712 {
3713     using value_type = range_value_t<ConstructibleArrayType>;
3714
3715     static constexpr bool value =
3716         std::is_same<value_type,
3717         typename BasicJsonType::array_t::value_type>::value ||
3718         has_from_json<BasicJsonType,
3719         value_type>::value ||
3720         has_non_default_from_json <
3721         BasicJsonType,
3722         value_type >::value;
3723 };
3724
3725 template<typename BasicJsonType, typename ConstructibleArrayType>
3726 struct is_constructible_array_type
3727     : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3728
3729 template<typename RealIntegerType, typename CompatibleNumberIntegerType,
3730          typename = void>
3731 struct is_compatible_integer_type_impl : std::false_type {};
3732
3733 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3734 struct is_compatible_integer_type_impl <
3735     RealIntegerType, CompatibleNumberIntegerType,
3736     enable_if_t < std::is_integral<RealIntegerType>::value&&
3737     std::is_integral<CompatibleNumberIntegerType>::value&&
3738     !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3739 {
3740     // is there an assert somewhere on overflows?
3741     using RealLimits = std::numeric_limits<RealIntegerType>;
3742     using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3743
3744     static constexpr auto value =
3745         is_constructible<RealIntegerType,
3746         CompatibleNumberIntegerType>::value &&
3747         CompatibleLimits::is_integer &&
3748         RealLimits::is_signed == CompatibleLimits::is_signed;
3749 };
3750
3751 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3752 struct is_compatible_integer_type
3753     : is_compatible_integer_type_impl<RealIntegerType,
3754       CompatibleNumberIntegerType> {};
3755
3756 template<typename BasicJsonType, typename CompatibleType, typename = void>
3757 struct is_compatible_type_impl: std::false_type {};
3758
3759 template<typename BasicJsonType, typename CompatibleType>
3760 struct is_compatible_type_impl <
3761     BasicJsonType, CompatibleType,
3762     enable_if_t<is_complete_type<CompatibleType>::value >>
3763 {
3764     static constexpr bool value =
3765         has_to_json<BasicJsonType, CompatibleType>::value;
3766 };
3767
3768 template<typename BasicJsonType, typename CompatibleType>
3769 struct is_compatible_type
3770     : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3771
3772 template<typename T1, typename T2>
3773 struct is_constructible_tuple : std::false_type {};
3774
3775 template<typename T1, typename... Args>
3776 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3777
3778 // a naive helper to check if a type is an ordered_map (exploits the fact that
3779 // ordered_map inherits capacity() from std::vector)
3780 template <typename T>
3781 struct is_ordered_map
3782 {
3783     using one = char;
3784
3785     struct two
3786     {
3787         char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
3788     };
3789
3790     template <typename C> static one test( decltype(&C::capacity) ) ;
3791     template <typename C> static two test(...);
3792
3793     enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
3794 };
3795
3796 // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
3797 template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
3798 T conditional_static_cast(U value)
3799 {
3800     return static_cast<T>(value);
3801 }
3802
3803 template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
3804 T conditional_static_cast(U value)
3805 {
3806     return value;
3807 }
3808
3809 }  // namespace detail
3810 }  // namespace nlohmann
3811
3812 // #include <nlohmann/detail/value_t.hpp>
3813
3814
3815 #if JSON_HAS_EXPERIMENTAL_FILESYSTEM
3816 #include <experimental/filesystem>
3817 namespace nlohmann::detail
3818 {
3819 namespace std_fs = std::experimental::filesystem;
3820 } // namespace nlohmann::detail
3821 #elif JSON_HAS_FILESYSTEM
3822 #include <filesystem>
3823 namespace nlohmann::detail
3824 {
3825 namespace std_fs = std::filesystem;
3826 } // namespace nlohmann::detail
3827 #endif
3828
3829 namespace nlohmann
3830 {
3831 namespace detail
3832 {
3833 template<typename BasicJsonType>
3834 void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
3835 {
3836     if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3837     {
3838         JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), j));
3839     }
3840     n = nullptr;
3841 }
3842
3843 // overloads for basic_json template parameters
3844 template < typename BasicJsonType, typename ArithmeticType,
3845            enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3846                          !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3847                          int > = 0 >
3848 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
3849 {
3850     switch (static_cast<value_t>(j))
3851     {
3852         case value_t::number_unsigned:
3853         {
3854             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3855             break;
3856         }
3857         case value_t::number_integer:
3858         {
3859             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3860             break;
3861         }
3862         case value_t::number_float:
3863         {
3864             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3865             break;
3866         }
3867
3868         case value_t::null:
3869         case value_t::object:
3870         case value_t::array:
3871         case value_t::string:
3872         case value_t::boolean:
3873         case value_t::binary:
3874         case value_t::discarded:
3875         default:
3876             JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
3877     }
3878 }
3879
3880 template<typename BasicJsonType>
3881 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
3882 {
3883     if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3884     {
3885         JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), j));
3886     }
3887     b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3888 }
3889
3890 template<typename BasicJsonType>
3891 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
3892 {
3893     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3894     {
3895         JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
3896     }
3897     s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3898 }
3899
3900 template <
3901     typename BasicJsonType, typename ConstructibleStringType,
3902     enable_if_t <
3903         is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3904         !std::is_same<typename BasicJsonType::string_t,
3905                       ConstructibleStringType>::value,
3906         int > = 0 >
3907 void from_json(const BasicJsonType& j, ConstructibleStringType& s)
3908 {
3909     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3910     {
3911         JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
3912     }
3913
3914     s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3915 }
3916
3917 template<typename BasicJsonType>
3918 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
3919 {
3920     get_arithmetic_value(j, val);
3921 }
3922
3923 template<typename BasicJsonType>
3924 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
3925 {
3926     get_arithmetic_value(j, val);
3927 }
3928
3929 template<typename BasicJsonType>
3930 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
3931 {
3932     get_arithmetic_value(j, val);
3933 }
3934
3935 template<typename BasicJsonType, typename EnumType,
3936          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
3937 void from_json(const BasicJsonType& j, EnumType& e)
3938 {
3939     typename std::underlying_type<EnumType>::type val;
3940     get_arithmetic_value(j, val);
3941     e = static_cast<EnumType>(val);
3942 }
3943
3944 // forward_list doesn't have an insert method
3945 template<typename BasicJsonType, typename T, typename Allocator,
3946          enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
3947 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3948 {
3949     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3950     {
3951         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
3952     }
3953     l.clear();
3954     std::transform(j.rbegin(), j.rend(),
3955                    std::front_inserter(l), [](const BasicJsonType & i)
3956     {
3957         return i.template get<T>();
3958     });
3959 }
3960
3961 // valarray doesn't have an insert method
3962 template<typename BasicJsonType, typename T,
3963          enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
3964 void from_json(const BasicJsonType& j, std::valarray<T>& l)
3965 {
3966     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3967     {
3968         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
3969     }
3970     l.resize(j.size());
3971     std::transform(j.begin(), j.end(), std::begin(l),
3972                    [](const BasicJsonType & elem)
3973     {
3974         return elem.template get<T>();
3975     });
3976 }
3977
3978 template<typename BasicJsonType, typename T, std::size_t N>
3979 auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
3980 -> decltype(j.template get<T>(), void())
3981 {
3982     for (std::size_t i = 0; i < N; ++i)
3983     {
3984         arr[i] = j.at(i).template get<T>();
3985     }
3986 }
3987
3988 template<typename BasicJsonType>
3989 void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
3990 {
3991     arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3992 }
3993
3994 template<typename BasicJsonType, typename T, std::size_t N>
3995 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
3996                           priority_tag<2> /*unused*/)
3997 -> decltype(j.template get<T>(), void())
3998 {
3999     for (std::size_t i = 0; i < N; ++i)
4000     {
4001         arr[i] = j.at(i).template get<T>();
4002     }
4003 }
4004
4005 template<typename BasicJsonType, typename ConstructibleArrayType,
4006          enable_if_t<
4007              std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4008              int> = 0>
4009 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
4010 -> decltype(
4011     arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4012     j.template get<typename ConstructibleArrayType::value_type>(),
4013     void())
4014 {
4015     using std::end;
4016
4017     ConstructibleArrayType ret;
4018     ret.reserve(j.size());
4019     std::transform(j.begin(), j.end(),
4020                    std::inserter(ret, end(ret)), [](const BasicJsonType & i)
4021     {
4022         // get<BasicJsonType>() returns *this, this won't call a from_json
4023         // method when value_type is BasicJsonType
4024         return i.template get<typename ConstructibleArrayType::value_type>();
4025     });
4026     arr = std::move(ret);
4027 }
4028
4029 template<typename BasicJsonType, typename ConstructibleArrayType,
4030          enable_if_t<
4031              std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4032              int> = 0>
4033 void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
4034                           priority_tag<0> /*unused*/)
4035 {
4036     using std::end;
4037
4038     ConstructibleArrayType ret;
4039     std::transform(
4040         j.begin(), j.end(), std::inserter(ret, end(ret)),
4041         [](const BasicJsonType & i)
4042     {
4043         // get<BasicJsonType>() returns *this, this won't call a from_json
4044         // method when value_type is BasicJsonType
4045         return i.template get<typename ConstructibleArrayType::value_type>();
4046     });
4047     arr = std::move(ret);
4048 }
4049
4050 template < typename BasicJsonType, typename ConstructibleArrayType,
4051            enable_if_t <
4052                is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
4053                !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
4054                !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
4055                !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4056                !is_basic_json<ConstructibleArrayType>::value,
4057                int > = 0 >
4058 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
4059 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
4060 j.template get<typename ConstructibleArrayType::value_type>(),
4061 void())
4062 {
4063     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4064     {
4065         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4066     }
4067
4068     from_json_array_impl(j, arr, priority_tag<3> {});
4069 }
4070
4071 template < typename BasicJsonType, typename T, std::size_t... Idx >
4072 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4073         identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
4074 {
4075     return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4076 }
4077
4078 template < typename BasicJsonType, typename T, std::size_t N >
4079 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4080 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4081 {
4082     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4083     {
4084         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4085     }
4086
4087     return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4088 }
4089
4090 template<typename BasicJsonType>
4091 void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
4092 {
4093     if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
4094     {
4095         JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), j));
4096     }
4097
4098     bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4099 }
4100
4101 template<typename BasicJsonType, typename ConstructibleObjectType,
4102          enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
4103 void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
4104 {
4105     if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
4106     {
4107         JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), j));
4108     }
4109
4110     ConstructibleObjectType ret;
4111     const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4112     using value_type = typename ConstructibleObjectType::value_type;
4113     std::transform(
4114         inner_object->begin(), inner_object->end(),
4115         std::inserter(ret, ret.begin()),
4116         [](typename BasicJsonType::object_t::value_type const & p)
4117     {
4118         return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
4119     });
4120     obj = std::move(ret);
4121 }
4122
4123 // overload for arithmetic types, not chosen for basic_json template arguments
4124 // (BooleanType, etc..); note: Is it really necessary to provide explicit
4125 // overloads for boolean_t etc. in case of a custom BooleanType which is not
4126 // an arithmetic type?
4127 template < typename BasicJsonType, typename ArithmeticType,
4128            enable_if_t <
4129                std::is_arithmetic<ArithmeticType>::value&&
4130                !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4131                !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4132                !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4133                !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4134                int > = 0 >
4135 void from_json(const BasicJsonType& j, ArithmeticType& val)
4136 {
4137     switch (static_cast<value_t>(j))
4138     {
4139         case value_t::number_unsigned:
4140         {
4141             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4142             break;
4143         }
4144         case value_t::number_integer:
4145         {
4146             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4147             break;
4148         }
4149         case value_t::number_float:
4150         {
4151             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4152             break;
4153         }
4154         case value_t::boolean:
4155         {
4156             val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4157             break;
4158         }
4159
4160         case value_t::null:
4161         case value_t::object:
4162         case value_t::array:
4163         case value_t::string:
4164         case value_t::binary:
4165         case value_t::discarded:
4166         default:
4167             JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
4168     }
4169 }
4170
4171 template<typename BasicJsonType, typename... Args, std::size_t... Idx>
4172 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
4173 {
4174     return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
4175 }
4176
4177 template < typename BasicJsonType, class A1, class A2 >
4178 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
4179 {
4180     return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4181             std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4182 }
4183
4184 template<typename BasicJsonType, typename A1, typename A2>
4185 void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
4186 {
4187     p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
4188 }
4189
4190 template<typename BasicJsonType, typename... Args>
4191 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
4192 {
4193     return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4194 }
4195
4196 template<typename BasicJsonType, typename... Args>
4197 void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
4198 {
4199     t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4200 }
4201
4202 template<typename BasicJsonType, typename TupleRelated>
4203 auto from_json(BasicJsonType&& j, TupleRelated&& t)
4204 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
4205 {
4206     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4207     {
4208         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4209     }
4210
4211     return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4212 }
4213
4214 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
4215            typename = enable_if_t < !std::is_constructible <
4216                                         typename BasicJsonType::string_t, Key >::value >>
4217 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4218 {
4219     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4220     {
4221         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4222     }
4223     m.clear();
4224     for (const auto& p : j)
4225     {
4226         if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4227         {
4228             JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
4229         }
4230         m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4231     }
4232 }
4233
4234 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
4235            typename = enable_if_t < !std::is_constructible <
4236                                         typename BasicJsonType::string_t, Key >::value >>
4237 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
4238 {
4239     if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
4240     {
4241         JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
4242     }
4243     m.clear();
4244     for (const auto& p : j)
4245     {
4246         if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
4247         {
4248             JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
4249         }
4250         m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
4251     }
4252 }
4253
4254 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
4255 template<typename BasicJsonType>
4256 void from_json(const BasicJsonType& j, std_fs::path& p)
4257 {
4258     if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
4259     {
4260         JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
4261     }
4262     p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4263 }
4264 #endif
4265
4266 struct from_json_fn
4267 {
4268     template<typename BasicJsonType, typename T>
4269     auto operator()(const BasicJsonType& j, T&& val) const
4270     noexcept(noexcept(from_json(j, std::forward<T>(val))))
4271     -> decltype(from_json(j, std::forward<T>(val)))
4272     {
4273         return from_json(j, std::forward<T>(val));
4274     }
4275 };
4276 }  // namespace detail
4277
4278 /// namespace to hold default `from_json` function
4279 /// to see why this is required:
4280 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
4281 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
4282 {
4283 constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value; // NOLINT(misc-definitions-in-headers)
4284 } // namespace
4285 } // namespace nlohmann
4286
4287 // #include <nlohmann/detail/conversions/to_json.hpp>
4288
4289
4290 #include <algorithm> // copy
4291 #include <iterator> // begin, end
4292 #include <string> // string
4293 #include <tuple> // tuple, get
4294 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
4295 #include <utility> // move, forward, declval, pair
4296 #include <valarray> // valarray
4297 #include <vector> // vector
4298
4299 // #include <nlohmann/detail/macro_scope.hpp>
4300
4301 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
4302
4303
4304 #include <cstddef> // size_t
4305 #include <iterator> // input_iterator_tag
4306 #include <string> // string, to_string
4307 #include <tuple> // tuple_size, get, tuple_element
4308 #include <utility> // move
4309
4310 // #include <nlohmann/detail/meta/type_traits.hpp>
4311
4312 // #include <nlohmann/detail/value_t.hpp>
4313
4314
4315 namespace nlohmann
4316 {
4317 namespace detail
4318 {
4319 template<typename string_type>
4320 void int_to_string( string_type& target, std::size_t value )
4321 {
4322     // For ADL
4323     using std::to_string;
4324     target = to_string(value);
4325 }
4326 template<typename IteratorType> class iteration_proxy_value
4327 {
4328   public:
4329     using difference_type = std::ptrdiff_t;
4330     using value_type = iteration_proxy_value;
4331     using pointer = value_type * ;
4332     using reference = value_type & ;
4333     using iterator_category = std::input_iterator_tag;
4334     using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
4335
4336   private:
4337     /// the iterator
4338     IteratorType anchor;
4339     /// an index for arrays (used to create key names)
4340     std::size_t array_index = 0;
4341     /// last stringified array index
4342     mutable std::size_t array_index_last = 0;
4343     /// a string representation of the array index
4344     mutable string_type array_index_str = "0";
4345     /// an empty string (to return a reference for primitive values)
4346     const string_type empty_str{};
4347
4348   public:
4349     explicit iteration_proxy_value(IteratorType it) noexcept
4350         : anchor(std::move(it))
4351     {}
4352
4353     /// dereference operator (needed for range-based for)
4354     iteration_proxy_value& operator*()
4355     {
4356         return *this;
4357     }
4358
4359     /// increment operator (needed for range-based for)
4360     iteration_proxy_value& operator++()
4361     {
4362         ++anchor;
4363         ++array_index;
4364
4365         return *this;
4366     }
4367
4368     /// equality operator (needed for InputIterator)
4369     bool operator==(const iteration_proxy_value& o) const
4370     {
4371         return anchor == o.anchor;
4372     }
4373
4374     /// inequality operator (needed for range-based for)
4375     bool operator!=(const iteration_proxy_value& o) const
4376     {
4377         return anchor != o.anchor;
4378     }
4379
4380     /// return key of the iterator
4381     const string_type& key() const
4382     {
4383         JSON_ASSERT(anchor.m_object != nullptr);
4384
4385         switch (anchor.m_object->type())
4386         {
4387             // use integer array index as key
4388             case value_t::array:
4389             {
4390                 if (array_index != array_index_last)
4391                 {
4392                     int_to_string( array_index_str, array_index );
4393                     array_index_last = array_index;
4394                 }
4395                 return array_index_str;
4396             }
4397
4398             // use key from the object
4399             case value_t::object:
4400                 return anchor.key();
4401
4402             // use an empty key for all primitive types
4403             case value_t::null:
4404             case value_t::string:
4405             case value_t::boolean:
4406             case value_t::number_integer:
4407             case value_t::number_unsigned:
4408             case value_t::number_float:
4409             case value_t::binary:
4410             case value_t::discarded:
4411             default:
4412                 return empty_str;
4413         }
4414     }
4415
4416     /// return value of the iterator
4417     typename IteratorType::reference value() const
4418     {
4419         return anchor.value();
4420     }
4421 };
4422
4423 /// proxy class for the items() function
4424 template<typename IteratorType> class iteration_proxy
4425 {
4426   private:
4427     /// the container to iterate
4428     typename IteratorType::reference container;
4429
4430   public:
4431     /// construct iteration proxy from a container
4432     explicit iteration_proxy(typename IteratorType::reference cont) noexcept
4433         : container(cont) {}
4434
4435     /// return iterator begin (needed for range-based for)
4436     iteration_proxy_value<IteratorType> begin() noexcept
4437     {
4438         return iteration_proxy_value<IteratorType>(container.begin());
4439     }
4440
4441     /// return iterator end (needed for range-based for)
4442     iteration_proxy_value<IteratorType> end() noexcept
4443     {
4444         return iteration_proxy_value<IteratorType>(container.end());
4445     }
4446 };
4447 // Structured Bindings Support
4448 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
4449 // And see https://github.com/nlohmann/json/pull/1391
4450 template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
4451 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
4452 {
4453     return i.key();
4454 }
4455 // Structured Bindings Support
4456 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
4457 // And see https://github.com/nlohmann/json/pull/1391
4458 template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
4459 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
4460 {
4461     return i.value();
4462 }
4463 }  // namespace detail
4464 }  // namespace nlohmann
4465
4466 // The Addition to the STD Namespace is required to add
4467 // Structured Bindings Support to the iteration_proxy_value class
4468 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
4469 // And see https://github.com/nlohmann/json/pull/1391
4470 namespace std
4471 {
4472 #if defined(__clang__)
4473     // Fix: https://github.com/nlohmann/json/issues/1401
4474     #pragma clang diagnostic push
4475     #pragma clang diagnostic ignored "-Wmismatched-tags"
4476 #endif
4477 template<typename IteratorType>
4478 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
4479             : public std::integral_constant<std::size_t, 2> {};
4480
4481 template<std::size_t N, typename IteratorType>
4482 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
4483 {
4484   public:
4485     using type = decltype(
4486                      get<N>(std::declval <
4487                             ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
4488 };
4489 #if defined(__clang__)
4490     #pragma clang diagnostic pop
4491 #endif
4492 } // namespace std
4493
4494 // #include <nlohmann/detail/meta/cpp_future.hpp>
4495
4496 // #include <nlohmann/detail/meta/type_traits.hpp>
4497
4498 // #include <nlohmann/detail/value_t.hpp>
4499
4500
4501 #if JSON_HAS_EXPERIMENTAL_FILESYSTEM
4502 #include <experimental/filesystem>
4503 namespace nlohmann::detail
4504 {
4505 namespace std_fs = std::experimental::filesystem;
4506 } // namespace nlohmann::detail
4507 #elif JSON_HAS_FILESYSTEM
4508 #include <filesystem>
4509 namespace nlohmann::detail
4510 {
4511 namespace std_fs = std::filesystem;
4512 } // namespace nlohmann::detail
4513 #endif
4514
4515 namespace nlohmann
4516 {
4517 namespace detail
4518 {
4519 //////////////////
4520 // constructors //
4521 //////////////////
4522
4523 /*
4524  * Note all external_constructor<>::construct functions need to call
4525  * j.m_value.destroy(j.m_type) to avoid a memory leak in case j contains an
4526  * allocated value (e.g., a string). See bug issue
4527  * https://github.com/nlohmann/json/issues/2865 for more information.
4528  */
4529
4530 template<value_t> struct external_constructor;
4531
4532 template<>
4533 struct external_constructor<value_t::boolean>
4534 {
4535     template<typename BasicJsonType>
4536     static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
4537     {
4538         j.m_value.destroy(j.m_type);
4539         j.m_type = value_t::boolean;
4540         j.m_value = b;
4541         j.assert_invariant();
4542     }
4543 };
4544
4545 template<>
4546 struct external_constructor<value_t::string>
4547 {
4548     template<typename BasicJsonType>
4549     static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
4550     {
4551         j.m_value.destroy(j.m_type);
4552         j.m_type = value_t::string;
4553         j.m_value = s;
4554         j.assert_invariant();
4555     }
4556
4557     template<typename BasicJsonType>
4558     static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4559     {
4560         j.m_value.destroy(j.m_type);
4561         j.m_type = value_t::string;
4562         j.m_value = std::move(s);
4563         j.assert_invariant();
4564     }
4565
4566     template < typename BasicJsonType, typename CompatibleStringType,
4567                enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4568                              int > = 0 >
4569     static void construct(BasicJsonType& j, const CompatibleStringType& str)
4570     {
4571         j.m_value.destroy(j.m_type);
4572         j.m_type = value_t::string;
4573         j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4574         j.assert_invariant();
4575     }
4576 };
4577
4578 template<>
4579 struct external_constructor<value_t::binary>
4580 {
4581     template<typename BasicJsonType>
4582     static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
4583     {
4584         j.m_value.destroy(j.m_type);
4585         j.m_type = value_t::binary;
4586         j.m_value = typename BasicJsonType::binary_t(b);
4587         j.assert_invariant();
4588     }
4589
4590     template<typename BasicJsonType>
4591     static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
4592     {
4593         j.m_value.destroy(j.m_type);
4594         j.m_type = value_t::binary;
4595         j.m_value = typename BasicJsonType::binary_t(std::move(b));
4596         j.assert_invariant();
4597     }
4598 };
4599
4600 template<>
4601 struct external_constructor<value_t::number_float>
4602 {
4603     template<typename BasicJsonType>
4604     static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
4605     {
4606         j.m_value.destroy(j.m_type);
4607         j.m_type = value_t::number_float;
4608         j.m_value = val;
4609         j.assert_invariant();
4610     }
4611 };
4612
4613 template<>
4614 struct external_constructor<value_t::number_unsigned>
4615 {
4616     template<typename BasicJsonType>
4617     static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
4618     {
4619         j.m_value.destroy(j.m_type);
4620         j.m_type = value_t::number_unsigned;
4621         j.m_value = val;
4622         j.assert_invariant();
4623     }
4624 };
4625
4626 template<>
4627 struct external_constructor<value_t::number_integer>
4628 {
4629     template<typename BasicJsonType>
4630     static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
4631     {
4632         j.m_value.destroy(j.m_type);
4633         j.m_type = value_t::number_integer;
4634         j.m_value = val;
4635         j.assert_invariant();
4636     }
4637 };
4638
4639 template<>
4640 struct external_constructor<value_t::array>
4641 {
4642     template<typename BasicJsonType>
4643     static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
4644     {
4645         j.m_value.destroy(j.m_type);
4646         j.m_type = value_t::array;
4647         j.m_value = arr;
4648         j.set_parents();
4649         j.assert_invariant();
4650     }
4651
4652     template<typename BasicJsonType>
4653     static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4654     {
4655         j.m_value.destroy(j.m_type);
4656         j.m_type = value_t::array;
4657         j.m_value = std::move(arr);
4658         j.set_parents();
4659         j.assert_invariant();
4660     }
4661
4662     template < typename BasicJsonType, typename CompatibleArrayType,
4663                enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4664                              int > = 0 >
4665     static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
4666     {
4667         using std::begin;
4668         using std::end;
4669
4670         j.m_value.destroy(j.m_type);
4671         j.m_type = value_t::array;
4672         j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4673         j.set_parents();
4674         j.assert_invariant();
4675     }
4676
4677     template<typename BasicJsonType>
4678     static void construct(BasicJsonType& j, const std::vector<bool>& arr)
4679     {
4680         j.m_value.destroy(j.m_type);
4681         j.m_type = value_t::array;
4682         j.m_value = value_t::array;
4683         j.m_value.array->reserve(arr.size());
4684         for (const bool x : arr)
4685         {
4686             j.m_value.array->push_back(x);
4687             j.set_parent(j.m_value.array->back());
4688         }
4689         j.assert_invariant();
4690     }
4691
4692     template<typename BasicJsonType, typename T,
4693              enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
4694     static void construct(BasicJsonType& j, const std::valarray<T>& arr)
4695     {
4696         j.m_value.destroy(j.m_type);
4697         j.m_type = value_t::array;
4698         j.m_value = value_t::array;
4699         j.m_value.array->resize(arr.size());
4700         if (arr.size() > 0)
4701         {
4702             std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4703         }
4704         j.set_parents();
4705         j.assert_invariant();
4706     }
4707 };
4708
4709 template<>
4710 struct external_constructor<value_t::object>
4711 {
4712     template<typename BasicJsonType>
4713     static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
4714     {
4715         j.m_value.destroy(j.m_type);
4716         j.m_type = value_t::object;
4717         j.m_value = obj;
4718         j.set_parents();
4719         j.assert_invariant();
4720     }
4721
4722     template<typename BasicJsonType>
4723     static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4724     {
4725         j.m_value.destroy(j.m_type);
4726         j.m_type = value_t::object;
4727         j.m_value = std::move(obj);
4728         j.set_parents();
4729         j.assert_invariant();
4730     }
4731
4732     template < typename BasicJsonType, typename CompatibleObjectType,
4733                enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
4734     static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
4735     {
4736         using std::begin;
4737         using std::end;
4738
4739         j.m_value.destroy(j.m_type);
4740         j.m_type = value_t::object;
4741         j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4742         j.set_parents();
4743         j.assert_invariant();
4744     }
4745 };
4746
4747 /////////////
4748 // to_json //
4749 /////////////
4750
4751 template<typename BasicJsonType, typename T,
4752          enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
4753 void to_json(BasicJsonType& j, T b) noexcept
4754 {
4755     external_constructor<value_t::boolean>::construct(j, b);
4756 }
4757
4758 template<typename BasicJsonType, typename CompatibleString,
4759          enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
4760 void to_json(BasicJsonType& j, const CompatibleString& s)
4761 {
4762     external_constructor<value_t::string>::construct(j, s);
4763 }
4764
4765 template<typename BasicJsonType>
4766 void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4767 {
4768     external_constructor<value_t::string>::construct(j, std::move(s));
4769 }
4770
4771 template<typename BasicJsonType, typename FloatType,
4772          enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
4773 void to_json(BasicJsonType& j, FloatType val) noexcept
4774 {
4775     external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
4776 }
4777
4778 template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
4779          enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
4780 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4781 {
4782     external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
4783 }
4784
4785 template<typename BasicJsonType, typename CompatibleNumberIntegerType,
4786          enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
4787 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4788 {
4789     external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
4790 }
4791
4792 template<typename BasicJsonType, typename EnumType,
4793          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
4794 void to_json(BasicJsonType& j, EnumType e) noexcept
4795 {
4796     using underlying_type = typename std::underlying_type<EnumType>::type;
4797     external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
4798 }
4799
4800 template<typename BasicJsonType>
4801 void to_json(BasicJsonType& j, const std::vector<bool>& e)
4802 {
4803     external_constructor<value_t::array>::construct(j, e);
4804 }
4805
4806 template < typename BasicJsonType, typename CompatibleArrayType,
4807            enable_if_t < is_compatible_array_type<BasicJsonType,
4808                          CompatibleArrayType>::value&&
4809                          !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4810                          !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4811                          !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4812                          !is_basic_json<CompatibleArrayType>::value,
4813                          int > = 0 >
4814 void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
4815 {
4816     external_constructor<value_t::array>::construct(j, arr);
4817 }
4818
4819 template<typename BasicJsonType>
4820 void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
4821 {
4822     external_constructor<value_t::binary>::construct(j, bin);
4823 }
4824
4825 template<typename BasicJsonType, typename T,
4826          enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
4827 void to_json(BasicJsonType& j, const std::valarray<T>& arr)
4828 {
4829     external_constructor<value_t::array>::construct(j, std::move(arr));
4830 }
4831
4832 template<typename BasicJsonType>
4833 void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4834 {
4835     external_constructor<value_t::array>::construct(j, std::move(arr));
4836 }
4837
4838 template < typename BasicJsonType, typename CompatibleObjectType,
4839            enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
4840 void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
4841 {
4842     external_constructor<value_t::object>::construct(j, obj);
4843 }
4844
4845 template<typename BasicJsonType>
4846 void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4847 {
4848     external_constructor<value_t::object>::construct(j, std::move(obj));
4849 }
4850
4851 template <
4852     typename BasicJsonType, typename T, std::size_t N,
4853     enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
4854                   const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4855                   int > = 0 >
4856 void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4857 {
4858     external_constructor<value_t::array>::construct(j, arr);
4859 }
4860
4861 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
4862 void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
4863 {
4864     j = { p.first, p.second };
4865 }
4866
4867 // for https://github.com/nlohmann/json/pull/1134
4868 template<typename BasicJsonType, typename T,
4869          enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
4870 void to_json(BasicJsonType& j, const T& b)
4871 {
4872     j = { {b.key(), b.value()} };
4873 }
4874
4875 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
4876 void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
4877 {
4878     j = { std::get<Idx>(t)... };
4879 }
4880
4881 template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
4882 void to_json(BasicJsonType& j, const T& t)
4883 {
4884     to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4885 }
4886
4887 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
4888 template<typename BasicJsonType>
4889 void to_json(BasicJsonType& j, const std_fs::path& p)
4890 {
4891     j = p.string();
4892 }
4893 #endif
4894
4895 struct to_json_fn
4896 {
4897     template<typename BasicJsonType, typename T>
4898     auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
4899     -> decltype(to_json(j, std::forward<T>(val)), void())
4900     {
4901         return to_json(j, std::forward<T>(val));
4902     }
4903 };
4904 }  // namespace detail
4905
4906 /// namespace to hold default `to_json` function
4907 /// to see why this is required:
4908 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
4909 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
4910 {
4911 constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value; // NOLINT(misc-definitions-in-headers)
4912 } // namespace
4913 } // namespace nlohmann
4914
4915 // #include <nlohmann/detail/meta/identity_tag.hpp>
4916
4917 // #include <nlohmann/detail/meta/type_traits.hpp>
4918
4919
4920 namespace nlohmann
4921 {
4922
4923 /// @sa https://json.nlohmann.me/api/adl_serializer/
4924 template<typename ValueType, typename>
4925 struct adl_serializer
4926 {
4927     /// @brief convert a JSON value to any value type
4928     /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
4929     template<typename BasicJsonType, typename TargetType = ValueType>
4930     static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
4931         noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4932     -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
4933     {
4934         ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4935     }
4936
4937     /// @brief convert a JSON value to any value type
4938     /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
4939     template<typename BasicJsonType, typename TargetType = ValueType>
4940     static auto from_json(BasicJsonType && j) noexcept(
4941     noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
4942     -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
4943     {
4944         return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
4945     }
4946
4947     /// @brief convert any value type to a JSON value
4948     /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
4949     template<typename BasicJsonType, typename TargetType = ValueType>
4950     static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
4951         noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
4952     -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
4953     {
4954         ::nlohmann::to_json(j, std::forward<TargetType>(val));
4955     }
4956 };
4957 }  // namespace nlohmann
4958
4959 // #include <nlohmann/byte_container_with_subtype.hpp>
4960
4961
4962 #include <cstdint> // uint8_t, uint64_t
4963 #include <tuple> // tie
4964 #include <utility> // move
4965
4966 namespace nlohmann
4967 {
4968
4969 /// @brief an internal type for a backed binary type
4970 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
4971 template<typename BinaryType>
4972 class byte_container_with_subtype : public BinaryType
4973 {
4974   public:
4975     using container_type = BinaryType;
4976     using subtype_type = std::uint64_t;
4977
4978     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4979     byte_container_with_subtype() noexcept(noexcept(container_type()))
4980         : container_type()
4981     {}
4982
4983     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4984     byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
4985         : container_type(b)
4986     {}
4987
4988     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4989     byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
4990         : container_type(std::move(b))
4991     {}
4992
4993     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
4994     byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
4995         : container_type(b)
4996         , m_subtype(subtype_)
4997         , m_has_subtype(true)
4998     {}
4999
5000     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
5001     byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
5002         : container_type(std::move(b))
5003         , m_subtype(subtype_)
5004         , m_has_subtype(true)
5005     {}
5006
5007     bool operator==(const byte_container_with_subtype& rhs) const
5008     {
5009         return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
5010                std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
5011     }
5012
5013     bool operator!=(const byte_container_with_subtype& rhs) const
5014     {
5015         return !(rhs == *this);
5016     }
5017
5018     /// @brief sets the binary subtype
5019     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
5020     void set_subtype(subtype_type subtype_) noexcept
5021     {
5022         m_subtype = subtype_;
5023         m_has_subtype = true;
5024     }
5025
5026     /// @brief return the binary subtype
5027     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
5028     constexpr subtype_type subtype() const noexcept
5029     {
5030         return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
5031     }
5032
5033     /// @brief return whether the value has a subtype
5034     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
5035     constexpr bool has_subtype() const noexcept
5036     {
5037         return m_has_subtype;
5038     }
5039
5040     /// @brief clears the binary subtype
5041     /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
5042     void clear_subtype() noexcept
5043     {
5044         m_subtype = 0;
5045         m_has_subtype = false;
5046     }
5047
5048   private:
5049     subtype_type m_subtype = 0;
5050     bool m_has_subtype = false;
5051 };
5052
5053 }  // namespace nlohmann
5054
5055 // #include <nlohmann/detail/conversions/from_json.hpp>
5056
5057 // #include <nlohmann/detail/conversions/to_json.hpp>
5058
5059 // #include <nlohmann/detail/exceptions.hpp>
5060
5061 // #include <nlohmann/detail/hash.hpp>
5062
5063
5064 #include <cstdint> // uint8_t
5065 #include <cstddef> // size_t
5066 #include <functional> // hash
5067
5068 // #include <nlohmann/detail/macro_scope.hpp>
5069
5070 // #include <nlohmann/detail/value_t.hpp>
5071
5072
5073 namespace nlohmann
5074 {
5075 namespace detail
5076 {
5077
5078 // boost::hash_combine
5079 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
5080 {
5081     seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
5082     return seed;
5083 }
5084
5085 /*!
5086 @brief hash a JSON value
5087
5088 The hash function tries to rely on std::hash where possible. Furthermore, the
5089 type of the JSON value is taken into account to have different hash values for
5090 null, 0, 0U, and false, etc.
5091
5092 @tparam BasicJsonType basic_json specialization
5093 @param j JSON value to hash
5094 @return hash value of j
5095 */
5096 template<typename BasicJsonType>
5097 std::size_t hash(const BasicJsonType& j)
5098 {
5099     using string_t = typename BasicJsonType::string_t;
5100     using number_integer_t = typename BasicJsonType::number_integer_t;
5101     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5102     using number_float_t = typename BasicJsonType::number_float_t;
5103
5104     const auto type = static_cast<std::size_t>(j.type());
5105     switch (j.type())
5106     {
5107         case BasicJsonType::value_t::null:
5108         case BasicJsonType::value_t::discarded:
5109         {
5110             return combine(type, 0);
5111         }
5112
5113         case BasicJsonType::value_t::object:
5114         {
5115             auto seed = combine(type, j.size());
5116             for (const auto& element : j.items())
5117             {
5118                 const auto h = std::hash<string_t> {}(element.key());
5119                 seed = combine(seed, h);
5120                 seed = combine(seed, hash(element.value()));
5121             }
5122             return seed;
5123         }
5124
5125         case BasicJsonType::value_t::array:
5126         {
5127             auto seed = combine(type, j.size());
5128             for (const auto& element : j)
5129             {
5130                 seed = combine(seed, hash(element));
5131             }
5132             return seed;
5133         }
5134
5135         case BasicJsonType::value_t::string:
5136         {
5137             const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5138             return combine(type, h);
5139         }
5140
5141         case BasicJsonType::value_t::boolean:
5142         {
5143             const auto h = std::hash<bool> {}(j.template get<bool>());
5144             return combine(type, h);
5145         }
5146
5147         case BasicJsonType::value_t::number_integer:
5148         {
5149             const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
5150             return combine(type, h);
5151         }
5152
5153         case BasicJsonType::value_t::number_unsigned:
5154         {
5155             const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
5156             return combine(type, h);
5157         }
5158
5159         case BasicJsonType::value_t::number_float:
5160         {
5161             const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
5162             return combine(type, h);
5163         }
5164
5165         case BasicJsonType::value_t::binary:
5166         {
5167             auto seed = combine(type, j.get_binary().size());
5168             const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
5169             seed = combine(seed, h);
5170             seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
5171             for (const auto byte : j.get_binary())
5172             {
5173                 seed = combine(seed, std::hash<std::uint8_t> {}(byte));
5174             }
5175             return seed;
5176         }
5177
5178         default:                   // LCOV_EXCL_LINE
5179             JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
5180             return 0;              // LCOV_EXCL_LINE
5181     }
5182 }
5183
5184 }  // namespace detail
5185 }  // namespace nlohmann
5186
5187 // #include <nlohmann/detail/input/binary_reader.hpp>
5188
5189
5190 #include <algorithm> // generate_n
5191 #include <array> // array
5192 #include <cmath> // ldexp
5193 #include <cstddef> // size_t
5194 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
5195 #include <cstdio> // snprintf
5196 #include <cstring> // memcpy
5197 #include <iterator> // back_inserter
5198 #include <limits> // numeric_limits
5199 #include <string> // char_traits, string
5200 #include <utility> // make_pair, move
5201 #include <vector> // vector
5202
5203 // #include <nlohmann/detail/exceptions.hpp>
5204
5205 // #include <nlohmann/detail/input/input_adapters.hpp>
5206
5207
5208 #include <array> // array
5209 #include <cstddef> // size_t
5210 #include <cstring> // strlen
5211 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
5212 #include <memory> // shared_ptr, make_shared, addressof
5213 #include <numeric> // accumulate
5214 #include <string> // string, char_traits
5215 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
5216 #include <utility> // pair, declval
5217
5218 #ifndef JSON_NO_IO
5219     #include <cstdio>   // FILE *
5220     #include <istream>  // istream
5221 #endif                  // JSON_NO_IO
5222
5223 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
5224
5225 // #include <nlohmann/detail/macro_scope.hpp>
5226
5227
5228 namespace nlohmann
5229 {
5230 namespace detail
5231 {
5232 /// the supported input formats
5233 enum class input_format_t { json, cbor, msgpack, ubjson, bson };
5234
5235 ////////////////////
5236 // input adapters //
5237 ////////////////////
5238
5239 #ifndef JSON_NO_IO
5240 /*!
5241 Input adapter for stdio file access. This adapter read only 1 byte and do not use any
5242  buffer. This adapter is a very low level adapter.
5243 */
5244 class file_input_adapter
5245 {
5246   public:
5247     using char_type = char;
5248
5249     JSON_HEDLEY_NON_NULL(2)
5250     explicit file_input_adapter(std::FILE* f) noexcept
5251         : m_file(f)
5252     {}
5253
5254     // make class move-only
5255     file_input_adapter(const file_input_adapter&) = delete;
5256     file_input_adapter(file_input_adapter&&) noexcept = default;
5257     file_input_adapter& operator=(const file_input_adapter&) = delete;
5258     file_input_adapter& operator=(file_input_adapter&&) = delete;
5259     ~file_input_adapter() = default;
5260
5261     std::char_traits<char>::int_type get_character() noexcept
5262     {
5263         return std::fgetc(m_file);
5264     }
5265
5266   private:
5267     /// the file pointer to read from
5268     std::FILE* m_file;
5269 };
5270
5271
5272 /*!
5273 Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
5274 beginning of input. Does not support changing the underlying std::streambuf
5275 in mid-input. Maintains underlying std::istream and std::streambuf to support
5276 subsequent use of standard std::istream operations to process any input
5277 characters following those used in parsing the JSON input.  Clears the
5278 std::istream flags; any input errors (e.g., EOF) will be detected by the first
5279 subsequent call for input from the std::istream.
5280 */
5281 class input_stream_adapter
5282 {
5283   public:
5284     using char_type = char;
5285
5286     ~input_stream_adapter()
5287     {
5288         // clear stream flags; we use underlying streambuf I/O, do not
5289         // maintain ifstream flags, except eof
5290         if (is != nullptr)
5291         {
5292             is->clear(is->rdstate() & std::ios::eofbit);
5293         }
5294     }
5295
5296     explicit input_stream_adapter(std::istream& i)
5297         : is(&i), sb(i.rdbuf())
5298     {}
5299
5300     // delete because of pointer members
5301     input_stream_adapter(const input_stream_adapter&) = delete;
5302     input_stream_adapter& operator=(input_stream_adapter&) = delete;
5303     input_stream_adapter& operator=(input_stream_adapter&&) = delete;
5304
5305     input_stream_adapter(input_stream_adapter&& rhs) noexcept
5306         : is(rhs.is), sb(rhs.sb)
5307     {
5308         rhs.is = nullptr;
5309         rhs.sb = nullptr;
5310     }
5311
5312     // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
5313     // ensure that std::char_traits<char>::eof() and the character 0xFF do not
5314     // end up as the same value, e.g. 0xFFFFFFFF.
5315     std::char_traits<char>::int_type get_character()
5316     {
5317         auto res = sb->sbumpc();
5318         // set eof manually, as we don't use the istream interface.
5319         if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
5320         {
5321             is->clear(is->rdstate() | std::ios::eofbit);
5322         }
5323         return res;
5324     }
5325
5326   private:
5327     /// the associated input stream
5328     std::istream* is = nullptr;
5329     std::streambuf* sb = nullptr;
5330 };
5331 #endif  // JSON_NO_IO
5332
5333 // General-purpose iterator-based adapter. It might not be as fast as
5334 // theoretically possible for some containers, but it is extremely versatile.
5335 template<typename IteratorType>
5336 class iterator_input_adapter
5337 {
5338   public:
5339     using char_type = typename std::iterator_traits<IteratorType>::value_type;
5340
5341     iterator_input_adapter(IteratorType first, IteratorType last)
5342         : current(std::move(first)), end(std::move(last))
5343     {}
5344
5345     typename std::char_traits<char_type>::int_type get_character()
5346     {
5347         if (JSON_HEDLEY_LIKELY(current != end))
5348         {
5349             auto result = std::char_traits<char_type>::to_int_type(*current);
5350             std::advance(current, 1);
5351             return result;
5352         }
5353
5354         return std::char_traits<char_type>::eof();
5355     }
5356
5357   private:
5358     IteratorType current;
5359     IteratorType end;
5360
5361     template<typename BaseInputAdapter, size_t T>
5362     friend struct wide_string_input_helper;
5363
5364     bool empty() const
5365     {
5366         return current == end;
5367     }
5368 };
5369
5370
5371 template<typename BaseInputAdapter, size_t T>
5372 struct wide_string_input_helper;
5373
5374 template<typename BaseInputAdapter>
5375 struct wide_string_input_helper<BaseInputAdapter, 4>
5376 {
5377     // UTF-32
5378     static void fill_buffer(BaseInputAdapter& input,
5379                             std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5380                             size_t& utf8_bytes_index,
5381                             size_t& utf8_bytes_filled)
5382     {
5383         utf8_bytes_index = 0;
5384
5385         if (JSON_HEDLEY_UNLIKELY(input.empty()))
5386         {
5387             utf8_bytes[0] = std::char_traits<char>::eof();
5388             utf8_bytes_filled = 1;
5389         }
5390         else
5391         {
5392             // get the current character
5393             const auto wc = input.get_character();
5394
5395             // UTF-32 to UTF-8 encoding
5396             if (wc < 0x80)
5397             {
5398                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5399                 utf8_bytes_filled = 1;
5400             }
5401             else if (wc <= 0x7FF)
5402             {
5403                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
5404                 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5405                 utf8_bytes_filled = 2;
5406             }
5407             else if (wc <= 0xFFFF)
5408             {
5409                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
5410                 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5411                 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5412                 utf8_bytes_filled = 3;
5413             }
5414             else if (wc <= 0x10FFFF)
5415             {
5416                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
5417                 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
5418                 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5419                 utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5420                 utf8_bytes_filled = 4;
5421             }
5422             else
5423             {
5424                 // unknown character
5425                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5426                 utf8_bytes_filled = 1;
5427             }
5428         }
5429     }
5430 };
5431
5432 template<typename BaseInputAdapter>
5433 struct wide_string_input_helper<BaseInputAdapter, 2>
5434 {
5435     // UTF-16
5436     static void fill_buffer(BaseInputAdapter& input,
5437                             std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
5438                             size_t& utf8_bytes_index,
5439                             size_t& utf8_bytes_filled)
5440     {
5441         utf8_bytes_index = 0;
5442
5443         if (JSON_HEDLEY_UNLIKELY(input.empty()))
5444         {
5445             utf8_bytes[0] = std::char_traits<char>::eof();
5446             utf8_bytes_filled = 1;
5447         }
5448         else
5449         {
5450             // get the current character
5451             const auto wc = input.get_character();
5452
5453             // UTF-16 to UTF-8 encoding
5454             if (wc < 0x80)
5455             {
5456                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5457                 utf8_bytes_filled = 1;
5458             }
5459             else if (wc <= 0x7FF)
5460             {
5461                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
5462                 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5463                 utf8_bytes_filled = 2;
5464             }
5465             else if (0xD800 > wc || wc >= 0xE000)
5466             {
5467                 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
5468                 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
5469                 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
5470                 utf8_bytes_filled = 3;
5471             }
5472             else
5473             {
5474                 if (JSON_HEDLEY_UNLIKELY(!input.empty()))
5475                 {
5476                     const auto wc2 = static_cast<unsigned int>(input.get_character());
5477                     const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
5478                     utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
5479                     utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
5480                     utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
5481                     utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
5482                     utf8_bytes_filled = 4;
5483                 }
5484                 else
5485                 {
5486                     utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
5487                     utf8_bytes_filled = 1;
5488                 }
5489             }
5490         }
5491     }
5492 };
5493
5494 // Wraps another input apdater to convert wide character types into individual bytes.
5495 template<typename BaseInputAdapter, typename WideCharType>
5496 class wide_string_input_adapter
5497 {
5498   public:
5499     using char_type = char;
5500
5501     wide_string_input_adapter(BaseInputAdapter base)
5502         : base_adapter(base) {}
5503
5504     typename std::char_traits<char>::int_type get_character() noexcept
5505     {
5506         // check if buffer needs to be filled
5507         if (utf8_bytes_index == utf8_bytes_filled)
5508         {
5509             fill_buffer<sizeof(WideCharType)>();
5510
5511             JSON_ASSERT(utf8_bytes_filled > 0);
5512             JSON_ASSERT(utf8_bytes_index == 0);
5513         }
5514
5515         // use buffer
5516         JSON_ASSERT(utf8_bytes_filled > 0);
5517         JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5518         return utf8_bytes[utf8_bytes_index++];
5519     }
5520
5521   private:
5522     BaseInputAdapter base_adapter;
5523
5524     template<size_t T>
5525     void fill_buffer()
5526     {
5527         wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
5528     }
5529
5530     /// a buffer for UTF-8 bytes
5531     std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5532
5533     /// index to the utf8_codes array for the next valid byte
5534     std::size_t utf8_bytes_index = 0;
5535     /// number of valid bytes in the utf8_codes array
5536     std::size_t utf8_bytes_filled = 0;
5537 };
5538
5539
5540 template<typename IteratorType, typename Enable = void>
5541 struct iterator_input_adapter_factory
5542 {
5543     using iterator_type = IteratorType;
5544     using char_type = typename std::iterator_traits<iterator_type>::value_type;
5545     using adapter_type = iterator_input_adapter<iterator_type>;
5546
5547     static adapter_type create(IteratorType first, IteratorType last)
5548     {
5549         return adapter_type(std::move(first), std::move(last));
5550     }
5551 };
5552
5553 template<typename T>
5554 struct is_iterator_of_multibyte
5555 {
5556     using value_type = typename std::iterator_traits<T>::value_type;
5557     enum
5558     {
5559         value = sizeof(value_type) > 1
5560     };
5561 };
5562
5563 template<typename IteratorType>
5564 struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5565 {
5566     using iterator_type = IteratorType;
5567     using char_type = typename std::iterator_traits<iterator_type>::value_type;
5568     using base_adapter_type = iterator_input_adapter<iterator_type>;
5569     using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
5570
5571     static adapter_type create(IteratorType first, IteratorType last)
5572     {
5573         return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5574     }
5575 };
5576
5577 // General purpose iterator-based input
5578 template<typename IteratorType>
5579 typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5580 {
5581     using factory_type = iterator_input_adapter_factory<IteratorType>;
5582     return factory_type::create(first, last);
5583 }
5584
5585 // Convenience shorthand from container to iterator
5586 // Enables ADL on begin(container) and end(container)
5587 // Encloses the using declarations in namespace for not to leak them to outside scope
5588
5589 namespace container_input_adapter_factory_impl
5590 {
5591
5592 using std::begin;
5593 using std::end;
5594
5595 template<typename ContainerType, typename Enable = void>
5596 struct container_input_adapter_factory {};
5597
5598 template<typename ContainerType>
5599 struct container_input_adapter_factory< ContainerType,
5600        void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
5601        {
5602            using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
5603
5604            static adapter_type create(const ContainerType& container)
5605 {
5606     return input_adapter(begin(container), end(container));
5607 }
5608        };
5609
5610 } // namespace container_input_adapter_factory_impl
5611
5612 template<typename ContainerType>
5613 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
5614 {
5615     return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
5616 }
5617
5618 #ifndef JSON_NO_IO
5619 // Special cases with fast paths
5620 inline file_input_adapter input_adapter(std::FILE* file)
5621 {
5622     return file_input_adapter(file);
5623 }
5624
5625 inline input_stream_adapter input_adapter(std::istream& stream)
5626 {
5627     return input_stream_adapter(stream);
5628 }
5629
5630 inline input_stream_adapter input_adapter(std::istream&& stream)
5631 {
5632     return input_stream_adapter(stream);
5633 }
5634 #endif  // JSON_NO_IO
5635
5636 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5637
5638 // Null-delimited strings, and the like.
5639 template < typename CharT,
5640            typename std::enable_if <
5641                std::is_pointer<CharT>::value&&
5642                !std::is_array<CharT>::value&&
5643                std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5644                sizeof(typename std::remove_pointer<CharT>::type) == 1,
5645                int >::type = 0 >
5646 contiguous_bytes_input_adapter input_adapter(CharT b)
5647 {
5648     auto length = std::strlen(reinterpret_cast<const char*>(b));
5649     const auto* ptr = reinterpret_cast<const char*>(b);
5650     return input_adapter(ptr, ptr + length);
5651 }
5652
5653 template<typename T, std::size_t N>
5654 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5655 {
5656     return input_adapter(array, array + N);
5657 }
5658
5659 // This class only handles inputs of input_buffer_adapter type.
5660 // It's required so that expressions like {ptr, len} can be implicitly cast
5661 // to the correct adapter.
5662 class span_input_adapter
5663 {
5664   public:
5665     template < typename CharT,
5666                typename std::enable_if <
5667                    std::is_pointer<CharT>::value&&
5668                    std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5669                    sizeof(typename std::remove_pointer<CharT>::type) == 1,
5670                    int >::type = 0 >
5671     span_input_adapter(CharT b, std::size_t l)
5672         : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5673
5674     template<class IteratorType,
5675              typename std::enable_if<
5676                  std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5677                  int>::type = 0>
5678     span_input_adapter(IteratorType first, IteratorType last)
5679         : ia(input_adapter(first, last)) {}
5680
5681     contiguous_bytes_input_adapter&& get()
5682     {
5683         return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
5684     }
5685
5686   private:
5687     contiguous_bytes_input_adapter ia;
5688 };
5689 }  // namespace detail
5690 }  // namespace nlohmann
5691
5692 // #include <nlohmann/detail/input/json_sax.hpp>
5693
5694
5695 #include <cstddef>
5696 #include <string> // string
5697 #include <utility> // move
5698 #include <vector> // vector
5699
5700 // #include <nlohmann/detail/exceptions.hpp>
5701
5702 // #include <nlohmann/detail/macro_scope.hpp>
5703
5704
5705 namespace nlohmann
5706 {
5707
5708 /*!
5709 @brief SAX interface
5710
5711 This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
5712 Each function is called in different situations while the input is parsed. The
5713 boolean return value informs the parser whether to continue processing the
5714 input.
5715 */
5716 template<typename BasicJsonType>
5717 struct json_sax
5718 {
5719     using number_integer_t = typename BasicJsonType::number_integer_t;
5720     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5721     using number_float_t = typename BasicJsonType::number_float_t;
5722     using string_t = typename BasicJsonType::string_t;
5723     using binary_t = typename BasicJsonType::binary_t;
5724
5725     /*!
5726     @brief a null value was read
5727     @return whether parsing should proceed
5728     */
5729     virtual bool null() = 0;
5730
5731     /*!
5732     @brief a boolean value was read
5733     @param[in] val  boolean value
5734     @return whether parsing should proceed
5735     */
5736     virtual bool boolean(bool val) = 0;
5737
5738     /*!
5739     @brief an integer number was read
5740     @param[in] val  integer value
5741     @return whether parsing should proceed
5742     */
5743     virtual bool number_integer(number_integer_t val) = 0;
5744
5745     /*!
5746     @brief an unsigned integer number was read
5747     @param[in] val  unsigned integer value
5748     @return whether parsing should proceed
5749     */
5750     virtual bool number_unsigned(number_unsigned_t val) = 0;
5751
5752     /*!
5753     @brief a floating-point number was read
5754     @param[in] val  floating-point value
5755     @param[in] s    raw token value
5756     @return whether parsing should proceed
5757     */
5758     virtual bool number_float(number_float_t val, const string_t& s) = 0;
5759
5760     /*!
5761     @brief a string value was read
5762     @param[in] val  string value
5763     @return whether parsing should proceed
5764     @note It is safe to move the passed string value.
5765     */
5766     virtual bool string(string_t& val) = 0;
5767
5768     /*!
5769     @brief a binary value was read
5770     @param[in] val  binary value
5771     @return whether parsing should proceed
5772     @note It is safe to move the passed binary value.
5773     */
5774     virtual bool binary(binary_t& val) = 0;
5775
5776     /*!
5777     @brief the beginning of an object was read
5778     @param[in] elements  number of object elements or -1 if unknown
5779     @return whether parsing should proceed
5780     @note binary formats may report the number of elements
5781     */
5782     virtual bool start_object(std::size_t elements) = 0;
5783
5784     /*!
5785     @brief an object key was read
5786     @param[in] val  object key
5787     @return whether parsing should proceed
5788     @note It is safe to move the passed string.
5789     */
5790     virtual bool key(string_t& val) = 0;
5791
5792     /*!
5793     @brief the end of an object was read
5794     @return whether parsing should proceed
5795     */
5796     virtual bool end_object() = 0;
5797
5798     /*!
5799     @brief the beginning of an array was read
5800     @param[in] elements  number of array elements or -1 if unknown
5801     @return whether parsing should proceed
5802     @note binary formats may report the number of elements
5803     */
5804     virtual bool start_array(std::size_t elements) = 0;
5805
5806     /*!
5807     @brief the end of an array was read
5808     @return whether parsing should proceed
5809     */
5810     virtual bool end_array() = 0;
5811
5812     /*!
5813     @brief a parse error occurred
5814     @param[in] position    the position in the input where the error occurs
5815     @param[in] last_token  the last read token
5816     @param[in] ex          an exception object describing the error
5817     @return whether parsing should proceed (must return false)
5818     */
5819     virtual bool parse_error(std::size_t position,
5820                              const std::string& last_token,
5821                              const detail::exception& ex) = 0;
5822
5823     json_sax() = default;
5824     json_sax(const json_sax&) = default;
5825     json_sax(json_sax&&) noexcept = default;
5826     json_sax& operator=(const json_sax&) = default;
5827     json_sax& operator=(json_sax&&) noexcept = default;
5828     virtual ~json_sax() = default;
5829 };
5830
5831
5832 namespace detail
5833 {
5834 /*!
5835 @brief SAX implementation to create a JSON value from SAX events
5836
5837 This class implements the @ref json_sax interface and processes the SAX events
5838 to create a JSON value which makes it basically a DOM parser. The structure or
5839 hierarchy of the JSON value is managed by the stack `ref_stack` which contains
5840 a pointer to the respective array or object for each recursion depth.
5841
5842 After successful parsing, the value that is passed by reference to the
5843 constructor contains the parsed value.
5844
5845 @tparam BasicJsonType  the JSON type
5846 */
5847 template<typename BasicJsonType>
5848 class json_sax_dom_parser
5849 {
5850   public:
5851     using number_integer_t = typename BasicJsonType::number_integer_t;
5852     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5853     using number_float_t = typename BasicJsonType::number_float_t;
5854     using string_t = typename BasicJsonType::string_t;
5855     using binary_t = typename BasicJsonType::binary_t;
5856
5857     /*!
5858     @param[in,out] r  reference to a JSON value that is manipulated while
5859                        parsing
5860     @param[in] allow_exceptions_  whether parse errors yield exceptions
5861     */
5862     explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
5863         : root(r), allow_exceptions(allow_exceptions_)
5864     {}
5865
5866     // make class move-only
5867     json_sax_dom_parser(const json_sax_dom_parser&) = delete;
5868     json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
5869     json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
5870     json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
5871     ~json_sax_dom_parser() = default;
5872
5873     bool null()
5874     {
5875         handle_value(nullptr);
5876         return true;
5877     }
5878
5879     bool boolean(bool val)
5880     {
5881         handle_value(val);
5882         return true;
5883     }
5884
5885     bool number_integer(number_integer_t val)
5886     {
5887         handle_value(val);
5888         return true;
5889     }
5890
5891     bool number_unsigned(number_unsigned_t val)
5892     {
5893         handle_value(val);
5894         return true;
5895     }
5896
5897     bool number_float(number_float_t val, const string_t& /*unused*/)
5898     {
5899         handle_value(val);
5900         return true;
5901     }
5902
5903     bool string(string_t& val)
5904     {
5905         handle_value(val);
5906         return true;
5907     }
5908
5909     bool binary(binary_t& val)
5910     {
5911         handle_value(std::move(val));
5912         return true;
5913     }
5914
5915     bool start_object(std::size_t len)
5916     {
5917         ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
5918
5919         if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
5920         {
5921             JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
5922         }
5923
5924         return true;
5925     }
5926
5927     bool key(string_t& val)
5928     {
5929         // add null at given key and store the reference for later
5930         object_element = &(ref_stack.back()->m_value.object->operator[](val));
5931         return true;
5932     }
5933
5934     bool end_object()
5935     {
5936         ref_stack.back()->set_parents();
5937         ref_stack.pop_back();
5938         return true;
5939     }
5940
5941     bool start_array(std::size_t len)
5942     {
5943         ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
5944
5945         if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
5946         {
5947             JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
5948         }
5949
5950         return true;
5951     }
5952
5953     bool end_array()
5954     {
5955         ref_stack.back()->set_parents();
5956         ref_stack.pop_back();
5957         return true;
5958     }
5959
5960     template<class Exception>
5961     bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
5962                      const Exception& ex)
5963     {
5964         errored = true;
5965         static_cast<void>(ex);
5966         if (allow_exceptions)
5967         {
5968             JSON_THROW(ex);
5969         }
5970         return false;
5971     }
5972
5973     constexpr bool is_errored() const
5974     {
5975         return errored;
5976     }
5977
5978   private:
5979     /*!
5980     @invariant If the ref stack is empty, then the passed value will be the new
5981                root.
5982     @invariant If the ref stack contains a value, then it is an array or an
5983                object to which we can add elements
5984     */
5985     template<typename Value>
5986     JSON_HEDLEY_RETURNS_NON_NULL
5987     BasicJsonType* handle_value(Value&& v)
5988     {
5989         if (ref_stack.empty())
5990         {
5991             root = BasicJsonType(std::forward<Value>(v));
5992             return &root;
5993         }
5994
5995         JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5996
5997         if (ref_stack.back()->is_array())
5998         {
5999             ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6000             return &(ref_stack.back()->m_value.array->back());
6001         }
6002
6003         JSON_ASSERT(ref_stack.back()->is_object());
6004         JSON_ASSERT(object_element);
6005         *object_element = BasicJsonType(std::forward<Value>(v));
6006         return object_element;
6007     }
6008
6009     /// the parsed JSON value
6010     BasicJsonType& root;
6011     /// stack to model hierarchy of values
6012     std::vector<BasicJsonType*> ref_stack {};
6013     /// helper to hold the reference for the next object element
6014     BasicJsonType* object_element = nullptr;
6015     /// whether a syntax error occurred
6016     bool errored = false;
6017     /// whether to throw exceptions in case of errors
6018     const bool allow_exceptions = true;
6019 };
6020
6021 template<typename BasicJsonType>
6022 class json_sax_dom_callback_parser
6023 {
6024   public:
6025     using number_integer_t = typename BasicJsonType::number_integer_t;
6026     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6027     using number_float_t = typename BasicJsonType::number_float_t;
6028     using string_t = typename BasicJsonType::string_t;
6029     using binary_t = typename BasicJsonType::binary_t;
6030     using parser_callback_t = typename BasicJsonType::parser_callback_t;
6031     using parse_event_t = typename BasicJsonType::parse_event_t;
6032
6033     json_sax_dom_callback_parser(BasicJsonType& r,
6034                                  const parser_callback_t cb,
6035                                  const bool allow_exceptions_ = true)
6036         : root(r), callback(cb), allow_exceptions(allow_exceptions_)
6037     {
6038         keep_stack.push_back(true);
6039     }
6040
6041     // make class move-only
6042     json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
6043     json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6044     json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
6045     json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6046     ~json_sax_dom_callback_parser() = default;
6047
6048     bool null()
6049     {
6050         handle_value(nullptr);
6051         return true;
6052     }
6053
6054     bool boolean(bool val)
6055     {
6056         handle_value(val);
6057         return true;
6058     }
6059
6060     bool number_integer(number_integer_t val)
6061     {
6062         handle_value(val);
6063         return true;
6064     }
6065
6066     bool number_unsigned(number_unsigned_t val)
6067     {
6068         handle_value(val);
6069         return true;
6070     }
6071
6072     bool number_float(number_float_t val, const string_t& /*unused*/)
6073     {
6074         handle_value(val);
6075         return true;
6076     }
6077
6078     bool string(string_t& val)
6079     {
6080         handle_value(val);
6081         return true;
6082     }
6083
6084     bool binary(binary_t& val)
6085     {
6086         handle_value(std::move(val));
6087         return true;
6088     }
6089
6090     bool start_object(std::size_t len)
6091     {
6092         // check callback for object start
6093         const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
6094         keep_stack.push_back(keep);
6095
6096         auto val = handle_value(BasicJsonType::value_t::object, true);
6097         ref_stack.push_back(val.second);
6098
6099         // check object limit
6100         if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6101         {
6102             JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
6103         }
6104
6105         return true;
6106     }
6107
6108     bool key(string_t& val)
6109     {
6110         BasicJsonType k = BasicJsonType(val);
6111
6112         // check callback for key
6113         const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
6114         key_keep_stack.push_back(keep);
6115
6116         // add discarded value at given key and store the reference for later
6117         if (keep && ref_stack.back())
6118         {
6119             object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
6120         }
6121
6122         return true;
6123     }
6124
6125     bool end_object()
6126     {
6127         if (ref_stack.back())
6128         {
6129             if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
6130             {
6131                 // discard object
6132                 *ref_stack.back() = discarded;
6133             }
6134             else
6135             {
6136                 ref_stack.back()->set_parents();
6137             }
6138         }
6139
6140         JSON_ASSERT(!ref_stack.empty());
6141         JSON_ASSERT(!keep_stack.empty());
6142         ref_stack.pop_back();
6143         keep_stack.pop_back();
6144
6145         if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
6146         {
6147             // remove discarded value
6148             for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
6149             {
6150                 if (it->is_discarded())
6151                 {
6152                     ref_stack.back()->erase(it);
6153                     break;
6154                 }
6155             }
6156         }
6157
6158         return true;
6159     }
6160
6161     bool start_array(std::size_t len)
6162     {
6163         const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
6164         keep_stack.push_back(keep);
6165
6166         auto val = handle_value(BasicJsonType::value_t::array, true);
6167         ref_stack.push_back(val.second);
6168
6169         // check array limit
6170         if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6171         {
6172             JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
6173         }
6174
6175         return true;
6176     }
6177
6178     bool end_array()
6179     {
6180         bool keep = true;
6181
6182         if (ref_stack.back())
6183         {
6184             keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
6185             if (keep)
6186             {
6187                 ref_stack.back()->set_parents();
6188             }
6189             else
6190             {
6191                 // discard array
6192                 *ref_stack.back() = discarded;
6193             }
6194         }
6195
6196         JSON_ASSERT(!ref_stack.empty());
6197         JSON_ASSERT(!keep_stack.empty());
6198         ref_stack.pop_back();
6199         keep_stack.pop_back();
6200
6201         // remove discarded value
6202         if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
6203         {
6204             ref_stack.back()->m_value.array->pop_back();
6205         }
6206
6207         return true;
6208     }
6209
6210     template<class Exception>
6211     bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
6212                      const Exception& ex)
6213     {
6214         errored = true;
6215         static_cast<void>(ex);
6216         if (allow_exceptions)
6217         {
6218             JSON_THROW(ex);
6219         }
6220         return false;
6221     }
6222
6223     constexpr bool is_errored() const
6224     {
6225         return errored;
6226     }
6227
6228   private:
6229     /*!
6230     @param[in] v  value to add to the JSON value we build during parsing
6231     @param[in] skip_callback  whether we should skip calling the callback
6232                function; this is required after start_array() and
6233                start_object() SAX events, because otherwise we would call the
6234                callback function with an empty array or object, respectively.
6235
6236     @invariant If the ref stack is empty, then the passed value will be the new
6237                root.
6238     @invariant If the ref stack contains a value, then it is an array or an
6239                object to which we can add elements
6240
6241     @return pair of boolean (whether value should be kept) and pointer (to the
6242             passed value in the ref_stack hierarchy; nullptr if not kept)
6243     */
6244     template<typename Value>
6245     std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
6246     {
6247         JSON_ASSERT(!keep_stack.empty());
6248
6249         // do not handle this value if we know it would be added to a discarded
6250         // container
6251         if (!keep_stack.back())
6252         {
6253             return {false, nullptr};
6254         }
6255
6256         // create value
6257         auto value = BasicJsonType(std::forward<Value>(v));
6258
6259         // check callback
6260         const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
6261
6262         // do not handle this value if we just learnt it shall be discarded
6263         if (!keep)
6264         {
6265             return {false, nullptr};
6266         }
6267
6268         if (ref_stack.empty())
6269         {
6270             root = std::move(value);
6271             return {true, &root};
6272         }
6273
6274         // skip this value if we already decided to skip the parent
6275         // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
6276         if (!ref_stack.back())
6277         {
6278             return {false, nullptr};
6279         }
6280
6281         // we now only expect arrays and objects
6282         JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
6283
6284         // array
6285         if (ref_stack.back()->is_array())
6286         {
6287             ref_stack.back()->m_value.array->emplace_back(std::move(value));
6288             return {true, &(ref_stack.back()->m_value.array->back())};
6289         }
6290
6291         // object
6292         JSON_ASSERT(ref_stack.back()->is_object());
6293         // check if we should store an element for the current key
6294         JSON_ASSERT(!key_keep_stack.empty());
6295         const bool store_element = key_keep_stack.back();
6296         key_keep_stack.pop_back();
6297
6298         if (!store_element)
6299         {
6300             return {false, nullptr};
6301         }
6302
6303         JSON_ASSERT(object_element);
6304         *object_element = std::move(value);
6305         return {true, object_element};
6306     }
6307
6308     /// the parsed JSON value
6309     BasicJsonType& root;
6310     /// stack to model hierarchy of values
6311     std::vector<BasicJsonType*> ref_stack {};
6312     /// stack to manage which values to keep
6313     std::vector<bool> keep_stack {};
6314     /// stack to manage which object keys to keep
6315     std::vector<bool> key_keep_stack {};
6316     /// helper to hold the reference for the next object element
6317     BasicJsonType* object_element = nullptr;
6318     /// whether a syntax error occurred
6319     bool errored = false;
6320     /// callback function
6321     const parser_callback_t callback = nullptr;
6322     /// whether to throw exceptions in case of errors
6323     const bool allow_exceptions = true;
6324     /// a discarded value for the callback
6325     BasicJsonType discarded = BasicJsonType::value_t::discarded;
6326 };
6327
6328 template<typename BasicJsonType>
6329 class json_sax_acceptor
6330 {
6331   public:
6332     using number_integer_t = typename BasicJsonType::number_integer_t;
6333     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6334     using number_float_t = typename BasicJsonType::number_float_t;
6335     using string_t = typename BasicJsonType::string_t;
6336     using binary_t = typename BasicJsonType::binary_t;
6337
6338     bool null()
6339     {
6340         return true;
6341     }
6342
6343     bool boolean(bool /*unused*/)
6344     {
6345         return true;
6346     }
6347
6348     bool number_integer(number_integer_t /*unused*/)
6349     {
6350         return true;
6351     }
6352
6353     bool number_unsigned(number_unsigned_t /*unused*/)
6354     {
6355         return true;
6356     }
6357
6358     bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
6359     {
6360         return true;
6361     }
6362
6363     bool string(string_t& /*unused*/)
6364     {
6365         return true;
6366     }
6367
6368     bool binary(binary_t& /*unused*/)
6369     {
6370         return true;
6371     }
6372
6373     bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
6374     {
6375         return true;
6376     }
6377
6378     bool key(string_t& /*unused*/)
6379     {
6380         return true;
6381     }
6382
6383     bool end_object()
6384     {
6385         return true;
6386     }
6387
6388     bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
6389     {
6390         return true;
6391     }
6392
6393     bool end_array()
6394     {
6395         return true;
6396     }
6397
6398     bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
6399     {
6400         return false;
6401     }
6402 };
6403 }  // namespace detail
6404
6405 }  // namespace nlohmann
6406
6407 // #include <nlohmann/detail/input/lexer.hpp>
6408
6409
6410 #include <array> // array
6411 #include <clocale> // localeconv
6412 #include <cstddef> // size_t
6413 #include <cstdio> // snprintf
6414 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
6415 #include <initializer_list> // initializer_list
6416 #include <string> // char_traits, string
6417 #include <utility> // move
6418 #include <vector> // vector
6419
6420 // #include <nlohmann/detail/input/input_adapters.hpp>
6421
6422 // #include <nlohmann/detail/input/position_t.hpp>
6423
6424 // #include <nlohmann/detail/macro_scope.hpp>
6425
6426
6427 namespace nlohmann
6428 {
6429 namespace detail
6430 {
6431 ///////////
6432 // lexer //
6433 ///////////
6434
6435 template<typename BasicJsonType>
6436 class lexer_base
6437 {
6438   public:
6439     /// token types for the parser
6440     enum class token_type
6441     {
6442         uninitialized,    ///< indicating the scanner is uninitialized
6443         literal_true,     ///< the `true` literal
6444         literal_false,    ///< the `false` literal
6445         literal_null,     ///< the `null` literal
6446         value_string,     ///< a string -- use get_string() for actual value
6447         value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
6448         value_integer,    ///< a signed integer -- use get_number_integer() for actual value
6449         value_float,      ///< an floating point number -- use get_number_float() for actual value
6450         begin_array,      ///< the character for array begin `[`
6451         begin_object,     ///< the character for object begin `{`
6452         end_array,        ///< the character for array end `]`
6453         end_object,       ///< the character for object end `}`
6454         name_separator,   ///< the name separator `:`
6455         value_separator,  ///< the value separator `,`
6456         parse_error,      ///< indicating a parse error
6457         end_of_input,     ///< indicating the end of the input buffer
6458         literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
6459     };
6460
6461     /// return name of values of type token_type (only used for errors)
6462     JSON_HEDLEY_RETURNS_NON_NULL
6463     JSON_HEDLEY_CONST
6464     static const char* token_type_name(const token_type t) noexcept
6465     {
6466         switch (t)
6467         {
6468             case token_type::uninitialized:
6469                 return "<uninitialized>";
6470             case token_type::literal_true:
6471                 return "true literal";
6472             case token_type::literal_false:
6473                 return "false literal";
6474             case token_type::literal_null:
6475                 return "null literal";
6476             case token_type::value_string:
6477                 return "string literal";
6478             case token_type::value_unsigned:
6479             case token_type::value_integer:
6480             case token_type::value_float:
6481                 return "number literal";
6482             case token_type::begin_array:
6483                 return "'['";
6484             case token_type::begin_object:
6485                 return "'{'";
6486             case token_type::end_array:
6487                 return "']'";
6488             case token_type::end_object:
6489                 return "'}'";
6490             case token_type::name_separator:
6491                 return "':'";
6492             case token_type::value_separator:
6493                 return "','";
6494             case token_type::parse_error:
6495                 return "<parse error>";
6496             case token_type::end_of_input:
6497                 return "end of input";
6498             case token_type::literal_or_value:
6499                 return "'[', '{', or a literal";
6500             // LCOV_EXCL_START
6501             default: // catch non-enum values
6502                 return "unknown token";
6503                 // LCOV_EXCL_STOP
6504         }
6505     }
6506 };
6507 /*!
6508 @brief lexical analysis
6509
6510 This class organizes the lexical analysis during JSON deserialization.
6511 */
6512 template<typename BasicJsonType, typename InputAdapterType>
6513 class lexer : public lexer_base<BasicJsonType>
6514 {
6515     using number_integer_t = typename BasicJsonType::number_integer_t;
6516     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
6517     using number_float_t = typename BasicJsonType::number_float_t;
6518     using string_t = typename BasicJsonType::string_t;
6519     using char_type = typename InputAdapterType::char_type;
6520     using char_int_type = typename std::char_traits<char_type>::int_type;
6521
6522   public:
6523     using token_type = typename lexer_base<BasicJsonType>::token_type;
6524
6525     explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
6526         : ia(std::move(adapter))
6527         , ignore_comments(ignore_comments_)
6528         , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
6529     {}
6530
6531     // delete because of pointer members
6532     lexer(const lexer&) = delete;
6533     lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6534     lexer& operator=(lexer&) = delete;
6535     lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
6536     ~lexer() = default;
6537
6538   private:
6539     /////////////////////
6540     // locales
6541     /////////////////////
6542
6543     /// return the locale-dependent decimal point
6544     JSON_HEDLEY_PURE
6545     static char get_decimal_point() noexcept
6546     {
6547         const auto* loc = localeconv();
6548         JSON_ASSERT(loc != nullptr);
6549         return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
6550     }
6551
6552     /////////////////////
6553     // scan functions
6554     /////////////////////
6555
6556     /*!
6557     @brief get codepoint from 4 hex characters following `\u`
6558
6559     For input "\u c1 c2 c3 c4" the codepoint is:
6560       (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
6561     = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
6562
6563     Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
6564     must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
6565     conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
6566     between the ASCII value of the character and the desired integer value.
6567
6568     @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
6569             non-hex character)
6570     */
6571     int get_codepoint()
6572     {
6573         // this function only makes sense after reading `\u`
6574         JSON_ASSERT(current == 'u');
6575         int codepoint = 0;
6576
6577         const auto factors = { 12u, 8u, 4u, 0u };
6578         for (const auto factor : factors)
6579         {
6580             get();
6581
6582             if (current >= '0' && current <= '9')
6583             {
6584                 codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
6585             }
6586             else if (current >= 'A' && current <= 'F')
6587             {
6588                 codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
6589             }
6590             else if (current >= 'a' && current <= 'f')
6591             {
6592                 codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
6593             }
6594             else
6595             {
6596                 return -1;
6597             }
6598         }
6599
6600         JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6601         return codepoint;
6602     }
6603
6604     /*!
6605     @brief check if the next byte(s) are inside a given range
6606
6607     Adds the current byte and, for each passed range, reads a new byte and
6608     checks if it is inside the range. If a violation was detected, set up an
6609     error message and return false. Otherwise, return true.
6610
6611     @param[in] ranges  list of integers; interpreted as list of pairs of
6612                        inclusive lower and upper bound, respectively
6613
6614     @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
6615          1, 2, or 3 pairs. This precondition is enforced by an assertion.
6616
6617     @return true if and only if no range violation was detected
6618     */
6619     bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6620     {
6621         JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6622         add(current);
6623
6624         for (auto range = ranges.begin(); range != ranges.end(); ++range)
6625         {
6626             get();
6627             if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6628             {
6629                 add(current);
6630             }
6631             else
6632             {
6633                 error_message = "invalid string: ill-formed UTF-8 byte";
6634                 return false;
6635             }
6636         }
6637
6638         return true;
6639     }
6640
6641     /*!
6642     @brief scan a string literal
6643
6644     This function scans a string according to Sect. 7 of RFC 8259. While
6645     scanning, bytes are escaped and copied into buffer token_buffer. Then the
6646     function returns successfully, token_buffer is *not* null-terminated (as it
6647     may contain \0 bytes), and token_buffer.size() is the number of bytes in the
6648     string.
6649
6650     @return token_type::value_string if string could be successfully scanned,
6651             token_type::parse_error otherwise
6652
6653     @note In case of errors, variable error_message contains a textual
6654           description.
6655     */
6656     token_type scan_string()
6657     {
6658         // reset token_buffer (ignore opening quote)
6659         reset();
6660
6661         // we entered the function by reading an open quote
6662         JSON_ASSERT(current == '\"');
6663
6664         while (true)
6665         {
6666             // get next character
6667             switch (get())
6668             {
6669                 // end of file while parsing string
6670                 case std::char_traits<char_type>::eof():
6671                 {
6672                     error_message = "invalid string: missing closing quote";
6673                     return token_type::parse_error;
6674                 }
6675
6676                 // closing quote
6677                 case '\"':
6678                 {
6679                     return token_type::value_string;
6680                 }
6681
6682                 // escapes
6683                 case '\\':
6684                 {
6685                     switch (get())
6686                     {
6687                         // quotation mark
6688                         case '\"':
6689                             add('\"');
6690                             break;
6691                         // reverse solidus
6692                         case '\\':
6693                             add('\\');
6694                             break;
6695                         // solidus
6696                         case '/':
6697                             add('/');
6698                             break;
6699                         // backspace
6700                         case 'b':
6701                             add('\b');
6702                             break;
6703                         // form feed
6704                         case 'f':
6705                             add('\f');
6706                             break;
6707                         // line feed
6708                         case 'n':
6709                             add('\n');
6710                             break;
6711                         // carriage return
6712                         case 'r':
6713                             add('\r');
6714                             break;
6715                         // tab
6716                         case 't':
6717                             add('\t');
6718                             break;
6719
6720                         // unicode escapes
6721                         case 'u':
6722                         {
6723                             const int codepoint1 = get_codepoint();
6724                             int codepoint = codepoint1; // start with codepoint1
6725
6726                             if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6727                             {
6728                                 error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6729                                 return token_type::parse_error;
6730                             }
6731
6732                             // check if code point is a high surrogate
6733                             if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6734                             {
6735                                 // expect next \uxxxx entry
6736                                 if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
6737                                 {
6738                                     const int codepoint2 = get_codepoint();
6739
6740                                     if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6741                                     {
6742                                         error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6743                                         return token_type::parse_error;
6744                                     }
6745
6746                                     // check if codepoint2 is a low surrogate
6747                                     if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6748                                     {
6749                                         // overwrite codepoint
6750                                         codepoint = static_cast<int>(
6751                                                         // high surrogate occupies the most significant 22 bits
6752                                                         (static_cast<unsigned int>(codepoint1) << 10u)
6753                                                         // low surrogate occupies the least significant 15 bits
6754                                                         + static_cast<unsigned int>(codepoint2)
6755                                                         // there is still the 0xD800, 0xDC00 and 0x10000 noise
6756                                                         // in the result, so we have to subtract with:
6757                                                         // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
6758                                                         - 0x35FDC00u);
6759                                     }
6760                                     else
6761                                     {
6762                                         error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6763                                         return token_type::parse_error;
6764                                     }
6765                                 }
6766                                 else
6767                                 {
6768                                     error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6769                                     return token_type::parse_error;
6770                                 }
6771                             }
6772                             else
6773                             {
6774                                 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6775                                 {
6776                                     error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6777                                     return token_type::parse_error;
6778                                 }
6779                             }
6780
6781                             // result of the above calculation yields a proper codepoint
6782                             JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6783
6784                             // translate codepoint into bytes
6785                             if (codepoint < 0x80)
6786                             {
6787                                 // 1-byte characters: 0xxxxxxx (ASCII)
6788                                 add(static_cast<char_int_type>(codepoint));
6789                             }
6790                             else if (codepoint <= 0x7FF)
6791                             {
6792                                 // 2-byte characters: 110xxxxx 10xxxxxx
6793                                 add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
6794                                 add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6795                             }
6796                             else if (codepoint <= 0xFFFF)
6797                             {
6798                                 // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
6799                                 add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
6800                                 add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6801                                 add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6802                             }
6803                             else
6804                             {
6805                                 // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
6806                                 add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
6807                                 add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6808                                 add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6809                                 add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6810                             }
6811
6812                             break;
6813                         }
6814
6815                         // other characters after escape
6816                         default:
6817                             error_message = "invalid string: forbidden character after backslash";
6818                             return token_type::parse_error;
6819                     }
6820
6821                     break;
6822                 }
6823
6824                 // invalid control characters
6825                 case 0x00:
6826                 {
6827                     error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6828                     return token_type::parse_error;
6829                 }
6830
6831                 case 0x01:
6832                 {
6833                     error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6834                     return token_type::parse_error;
6835                 }
6836
6837                 case 0x02:
6838                 {
6839                     error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6840                     return token_type::parse_error;
6841                 }
6842
6843                 case 0x03:
6844                 {
6845                     error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6846                     return token_type::parse_error;
6847                 }
6848
6849                 case 0x04:
6850                 {
6851                     error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6852                     return token_type::parse_error;
6853                 }
6854
6855                 case 0x05:
6856                 {
6857                     error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6858                     return token_type::parse_error;
6859                 }
6860
6861                 case 0x06:
6862                 {
6863                     error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6864                     return token_type::parse_error;
6865                 }
6866
6867                 case 0x07:
6868                 {
6869                     error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6870                     return token_type::parse_error;
6871                 }
6872
6873                 case 0x08:
6874                 {
6875                     error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6876                     return token_type::parse_error;
6877                 }
6878
6879                 case 0x09:
6880                 {
6881                     error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6882                     return token_type::parse_error;
6883                 }
6884
6885                 case 0x0A:
6886                 {
6887                     error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6888                     return token_type::parse_error;
6889                 }
6890
6891                 case 0x0B:
6892                 {
6893                     error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
6894                     return token_type::parse_error;
6895                 }
6896
6897                 case 0x0C:
6898                 {
6899                     error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
6900                     return token_type::parse_error;
6901                 }
6902
6903                 case 0x0D:
6904                 {
6905                     error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
6906                     return token_type::parse_error;
6907                 }
6908
6909                 case 0x0E:
6910                 {
6911                     error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
6912                     return token_type::parse_error;
6913                 }
6914
6915                 case 0x0F:
6916                 {
6917                     error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
6918                     return token_type::parse_error;
6919                 }
6920
6921                 case 0x10:
6922                 {
6923                     error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
6924                     return token_type::parse_error;
6925                 }
6926
6927                 case 0x11:
6928                 {
6929                     error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
6930                     return token_type::parse_error;
6931                 }
6932
6933                 case 0x12:
6934                 {
6935                     error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
6936                     return token_type::parse_error;
6937                 }
6938
6939                 case 0x13:
6940                 {
6941                     error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
6942                     return token_type::parse_error;
6943                 }
6944
6945                 case 0x14:
6946                 {
6947                     error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
6948                     return token_type::parse_error;
6949                 }
6950
6951                 case 0x15:
6952                 {
6953                     error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
6954                     return token_type::parse_error;
6955                 }
6956
6957                 case 0x16:
6958                 {
6959                     error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
6960                     return token_type::parse_error;
6961                 }
6962
6963                 case 0x17:
6964                 {
6965                     error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
6966                     return token_type::parse_error;
6967                 }
6968
6969                 case 0x18:
6970                 {
6971                     error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
6972                     return token_type::parse_error;
6973                 }
6974
6975                 case 0x19:
6976                 {
6977                     error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
6978                     return token_type::parse_error;
6979                 }
6980
6981                 case 0x1A:
6982                 {
6983                     error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
6984                     return token_type::parse_error;
6985                 }
6986
6987                 case 0x1B:
6988                 {
6989                     error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
6990                     return token_type::parse_error;
6991                 }
6992
6993                 case 0x1C:
6994                 {
6995                     error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
6996                     return token_type::parse_error;
6997                 }
6998
6999                 case 0x1D:
7000                 {
7001                     error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
7002                     return token_type::parse_error;
7003                 }
7004
7005                 case 0x1E:
7006                 {
7007                     error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
7008                     return token_type::parse_error;
7009                 }
7010
7011                 case 0x1F:
7012                 {
7013                     error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
7014                     return token_type::parse_error;
7015                 }
7016
7017                 // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
7018                 case 0x20:
7019                 case 0x21:
7020                 case 0x23:
7021                 case 0x24:
7022                 case 0x25:
7023                 case 0x26:
7024                 case 0x27:
7025                 case 0x28:
7026                 case 0x29:
7027                 case 0x2A:
7028                 case 0x2B:
7029                 case 0x2C:
7030                 case 0x2D:
7031                 case 0x2E:
7032                 case 0x2F:
7033                 case 0x30:
7034                 case 0x31:
7035                 case 0x32:
7036                 case 0x33:
7037                 case 0x34:
7038                 case 0x35:
7039                 case 0x36:
7040                 case 0x37:
7041                 case 0x38:
7042                 case 0x39:
7043                 case 0x3A:
7044                 case 0x3B:
7045                 case 0x3C:
7046                 case 0x3D:
7047                 case 0x3E:
7048                 case 0x3F:
7049                 case 0x40:
7050                 case 0x41:
7051                 case 0x42:
7052                 case 0x43:
7053                 case 0x44:
7054                 case 0x45:
7055                 case 0x46:
7056                 case 0x47:
7057                 case 0x48:
7058                 case 0x49:
7059                 case 0x4A:
7060                 case 0x4B:
7061                 case 0x4C:
7062                 case 0x4D:
7063                 case 0x4E:
7064                 case 0x4F:
7065                 case 0x50:
7066                 case 0x51:
7067                 case 0x52:
7068                 case 0x53:
7069                 case 0x54:
7070                 case 0x55:
7071                 case 0x56:
7072                 case 0x57:
7073                 case 0x58:
7074                 case 0x59:
7075                 case 0x5A:
7076                 case 0x5B:
7077                 case 0x5D:
7078                 case 0x5E:
7079                 case 0x5F:
7080                 case 0x60:
7081                 case 0x61:
7082                 case 0x62:
7083                 case 0x63:
7084                 case 0x64:
7085                 case 0x65:
7086                 case 0x66:
7087                 case 0x67:
7088                 case 0x68:
7089                 case 0x69:
7090                 case 0x6A:
7091                 case 0x6B:
7092                 case 0x6C:
7093                 case 0x6D:
7094                 case 0x6E:
7095                 case 0x6F:
7096                 case 0x70:
7097                 case 0x71:
7098                 case 0x72:
7099                 case 0x73:
7100                 case 0x74:
7101                 case 0x75:
7102                 case 0x76:
7103                 case 0x77:
7104                 case 0x78:
7105                 case 0x79:
7106                 case 0x7A:
7107                 case 0x7B:
7108                 case 0x7C:
7109                 case 0x7D:
7110                 case 0x7E:
7111                 case 0x7F:
7112                 {
7113                     add(current);
7114                     break;
7115                 }
7116
7117                 // U+0080..U+07FF: bytes C2..DF 80..BF
7118                 case 0xC2:
7119                 case 0xC3:
7120                 case 0xC4:
7121                 case 0xC5:
7122                 case 0xC6:
7123                 case 0xC7:
7124                 case 0xC8:
7125                 case 0xC9:
7126                 case 0xCA:
7127                 case 0xCB:
7128                 case 0xCC:
7129                 case 0xCD:
7130                 case 0xCE:
7131                 case 0xCF:
7132                 case 0xD0:
7133                 case 0xD1:
7134                 case 0xD2:
7135                 case 0xD3:
7136                 case 0xD4:
7137                 case 0xD5:
7138                 case 0xD6:
7139                 case 0xD7:
7140                 case 0xD8:
7141                 case 0xD9:
7142                 case 0xDA:
7143                 case 0xDB:
7144                 case 0xDC:
7145                 case 0xDD:
7146                 case 0xDE:
7147                 case 0xDF:
7148                 {
7149                     if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
7150                     {
7151                         return token_type::parse_error;
7152                     }
7153                     break;
7154                 }
7155
7156                 // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
7157                 case 0xE0:
7158                 {
7159                     if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
7160                     {
7161                         return token_type::parse_error;
7162                     }
7163                     break;
7164                 }
7165
7166                 // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
7167                 // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
7168                 case 0xE1:
7169                 case 0xE2:
7170                 case 0xE3:
7171                 case 0xE4:
7172                 case 0xE5:
7173                 case 0xE6:
7174                 case 0xE7:
7175                 case 0xE8:
7176                 case 0xE9:
7177                 case 0xEA:
7178                 case 0xEB:
7179                 case 0xEC:
7180                 case 0xEE:
7181                 case 0xEF:
7182                 {
7183                     if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
7184                     {
7185                         return token_type::parse_error;
7186                     }
7187                     break;
7188                 }
7189
7190                 // U+D000..U+D7FF: bytes ED 80..9F 80..BF
7191                 case 0xED:
7192                 {
7193                     if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
7194                     {
7195                         return token_type::parse_error;
7196                     }
7197                     break;
7198                 }
7199
7200                 // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
7201                 case 0xF0:
7202                 {
7203                     if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7204                     {
7205                         return token_type::parse_error;
7206                     }
7207                     break;
7208                 }
7209
7210                 // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
7211                 case 0xF1:
7212                 case 0xF2:
7213                 case 0xF3:
7214                 {
7215                     if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
7216                     {
7217                         return token_type::parse_error;
7218                     }
7219                     break;
7220                 }
7221
7222                 // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
7223                 case 0xF4:
7224                 {
7225                     if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
7226                     {
7227                         return token_type::parse_error;
7228                     }
7229                     break;
7230                 }
7231
7232                 // remaining bytes (80..C1 and F5..FF) are ill-formed
7233                 default:
7234                 {
7235                     error_message = "invalid string: ill-formed UTF-8 byte";
7236                     return token_type::parse_error;
7237                 }
7238             }
7239         }
7240     }
7241
7242     /*!
7243      * @brief scan a comment
7244      * @return whether comment could be scanned successfully
7245      */
7246     bool scan_comment()
7247     {
7248         switch (get())
7249         {
7250             // single-line comments skip input until a newline or EOF is read
7251             case '/':
7252             {
7253                 while (true)
7254                 {
7255                     switch (get())
7256                     {
7257                         case '\n':
7258                         case '\r':
7259                         case std::char_traits<char_type>::eof():
7260                         case '\0':
7261                             return true;
7262
7263                         default:
7264                             break;
7265                     }
7266                 }
7267             }
7268
7269             // multi-line comments skip input until */ is read
7270             case '*':
7271             {
7272                 while (true)
7273                 {
7274                     switch (get())
7275                     {
7276                         case std::char_traits<char_type>::eof():
7277                         case '\0':
7278                         {
7279                             error_message = "invalid comment; missing closing '*/'";
7280                             return false;
7281                         }
7282
7283                         case '*':
7284                         {
7285                             switch (get())
7286                             {
7287                                 case '/':
7288                                     return true;
7289
7290                                 default:
7291                                 {
7292                                     unget();
7293                                     continue;
7294                                 }
7295                             }
7296                         }
7297
7298                         default:
7299                             continue;
7300                     }
7301                 }
7302             }
7303
7304             // unexpected character after reading '/'
7305             default:
7306             {
7307                 error_message = "invalid comment; expecting '/' or '*' after '/'";
7308                 return false;
7309             }
7310         }
7311     }
7312
7313     JSON_HEDLEY_NON_NULL(2)
7314     static void strtof(float& f, const char* str, char** endptr) noexcept
7315     {
7316         f = std::strtof(str, endptr);
7317     }
7318
7319     JSON_HEDLEY_NON_NULL(2)
7320     static void strtof(double& f, const char* str, char** endptr) noexcept
7321     {
7322         f = std::strtod(str, endptr);
7323     }
7324
7325     JSON_HEDLEY_NON_NULL(2)
7326     static void strtof(long double& f, const char* str, char** endptr) noexcept
7327     {
7328         f = std::strtold(str, endptr);
7329     }
7330
7331     /*!
7332     @brief scan a number literal
7333
7334     This function scans a string according to Sect. 6 of RFC 8259.
7335
7336     The function is realized with a deterministic finite state machine derived
7337     from the grammar described in RFC 8259. Starting in state "init", the
7338     input is read and used to determined the next state. Only state "done"
7339     accepts the number. State "error" is a trap state to model errors. In the
7340     table below, "anything" means any character but the ones listed before.
7341
7342     state    | 0        | 1-9      | e E      | +       | -       | .        | anything
7343     ---------|----------|----------|----------|---------|---------|----------|-----------
7344     init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
7345     minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
7346     zero     | done     | done     | exponent | done    | done    | decimal1 | done
7347     any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
7348     decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
7349     decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
7350     exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
7351     sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
7352     any2     | any2     | any2     | done     | done    | done    | done     | done
7353
7354     The state machine is realized with one label per state (prefixed with
7355     "scan_number_") and `goto` statements between them. The state machine
7356     contains cycles, but any cycle can be left when EOF is read. Therefore,
7357     the function is guaranteed to terminate.
7358
7359     During scanning, the read bytes are stored in token_buffer. This string is
7360     then converted to a signed integer, an unsigned integer, or a
7361     floating-point number.
7362
7363     @return token_type::value_unsigned, token_type::value_integer, or
7364             token_type::value_float if number could be successfully scanned,
7365             token_type::parse_error otherwise
7366
7367     @note The scanner is independent of the current locale. Internally, the
7368           locale's decimal point is used instead of `.` to work with the
7369           locale-dependent converters.
7370     */
7371     token_type scan_number()  // lgtm [cpp/use-of-goto]
7372     {
7373         // reset token_buffer to store the number's bytes
7374         reset();
7375
7376         // the type of the parsed number; initially set to unsigned; will be
7377         // changed if minus sign, decimal point or exponent is read
7378         token_type number_type = token_type::value_unsigned;
7379
7380         // state (init): we just found out we need to scan a number
7381         switch (current)
7382         {
7383             case '-':
7384             {
7385                 add(current);
7386                 goto scan_number_minus;
7387             }
7388
7389             case '0':
7390             {
7391                 add(current);
7392                 goto scan_number_zero;
7393             }
7394
7395             case '1':
7396             case '2':
7397             case '3':
7398             case '4':
7399             case '5':
7400             case '6':
7401             case '7':
7402             case '8':
7403             case '9':
7404             {
7405                 add(current);
7406                 goto scan_number_any1;
7407             }
7408
7409             // all other characters are rejected outside scan_number()
7410             default:            // LCOV_EXCL_LINE
7411                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
7412         }
7413
7414 scan_number_minus:
7415         // state: we just parsed a leading minus sign
7416         number_type = token_type::value_integer;
7417         switch (get())
7418         {
7419             case '0':
7420             {
7421                 add(current);
7422                 goto scan_number_zero;
7423             }
7424
7425             case '1':
7426             case '2':
7427             case '3':
7428             case '4':
7429             case '5':
7430             case '6':
7431             case '7':
7432             case '8':
7433             case '9':
7434             {
7435                 add(current);
7436                 goto scan_number_any1;
7437             }
7438
7439             default:
7440             {
7441                 error_message = "invalid number; expected digit after '-'";
7442                 return token_type::parse_error;
7443             }
7444         }
7445
7446 scan_number_zero:
7447         // state: we just parse a zero (maybe with a leading minus sign)
7448         switch (get())
7449         {
7450             case '.':
7451             {
7452                 add(decimal_point_char);
7453                 goto scan_number_decimal1;
7454             }
7455
7456             case 'e':
7457             case 'E':
7458             {
7459                 add(current);
7460                 goto scan_number_exponent;
7461             }
7462
7463             default:
7464                 goto scan_number_done;
7465         }
7466
7467 scan_number_any1:
7468         // state: we just parsed a number 0-9 (maybe with a leading minus sign)
7469         switch (get())
7470         {
7471             case '0':
7472             case '1':
7473             case '2':
7474             case '3':
7475             case '4':
7476             case '5':
7477             case '6':
7478             case '7':
7479             case '8':
7480             case '9':
7481             {
7482                 add(current);
7483                 goto scan_number_any1;
7484             }
7485
7486             case '.':
7487             {
7488                 add(decimal_point_char);
7489                 goto scan_number_decimal1;
7490             }
7491
7492             case 'e':
7493             case 'E':
7494             {
7495                 add(current);
7496                 goto scan_number_exponent;
7497             }
7498
7499             default:
7500                 goto scan_number_done;
7501         }
7502
7503 scan_number_decimal1:
7504         // state: we just parsed a decimal point
7505         number_type = token_type::value_float;
7506         switch (get())
7507         {
7508             case '0':
7509             case '1':
7510             case '2':
7511             case '3':
7512             case '4':
7513             case '5':
7514             case '6':
7515             case '7':
7516             case '8':
7517             case '9':
7518             {
7519                 add(current);
7520                 goto scan_number_decimal2;
7521             }
7522
7523             default:
7524             {
7525                 error_message = "invalid number; expected digit after '.'";
7526                 return token_type::parse_error;
7527             }
7528         }
7529
7530 scan_number_decimal2:
7531         // we just parsed at least one number after a decimal point
7532         switch (get())
7533         {
7534             case '0':
7535             case '1':
7536             case '2':
7537             case '3':
7538             case '4':
7539             case '5':
7540             case '6':
7541             case '7':
7542             case '8':
7543             case '9':
7544             {
7545                 add(current);
7546                 goto scan_number_decimal2;
7547             }
7548
7549             case 'e':
7550             case 'E':
7551             {
7552                 add(current);
7553                 goto scan_number_exponent;
7554             }
7555
7556             default:
7557                 goto scan_number_done;
7558         }
7559
7560 scan_number_exponent:
7561         // we just parsed an exponent
7562         number_type = token_type::value_float;
7563         switch (get())
7564         {
7565             case '+':
7566             case '-':
7567             {
7568                 add(current);
7569                 goto scan_number_sign;
7570             }
7571
7572             case '0':
7573             case '1':
7574             case '2':
7575             case '3':
7576             case '4':
7577             case '5':
7578             case '6':
7579             case '7':
7580             case '8':
7581             case '9':
7582             {
7583                 add(current);
7584                 goto scan_number_any2;
7585             }
7586
7587             default:
7588             {
7589                 error_message =
7590                     "invalid number; expected '+', '-', or digit after exponent";
7591                 return token_type::parse_error;
7592             }
7593         }
7594
7595 scan_number_sign:
7596         // we just parsed an exponent sign
7597         switch (get())
7598         {
7599             case '0':
7600             case '1':
7601             case '2':
7602             case '3':
7603             case '4':
7604             case '5':
7605             case '6':
7606             case '7':
7607             case '8':
7608             case '9':
7609             {
7610                 add(current);
7611                 goto scan_number_any2;
7612             }
7613
7614             default:
7615             {
7616                 error_message = "invalid number; expected digit after exponent sign";
7617                 return token_type::parse_error;
7618             }
7619         }
7620
7621 scan_number_any2:
7622         // we just parsed a number after the exponent or exponent sign
7623         switch (get())
7624         {
7625             case '0':
7626             case '1':
7627             case '2':
7628             case '3':
7629             case '4':
7630             case '5':
7631             case '6':
7632             case '7':
7633             case '8':
7634             case '9':
7635             {
7636                 add(current);
7637                 goto scan_number_any2;
7638             }
7639
7640             default:
7641                 goto scan_number_done;
7642         }
7643
7644 scan_number_done:
7645         // unget the character after the number (we only read it to know that
7646         // we are done scanning a number)
7647         unget();
7648
7649         char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
7650         errno = 0;
7651
7652         // try to parse integers first and fall back to floats
7653         if (number_type == token_type::value_unsigned)
7654         {
7655             const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7656
7657             // we checked the number format before
7658             JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7659
7660             if (errno == 0)
7661             {
7662                 value_unsigned = static_cast<number_unsigned_t>(x);
7663                 if (value_unsigned == x)
7664                 {
7665                     return token_type::value_unsigned;
7666                 }
7667             }
7668         }
7669         else if (number_type == token_type::value_integer)
7670         {
7671             const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7672
7673             // we checked the number format before
7674             JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7675
7676             if (errno == 0)
7677             {
7678                 value_integer = static_cast<number_integer_t>(x);
7679                 if (value_integer == x)
7680                 {
7681                     return token_type::value_integer;
7682                 }
7683             }
7684         }
7685
7686         // this code is reached if we parse a floating-point number or if an
7687         // integer conversion above failed
7688         strtof(value_float, token_buffer.data(), &endptr);
7689
7690         // we checked the number format before
7691         JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7692
7693         return token_type::value_float;
7694     }
7695
7696     /*!
7697     @param[in] literal_text  the literal text to expect
7698     @param[in] length        the length of the passed literal text
7699     @param[in] return_type   the token type to return on success
7700     */
7701     JSON_HEDLEY_NON_NULL(2)
7702     token_type scan_literal(const char_type* literal_text, const std::size_t length,
7703                             token_type return_type)
7704     {
7705         JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7706         for (std::size_t i = 1; i < length; ++i)
7707         {
7708             if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7709             {
7710                 error_message = "invalid literal";
7711                 return token_type::parse_error;
7712             }
7713         }
7714         return return_type;
7715     }
7716
7717     /////////////////////
7718     // input management
7719     /////////////////////
7720
7721     /// reset token_buffer; current character is beginning of token
7722     void reset() noexcept
7723     {
7724         token_buffer.clear();
7725         token_string.clear();
7726         token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7727     }
7728
7729     /*
7730     @brief get next character from the input
7731
7732     This function provides the interface to the used input adapter. It does
7733     not throw in case the input reached EOF, but returns a
7734     `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
7735     for use in error messages.
7736
7737     @return character read from the input
7738     */
7739     char_int_type get()
7740     {
7741         ++position.chars_read_total;
7742         ++position.chars_read_current_line;
7743
7744         if (next_unget)
7745         {
7746             // just reset the next_unget variable and work with current
7747             next_unget = false;
7748         }
7749         else
7750         {
7751             current = ia.get_character();
7752         }
7753
7754         if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7755         {
7756             token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7757         }
7758
7759         if (current == '\n')
7760         {
7761             ++position.lines_read;
7762             position.chars_read_current_line = 0;
7763         }
7764
7765         return current;
7766     }
7767
7768     /*!
7769     @brief unget current character (read it again on next get)
7770
7771     We implement unget by setting variable next_unget to true. The input is not
7772     changed - we just simulate ungetting by modifying chars_read_total,
7773     chars_read_current_line, and token_string. The next call to get() will
7774     behave as if the unget character is read again.
7775     */
7776     void unget()
7777     {
7778         next_unget = true;
7779
7780         --position.chars_read_total;
7781
7782         // in case we "unget" a newline, we have to also decrement the lines_read
7783         if (position.chars_read_current_line == 0)
7784         {
7785             if (position.lines_read > 0)
7786             {
7787                 --position.lines_read;
7788             }
7789         }
7790         else
7791         {
7792             --position.chars_read_current_line;
7793         }
7794
7795         if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7796         {
7797             JSON_ASSERT(!token_string.empty());
7798             token_string.pop_back();
7799         }
7800     }
7801
7802     /// add a character to token_buffer
7803     void add(char_int_type c)
7804     {
7805         token_buffer.push_back(static_cast<typename string_t::value_type>(c));
7806     }
7807
7808   public:
7809     /////////////////////
7810     // value getters
7811     /////////////////////
7812
7813     /// return integer value
7814     constexpr number_integer_t get_number_integer() const noexcept
7815     {
7816         return value_integer;
7817     }
7818
7819     /// return unsigned integer value
7820     constexpr number_unsigned_t get_number_unsigned() const noexcept
7821     {
7822         return value_unsigned;
7823     }
7824
7825     /// return floating-point value
7826     constexpr number_float_t get_number_float() const noexcept
7827     {
7828         return value_float;
7829     }
7830
7831     /// return current string value (implicitly resets the token; useful only once)
7832     string_t& get_string()
7833     {
7834         return token_buffer;
7835     }
7836
7837     /////////////////////
7838     // diagnostics
7839     /////////////////////
7840
7841     /// return position of last read token
7842     constexpr position_t get_position() const noexcept
7843     {
7844         return position;
7845     }
7846
7847     /// return the last read token (for errors only).  Will never contain EOF
7848     /// (an arbitrary value that is not a valid char value, often -1), because
7849     /// 255 may legitimately occur.  May contain NUL, which should be escaped.
7850     std::string get_token_string() const
7851     {
7852         // escape control characters
7853         std::string result;
7854         for (const auto c : token_string)
7855         {
7856             if (static_cast<unsigned char>(c) <= '\x1F')
7857             {
7858                 // escape control characters
7859                 std::array<char, 9> cs{{}};
7860                 static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
7861                 result += cs.data();
7862             }
7863             else
7864             {
7865                 // add character as is
7866                 result.push_back(static_cast<std::string::value_type>(c));
7867             }
7868         }
7869
7870         return result;
7871     }
7872
7873     /// return syntax error message
7874     JSON_HEDLEY_RETURNS_NON_NULL
7875     constexpr const char* get_error_message() const noexcept
7876     {
7877         return error_message;
7878     }
7879
7880     /////////////////////
7881     // actual scanner
7882     /////////////////////
7883
7884     /*!
7885     @brief skip the UTF-8 byte order mark
7886     @return true iff there is no BOM or the correct BOM has been skipped
7887     */
7888     bool skip_bom()
7889     {
7890         if (get() == 0xEF)
7891         {
7892             // check if we completely parse the BOM
7893             return get() == 0xBB && get() == 0xBF;
7894         }
7895
7896         // the first character is not the beginning of the BOM; unget it to
7897         // process is later
7898         unget();
7899         return true;
7900     }
7901
7902     void skip_whitespace()
7903     {
7904         do
7905         {
7906             get();
7907         }
7908         while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
7909     }
7910
7911     token_type scan()
7912     {
7913         // initially, skip the BOM
7914         if (position.chars_read_total == 0 && !skip_bom())
7915         {
7916             error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
7917             return token_type::parse_error;
7918         }
7919
7920         // read next character and ignore whitespace
7921         skip_whitespace();
7922
7923         // ignore comments
7924         while (ignore_comments && current == '/')
7925         {
7926             if (!scan_comment())
7927             {
7928                 return token_type::parse_error;
7929             }
7930
7931             // skip following whitespace
7932             skip_whitespace();
7933         }
7934
7935         switch (current)
7936         {
7937             // structural characters
7938             case '[':
7939                 return token_type::begin_array;
7940             case ']':
7941                 return token_type::end_array;
7942             case '{':
7943                 return token_type::begin_object;
7944             case '}':
7945                 return token_type::end_object;
7946             case ':':
7947                 return token_type::name_separator;
7948             case ',':
7949                 return token_type::value_separator;
7950
7951             // literals
7952             case 't':
7953             {
7954                 std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
7955                 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
7956             }
7957             case 'f':
7958             {
7959                 std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
7960                 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
7961             }
7962             case 'n':
7963             {
7964                 std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
7965                 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
7966             }
7967
7968             // string
7969             case '\"':
7970                 return scan_string();
7971
7972             // number
7973             case '-':
7974             case '0':
7975             case '1':
7976             case '2':
7977             case '3':
7978             case '4':
7979             case '5':
7980             case '6':
7981             case '7':
7982             case '8':
7983             case '9':
7984                 return scan_number();
7985
7986             // end of input (the null byte is needed when parsing from
7987             // string literals)
7988             case '\0':
7989             case std::char_traits<char_type>::eof():
7990                 return token_type::end_of_input;
7991
7992             // error
7993             default:
7994                 error_message = "invalid literal";
7995                 return token_type::parse_error;
7996         }
7997     }
7998
7999   private:
8000     /// input adapter
8001     InputAdapterType ia;
8002
8003     /// whether comments should be ignored (true) or signaled as errors (false)
8004     const bool ignore_comments = false;
8005
8006     /// the current character
8007     char_int_type current = std::char_traits<char_type>::eof();
8008
8009     /// whether the next get() call should just return current
8010     bool next_unget = false;
8011
8012     /// the start position of the current token
8013     position_t position {};
8014
8015     /// raw input token string (for error messages)
8016     std::vector<char_type> token_string {};
8017
8018     /// buffer for variable-length tokens (numbers, strings)
8019     string_t token_buffer {};
8020
8021     /// a description of occurred lexer errors
8022     const char* error_message = "";
8023
8024     // number values
8025     number_integer_t value_integer = 0;
8026     number_unsigned_t value_unsigned = 0;
8027     number_float_t value_float = 0;
8028
8029     /// the decimal point
8030     const char_int_type decimal_point_char = '.';
8031 };
8032 }  // namespace detail
8033 }  // namespace nlohmann
8034
8035 // #include <nlohmann/detail/macro_scope.hpp>
8036
8037 // #include <nlohmann/detail/meta/is_sax.hpp>
8038
8039
8040 #include <cstdint> // size_t
8041 #include <utility> // declval
8042 #include <string> // string
8043
8044 // #include <nlohmann/detail/meta/detected.hpp>
8045
8046 // #include <nlohmann/detail/meta/type_traits.hpp>
8047
8048
8049 namespace nlohmann
8050 {
8051 namespace detail
8052 {
8053 template<typename T>
8054 using null_function_t = decltype(std::declval<T&>().null());
8055
8056 template<typename T>
8057 using boolean_function_t =
8058     decltype(std::declval<T&>().boolean(std::declval<bool>()));
8059
8060 template<typename T, typename Integer>
8061 using number_integer_function_t =
8062     decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8063
8064 template<typename T, typename Unsigned>
8065 using number_unsigned_function_t =
8066     decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8067
8068 template<typename T, typename Float, typename String>
8069 using number_float_function_t = decltype(std::declval<T&>().number_float(
8070                                     std::declval<Float>(), std::declval<const String&>()));
8071
8072 template<typename T, typename String>
8073 using string_function_t =
8074     decltype(std::declval<T&>().string(std::declval<String&>()));
8075
8076 template<typename T, typename Binary>
8077 using binary_function_t =
8078     decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8079
8080 template<typename T>
8081 using start_object_function_t =
8082     decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8083
8084 template<typename T, typename String>
8085 using key_function_t =
8086     decltype(std::declval<T&>().key(std::declval<String&>()));
8087
8088 template<typename T>
8089 using end_object_function_t = decltype(std::declval<T&>().end_object());
8090
8091 template<typename T>
8092 using start_array_function_t =
8093     decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
8094
8095 template<typename T>
8096 using end_array_function_t = decltype(std::declval<T&>().end_array());
8097
8098 template<typename T, typename Exception>
8099 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
8100         std::declval<std::size_t>(), std::declval<const std::string&>(),
8101         std::declval<const Exception&>()));
8102
8103 template<typename SAX, typename BasicJsonType>
8104 struct is_sax
8105 {
8106   private:
8107     static_assert(is_basic_json<BasicJsonType>::value,
8108                   "BasicJsonType must be of type basic_json<...>");
8109
8110     using number_integer_t = typename BasicJsonType::number_integer_t;
8111     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8112     using number_float_t = typename BasicJsonType::number_float_t;
8113     using string_t = typename BasicJsonType::string_t;
8114     using binary_t = typename BasicJsonType::binary_t;
8115     using exception_t = typename BasicJsonType::exception;
8116
8117   public:
8118     static constexpr bool value =
8119         is_detected_exact<bool, null_function_t, SAX>::value &&
8120         is_detected_exact<bool, boolean_function_t, SAX>::value &&
8121         is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
8122         is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
8123         is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
8124         is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
8125         is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
8126         is_detected_exact<bool, start_object_function_t, SAX>::value &&
8127         is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
8128         is_detected_exact<bool, end_object_function_t, SAX>::value &&
8129         is_detected_exact<bool, start_array_function_t, SAX>::value &&
8130         is_detected_exact<bool, end_array_function_t, SAX>::value &&
8131         is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
8132 };
8133
8134 template<typename SAX, typename BasicJsonType>
8135 struct is_sax_static_asserts
8136 {
8137   private:
8138     static_assert(is_basic_json<BasicJsonType>::value,
8139                   "BasicJsonType must be of type basic_json<...>");
8140
8141     using number_integer_t = typename BasicJsonType::number_integer_t;
8142     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8143     using number_float_t = typename BasicJsonType::number_float_t;
8144     using string_t = typename BasicJsonType::string_t;
8145     using binary_t = typename BasicJsonType::binary_t;
8146     using exception_t = typename BasicJsonType::exception;
8147
8148   public:
8149     static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
8150                   "Missing/invalid function: bool null()");
8151     static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8152                   "Missing/invalid function: bool boolean(bool)");
8153     static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
8154                   "Missing/invalid function: bool boolean(bool)");
8155     static_assert(
8156         is_detected_exact<bool, number_integer_function_t, SAX,
8157         number_integer_t>::value,
8158         "Missing/invalid function: bool number_integer(number_integer_t)");
8159     static_assert(
8160         is_detected_exact<bool, number_unsigned_function_t, SAX,
8161         number_unsigned_t>::value,
8162         "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
8163     static_assert(is_detected_exact<bool, number_float_function_t, SAX,
8164                   number_float_t, string_t>::value,
8165                   "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
8166     static_assert(
8167         is_detected_exact<bool, string_function_t, SAX, string_t>::value,
8168         "Missing/invalid function: bool string(string_t&)");
8169     static_assert(
8170         is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
8171         "Missing/invalid function: bool binary(binary_t&)");
8172     static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
8173                   "Missing/invalid function: bool start_object(std::size_t)");
8174     static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
8175                   "Missing/invalid function: bool key(string_t&)");
8176     static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
8177                   "Missing/invalid function: bool end_object()");
8178     static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
8179                   "Missing/invalid function: bool start_array(std::size_t)");
8180     static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
8181                   "Missing/invalid function: bool end_array()");
8182     static_assert(
8183         is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
8184         "Missing/invalid function: bool parse_error(std::size_t, const "
8185         "std::string&, const exception&)");
8186 };
8187 }  // namespace detail
8188 }  // namespace nlohmann
8189
8190 // #include <nlohmann/detail/meta/type_traits.hpp>
8191
8192 // #include <nlohmann/detail/value_t.hpp>
8193
8194
8195 namespace nlohmann
8196 {
8197 namespace detail
8198 {
8199
8200 /// how to treat CBOR tags
8201 enum class cbor_tag_handler_t
8202 {
8203     error,   ///< throw a parse_error exception in case of a tag
8204     ignore,  ///< ignore tags
8205     store    ///< store tags as binary type
8206 };
8207
8208 /*!
8209 @brief determine system byte order
8210
8211 @return true if and only if system's byte order is little endian
8212
8213 @note from https://stackoverflow.com/a/1001328/266378
8214 */
8215 static inline bool little_endianness(int num = 1) noexcept
8216 {
8217     return *reinterpret_cast<char*>(&num) == 1;
8218 }
8219
8220
8221 ///////////////////
8222 // binary reader //
8223 ///////////////////
8224
8225 /*!
8226 @brief deserialization of CBOR, MessagePack, and UBJSON values
8227 */
8228 template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
8229 class binary_reader
8230 {
8231     using number_integer_t = typename BasicJsonType::number_integer_t;
8232     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
8233     using number_float_t = typename BasicJsonType::number_float_t;
8234     using string_t = typename BasicJsonType::string_t;
8235     using binary_t = typename BasicJsonType::binary_t;
8236     using json_sax_t = SAX;
8237     using char_type = typename InputAdapterType::char_type;
8238     using char_int_type = typename std::char_traits<char_type>::int_type;
8239
8240   public:
8241     /*!
8242     @brief create a binary reader
8243
8244     @param[in] adapter  input adapter to read from
8245     */
8246     explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
8247     {
8248         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
8249     }
8250
8251     // make class move-only
8252     binary_reader(const binary_reader&) = delete;
8253     binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
8254     binary_reader& operator=(const binary_reader&) = delete;
8255     binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
8256     ~binary_reader() = default;
8257
8258     /*!
8259     @param[in] format  the binary format to parse
8260     @param[in] sax_    a SAX event processor
8261     @param[in] strict  whether to expect the input to be consumed completed
8262     @param[in] tag_handler  how to treat CBOR tags
8263
8264     @return whether parsing was successful
8265     */
8266     JSON_HEDLEY_NON_NULL(3)
8267     bool sax_parse(const input_format_t format,
8268                    json_sax_t* sax_,
8269                    const bool strict = true,
8270                    const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
8271     {
8272         sax = sax_;
8273         bool result = false;
8274
8275         switch (format)
8276         {
8277             case input_format_t::bson:
8278                 result = parse_bson_internal();
8279                 break;
8280
8281             case input_format_t::cbor:
8282                 result = parse_cbor_internal(true, tag_handler);
8283                 break;
8284
8285             case input_format_t::msgpack:
8286                 result = parse_msgpack_internal();
8287                 break;
8288
8289             case input_format_t::ubjson:
8290                 result = parse_ubjson_internal();
8291                 break;
8292
8293             case input_format_t::json: // LCOV_EXCL_LINE
8294             default:            // LCOV_EXCL_LINE
8295                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
8296         }
8297
8298         // strict mode: next byte must be EOF
8299         if (result && strict)
8300         {
8301             if (format == input_format_t::ubjson)
8302             {
8303                 get_ignore_noop();
8304             }
8305             else
8306             {
8307                 get();
8308             }
8309
8310             if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
8311             {
8312                 return sax->parse_error(chars_read, get_token_string(),
8313                                         parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value"), BasicJsonType()));
8314             }
8315         }
8316
8317         return result;
8318     }
8319
8320   private:
8321     //////////
8322     // BSON //
8323     //////////
8324
8325     /*!
8326     @brief Reads in a BSON-object and passes it to the SAX-parser.
8327     @return whether a valid BSON-value was passed to the SAX parser
8328     */
8329     bool parse_bson_internal()
8330     {
8331         std::int32_t document_size{};
8332         get_number<std::int32_t, true>(input_format_t::bson, document_size);
8333
8334         if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
8335         {
8336             return false;
8337         }
8338
8339         if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
8340         {
8341             return false;
8342         }
8343
8344         return sax->end_object();
8345     }
8346
8347     /*!
8348     @brief Parses a C-style string from the BSON input.
8349     @param[in,out] result  A reference to the string variable where the read
8350                             string is to be stored.
8351     @return `true` if the \x00-byte indicating the end of the string was
8352              encountered before the EOF; false` indicates an unexpected EOF.
8353     */
8354     bool get_bson_cstr(string_t& result)
8355     {
8356         auto out = std::back_inserter(result);
8357         while (true)
8358         {
8359             get();
8360             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
8361             {
8362                 return false;
8363             }
8364             if (current == 0x00)
8365             {
8366                 return true;
8367             }
8368             *out++ = static_cast<typename string_t::value_type>(current);
8369         }
8370     }
8371
8372     /*!
8373     @brief Parses a zero-terminated string of length @a len from the BSON
8374            input.
8375     @param[in] len  The length (including the zero-byte at the end) of the
8376                     string to be read.
8377     @param[in,out] result  A reference to the string variable where the read
8378                             string is to be stored.
8379     @tparam NumberType The type of the length @a len
8380     @pre len >= 1
8381     @return `true` if the string was successfully parsed
8382     */
8383     template<typename NumberType>
8384     bool get_bson_string(const NumberType len, string_t& result)
8385     {
8386         if (JSON_HEDLEY_UNLIKELY(len < 1))
8387         {
8388             auto last_token = get_token_string();
8389             return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string"), BasicJsonType()));
8390         }
8391
8392         return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
8393     }
8394
8395     /*!
8396     @brief Parses a byte array input of length @a len from the BSON input.
8397     @param[in] len  The length of the byte array to be read.
8398     @param[in,out] result  A reference to the binary variable where the read
8399                             array is to be stored.
8400     @tparam NumberType The type of the length @a len
8401     @pre len >= 0
8402     @return `true` if the byte array was successfully parsed
8403     */
8404     template<typename NumberType>
8405     bool get_bson_binary(const NumberType len, binary_t& result)
8406     {
8407         if (JSON_HEDLEY_UNLIKELY(len < 0))
8408         {
8409             auto last_token = get_token_string();
8410             return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary"), BasicJsonType()));
8411         }
8412
8413         // All BSON binary values have a subtype
8414         std::uint8_t subtype{};
8415         get_number<std::uint8_t>(input_format_t::bson, subtype);
8416         result.set_subtype(subtype);
8417
8418         return get_binary(input_format_t::bson, len, result);
8419     }
8420
8421     /*!
8422     @brief Read a BSON document element of the given @a element_type.
8423     @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
8424     @param[in] element_type_parse_position The position in the input stream,
8425                where the `element_type` was read.
8426     @warning Not all BSON element types are supported yet. An unsupported
8427              @a element_type will give rise to a parse_error.114:
8428              Unsupported BSON record type 0x...
8429     @return whether a valid BSON-object/array was passed to the SAX parser
8430     */
8431     bool parse_bson_element_internal(const char_int_type element_type,
8432                                      const std::size_t element_type_parse_position)
8433     {
8434         switch (element_type)
8435         {
8436             case 0x01: // double
8437             {
8438                 double number{};
8439                 return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
8440             }
8441
8442             case 0x02: // string
8443             {
8444                 std::int32_t len{};
8445                 string_t value;
8446                 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
8447             }
8448
8449             case 0x03: // object
8450             {
8451                 return parse_bson_internal();
8452             }
8453
8454             case 0x04: // array
8455             {
8456                 return parse_bson_array();
8457             }
8458
8459             case 0x05: // binary
8460             {
8461                 std::int32_t len{};
8462                 binary_t value;
8463                 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
8464             }
8465
8466             case 0x08: // boolean
8467             {
8468                 return sax->boolean(get() != 0);
8469             }
8470
8471             case 0x0A: // null
8472             {
8473                 return sax->null();
8474             }
8475
8476             case 0x10: // int32
8477             {
8478                 std::int32_t value{};
8479                 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8480             }
8481
8482             case 0x12: // int64
8483             {
8484                 std::int64_t value{};
8485                 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
8486             }
8487
8488             default: // anything else not supported (yet)
8489             {
8490                 std::array<char, 3> cr{{}};
8491                 static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8492                 return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data()), BasicJsonType()));
8493             }
8494         }
8495     }
8496
8497     /*!
8498     @brief Read a BSON element list (as specified in the BSON-spec)
8499
8500     The same binary layout is used for objects and arrays, hence it must be
8501     indicated with the argument @a is_array which one is expected
8502     (true --> array, false --> object).
8503
8504     @param[in] is_array Determines if the element list being read is to be
8505                         treated as an object (@a is_array == false), or as an
8506                         array (@a is_array == true).
8507     @return whether a valid BSON-object/array was passed to the SAX parser
8508     */
8509     bool parse_bson_element_list(const bool is_array)
8510     {
8511         string_t key;
8512
8513         while (auto element_type = get())
8514         {
8515             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
8516             {
8517                 return false;
8518             }
8519
8520             const std::size_t element_type_parse_position = chars_read;
8521             if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
8522             {
8523                 return false;
8524             }
8525
8526             if (!is_array && !sax->key(key))
8527             {
8528                 return false;
8529             }
8530
8531             if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
8532             {
8533                 return false;
8534             }
8535
8536             // get_bson_cstr only appends
8537             key.clear();
8538         }
8539
8540         return true;
8541     }
8542
8543     /*!
8544     @brief Reads an array from the BSON input and passes it to the SAX-parser.
8545     @return whether a valid BSON-array was passed to the SAX parser
8546     */
8547     bool parse_bson_array()
8548     {
8549         std::int32_t document_size{};
8550         get_number<std::int32_t, true>(input_format_t::bson, document_size);
8551
8552         if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
8553         {
8554             return false;
8555         }
8556
8557         if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
8558         {
8559             return false;
8560         }
8561
8562         return sax->end_array();
8563     }
8564
8565     //////////
8566     // CBOR //
8567     //////////
8568
8569     /*!
8570     @param[in] get_char  whether a new character should be retrieved from the
8571                          input (true) or whether the last read character should
8572                          be considered instead (false)
8573     @param[in] tag_handler how CBOR tags should be treated
8574
8575     @return whether a valid CBOR value was passed to the SAX parser
8576     */
8577     bool parse_cbor_internal(const bool get_char,
8578                              const cbor_tag_handler_t tag_handler)
8579     {
8580         switch (get_char ? get() : current)
8581         {
8582             // EOF
8583             case std::char_traits<char_type>::eof():
8584                 return unexpect_eof(input_format_t::cbor, "value");
8585
8586             // Integer 0x00..0x17 (0..23)
8587             case 0x00:
8588             case 0x01:
8589             case 0x02:
8590             case 0x03:
8591             case 0x04:
8592             case 0x05:
8593             case 0x06:
8594             case 0x07:
8595             case 0x08:
8596             case 0x09:
8597             case 0x0A:
8598             case 0x0B:
8599             case 0x0C:
8600             case 0x0D:
8601             case 0x0E:
8602             case 0x0F:
8603             case 0x10:
8604             case 0x11:
8605             case 0x12:
8606             case 0x13:
8607             case 0x14:
8608             case 0x15:
8609             case 0x16:
8610             case 0x17:
8611                 return sax->number_unsigned(static_cast<number_unsigned_t>(current));
8612
8613             case 0x18: // Unsigned integer (one-byte uint8_t follows)
8614             {
8615                 std::uint8_t number{};
8616                 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8617             }
8618
8619             case 0x19: // Unsigned integer (two-byte uint16_t follows)
8620             {
8621                 std::uint16_t number{};
8622                 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8623             }
8624
8625             case 0x1A: // Unsigned integer (four-byte uint32_t follows)
8626             {
8627                 std::uint32_t number{};
8628                 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8629             }
8630
8631             case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
8632             {
8633                 std::uint64_t number{};
8634                 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8635             }
8636
8637             // Negative integer -1-0x00..-1-0x17 (-1..-24)
8638             case 0x20:
8639             case 0x21:
8640             case 0x22:
8641             case 0x23:
8642             case 0x24:
8643             case 0x25:
8644             case 0x26:
8645             case 0x27:
8646             case 0x28:
8647             case 0x29:
8648             case 0x2A:
8649             case 0x2B:
8650             case 0x2C:
8651             case 0x2D:
8652             case 0x2E:
8653             case 0x2F:
8654             case 0x30:
8655             case 0x31:
8656             case 0x32:
8657             case 0x33:
8658             case 0x34:
8659             case 0x35:
8660             case 0x36:
8661             case 0x37:
8662                 return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
8663
8664             case 0x38: // Negative integer (one-byte uint8_t follows)
8665             {
8666                 std::uint8_t number{};
8667                 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8668             }
8669
8670             case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
8671             {
8672                 std::uint16_t number{};
8673                 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8674             }
8675
8676             case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
8677             {
8678                 std::uint32_t number{};
8679                 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8680             }
8681
8682             case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
8683             {
8684                 std::uint64_t number{};
8685                 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
8686                         - static_cast<number_integer_t>(number));
8687             }
8688
8689             // Binary data (0x00..0x17 bytes follow)
8690             case 0x40:
8691             case 0x41:
8692             case 0x42:
8693             case 0x43:
8694             case 0x44:
8695             case 0x45:
8696             case 0x46:
8697             case 0x47:
8698             case 0x48:
8699             case 0x49:
8700             case 0x4A:
8701             case 0x4B:
8702             case 0x4C:
8703             case 0x4D:
8704             case 0x4E:
8705             case 0x4F:
8706             case 0x50:
8707             case 0x51:
8708             case 0x52:
8709             case 0x53:
8710             case 0x54:
8711             case 0x55:
8712             case 0x56:
8713             case 0x57:
8714             case 0x58: // Binary data (one-byte uint8_t for n follows)
8715             case 0x59: // Binary data (two-byte uint16_t for n follow)
8716             case 0x5A: // Binary data (four-byte uint32_t for n follow)
8717             case 0x5B: // Binary data (eight-byte uint64_t for n follow)
8718             case 0x5F: // Binary data (indefinite length)
8719             {
8720                 binary_t b;
8721                 return get_cbor_binary(b) && sax->binary(b);
8722             }
8723
8724             // UTF-8 string (0x00..0x17 bytes follow)
8725             case 0x60:
8726             case 0x61:
8727             case 0x62:
8728             case 0x63:
8729             case 0x64:
8730             case 0x65:
8731             case 0x66:
8732             case 0x67:
8733             case 0x68:
8734             case 0x69:
8735             case 0x6A:
8736             case 0x6B:
8737             case 0x6C:
8738             case 0x6D:
8739             case 0x6E:
8740             case 0x6F:
8741             case 0x70:
8742             case 0x71:
8743             case 0x72:
8744             case 0x73:
8745             case 0x74:
8746             case 0x75:
8747             case 0x76:
8748             case 0x77:
8749             case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
8750             case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
8751             case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
8752             case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
8753             case 0x7F: // UTF-8 string (indefinite length)
8754             {
8755                 string_t s;
8756                 return get_cbor_string(s) && sax->string(s);
8757             }
8758
8759             // array (0x00..0x17 data items follow)
8760             case 0x80:
8761             case 0x81:
8762             case 0x82:
8763             case 0x83:
8764             case 0x84:
8765             case 0x85:
8766             case 0x86:
8767             case 0x87:
8768             case 0x88:
8769             case 0x89:
8770             case 0x8A:
8771             case 0x8B:
8772             case 0x8C:
8773             case 0x8D:
8774             case 0x8E:
8775             case 0x8F:
8776             case 0x90:
8777             case 0x91:
8778             case 0x92:
8779             case 0x93:
8780             case 0x94:
8781             case 0x95:
8782             case 0x96:
8783             case 0x97:
8784                 return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8785
8786             case 0x98: // array (one-byte uint8_t for n follows)
8787             {
8788                 std::uint8_t len{};
8789                 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8790             }
8791
8792             case 0x99: // array (two-byte uint16_t for n follow)
8793             {
8794                 std::uint16_t len{};
8795                 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8796             }
8797
8798             case 0x9A: // array (four-byte uint32_t for n follow)
8799             {
8800                 std::uint32_t len{};
8801                 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8802             }
8803
8804             case 0x9B: // array (eight-byte uint64_t for n follow)
8805             {
8806                 std::uint64_t len{};
8807                 return get_number(input_format_t::cbor, len) && get_cbor_array(detail::conditional_static_cast<std::size_t>(len), tag_handler);
8808             }
8809
8810             case 0x9F: // array (indefinite length)
8811                 return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
8812
8813             // map (0x00..0x17 pairs of data items follow)
8814             case 0xA0:
8815             case 0xA1:
8816             case 0xA2:
8817             case 0xA3:
8818             case 0xA4:
8819             case 0xA5:
8820             case 0xA6:
8821             case 0xA7:
8822             case 0xA8:
8823             case 0xA9:
8824             case 0xAA:
8825             case 0xAB:
8826             case 0xAC:
8827             case 0xAD:
8828             case 0xAE:
8829             case 0xAF:
8830             case 0xB0:
8831             case 0xB1:
8832             case 0xB2:
8833             case 0xB3:
8834             case 0xB4:
8835             case 0xB5:
8836             case 0xB6:
8837             case 0xB7:
8838                 return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8839
8840             case 0xB8: // map (one-byte uint8_t for n follows)
8841             {
8842                 std::uint8_t len{};
8843                 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8844             }
8845
8846             case 0xB9: // map (two-byte uint16_t for n follow)
8847             {
8848                 std::uint16_t len{};
8849                 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8850             }
8851
8852             case 0xBA: // map (four-byte uint32_t for n follow)
8853             {
8854                 std::uint32_t len{};
8855                 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8856             }
8857
8858             case 0xBB: // map (eight-byte uint64_t for n follow)
8859             {
8860                 std::uint64_t len{};
8861                 return get_number(input_format_t::cbor, len) && get_cbor_object(detail::conditional_static_cast<std::size_t>(len), tag_handler);
8862             }
8863
8864             case 0xBF: // map (indefinite length)
8865                 return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
8866
8867             case 0xC6: // tagged item
8868             case 0xC7:
8869             case 0xC8:
8870             case 0xC9:
8871             case 0xCA:
8872             case 0xCB:
8873             case 0xCC:
8874             case 0xCD:
8875             case 0xCE:
8876             case 0xCF:
8877             case 0xD0:
8878             case 0xD1:
8879             case 0xD2:
8880             case 0xD3:
8881             case 0xD4:
8882             case 0xD8: // tagged item (1 bytes follow)
8883             case 0xD9: // tagged item (2 bytes follow)
8884             case 0xDA: // tagged item (4 bytes follow)
8885             case 0xDB: // tagged item (8 bytes follow)
8886             {
8887                 switch (tag_handler)
8888                 {
8889                     case cbor_tag_handler_t::error:
8890                     {
8891                         auto last_token = get_token_string();
8892                         return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
8893                     }
8894
8895                     case cbor_tag_handler_t::ignore:
8896                     {
8897                         // ignore binary subtype
8898                         switch (current)
8899                         {
8900                             case 0xD8:
8901                             {
8902                                 std::uint8_t subtype_to_ignore{};
8903                                 get_number(input_format_t::cbor, subtype_to_ignore);
8904                                 break;
8905                             }
8906                             case 0xD9:
8907                             {
8908                                 std::uint16_t subtype_to_ignore{};
8909                                 get_number(input_format_t::cbor, subtype_to_ignore);
8910                                 break;
8911                             }
8912                             case 0xDA:
8913                             {
8914                                 std::uint32_t subtype_to_ignore{};
8915                                 get_number(input_format_t::cbor, subtype_to_ignore);
8916                                 break;
8917                             }
8918                             case 0xDB:
8919                             {
8920                                 std::uint64_t subtype_to_ignore{};
8921                                 get_number(input_format_t::cbor, subtype_to_ignore);
8922                                 break;
8923                             }
8924                             default:
8925                                 break;
8926                         }
8927                         return parse_cbor_internal(true, tag_handler);
8928                     }
8929
8930                     case cbor_tag_handler_t::store:
8931                     {
8932                         binary_t b;
8933                         // use binary subtype and store in binary container
8934                         switch (current)
8935                         {
8936                             case 0xD8:
8937                             {
8938                                 std::uint8_t subtype{};
8939                                 get_number(input_format_t::cbor, subtype);
8940                                 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8941                                 break;
8942                             }
8943                             case 0xD9:
8944                             {
8945                                 std::uint16_t subtype{};
8946                                 get_number(input_format_t::cbor, subtype);
8947                                 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8948                                 break;
8949                             }
8950                             case 0xDA:
8951                             {
8952                                 std::uint32_t subtype{};
8953                                 get_number(input_format_t::cbor, subtype);
8954                                 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8955                                 break;
8956                             }
8957                             case 0xDB:
8958                             {
8959                                 std::uint64_t subtype{};
8960                                 get_number(input_format_t::cbor, subtype);
8961                                 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
8962                                 break;
8963                             }
8964                             default:
8965                                 return parse_cbor_internal(true, tag_handler);
8966                         }
8967                         get();
8968                         return get_cbor_binary(b) && sax->binary(b);
8969                     }
8970
8971                     default:                 // LCOV_EXCL_LINE
8972                         JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
8973                         return false;        // LCOV_EXCL_LINE
8974                 }
8975             }
8976
8977             case 0xF4: // false
8978                 return sax->boolean(false);
8979
8980             case 0xF5: // true
8981                 return sax->boolean(true);
8982
8983             case 0xF6: // null
8984                 return sax->null();
8985
8986             case 0xF9: // Half-Precision Float (two-byte IEEE 754)
8987             {
8988                 const auto byte1_raw = get();
8989                 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8990                 {
8991                     return false;
8992                 }
8993                 const auto byte2_raw = get();
8994                 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8995                 {
8996                     return false;
8997                 }
8998
8999                 const auto byte1 = static_cast<unsigned char>(byte1_raw);
9000                 const auto byte2 = static_cast<unsigned char>(byte2_raw);
9001
9002                 // code from RFC 7049, Appendix D, Figure 3:
9003                 // As half-precision floating-point numbers were only added
9004                 // to IEEE 754 in 2008, today's programming platforms often
9005                 // still only have limited support for them. It is very
9006                 // easy to include at least decoding support for them even
9007                 // without such support. An example of a small decoder for
9008                 // half-precision floating-point numbers in the C language
9009                 // is shown in Fig. 3.
9010                 const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
9011                 const double val = [&half]
9012                 {
9013                     const int exp = (half >> 10u) & 0x1Fu;
9014                     const unsigned int mant = half & 0x3FFu;
9015                     JSON_ASSERT(0 <= exp&& exp <= 32);
9016                     JSON_ASSERT(mant <= 1024);
9017                     switch (exp)
9018                     {
9019                         case 0:
9020                             return std::ldexp(mant, -24);
9021                         case 31:
9022                             return (mant == 0)
9023                             ? std::numeric_limits<double>::infinity()
9024                             : std::numeric_limits<double>::quiet_NaN();
9025                         default:
9026                             return std::ldexp(mant + 1024, exp - 25);
9027                     }
9028                 }();
9029                 return sax->number_float((half & 0x8000u) != 0
9030                                          ? static_cast<number_float_t>(-val)
9031                                          : static_cast<number_float_t>(val), "");
9032             }
9033
9034             case 0xFA: // Single-Precision Float (four-byte IEEE 754)
9035             {
9036                 float number{};
9037                 return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
9038             }
9039
9040             case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
9041             {
9042                 double number{};
9043                 return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
9044             }
9045
9046             default: // anything else (0xFF is handled inside the other types)
9047             {
9048                 auto last_token = get_token_string();
9049                 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
9050             }
9051         }
9052     }
9053
9054     /*!
9055     @brief reads a CBOR string
9056
9057     This function first reads starting bytes to determine the expected
9058     string length and then copies this number of bytes into a string.
9059     Additionally, CBOR's strings with indefinite lengths are supported.
9060
9061     @param[out] result  created string
9062
9063     @return whether string creation completed
9064     */
9065     bool get_cbor_string(string_t& result)
9066     {
9067         if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
9068         {
9069             return false;
9070         }
9071
9072         switch (current)
9073         {
9074             // UTF-8 string (0x00..0x17 bytes follow)
9075             case 0x60:
9076             case 0x61:
9077             case 0x62:
9078             case 0x63:
9079             case 0x64:
9080             case 0x65:
9081             case 0x66:
9082             case 0x67:
9083             case 0x68:
9084             case 0x69:
9085             case 0x6A:
9086             case 0x6B:
9087             case 0x6C:
9088             case 0x6D:
9089             case 0x6E:
9090             case 0x6F:
9091             case 0x70:
9092             case 0x71:
9093             case 0x72:
9094             case 0x73:
9095             case 0x74:
9096             case 0x75:
9097             case 0x76:
9098             case 0x77:
9099             {
9100                 return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
9101             }
9102
9103             case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
9104             {
9105                 std::uint8_t len{};
9106                 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9107             }
9108
9109             case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
9110             {
9111                 std::uint16_t len{};
9112                 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9113             }
9114
9115             case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
9116             {
9117                 std::uint32_t len{};
9118                 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9119             }
9120
9121             case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
9122             {
9123                 std::uint64_t len{};
9124                 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
9125             }
9126
9127             case 0x7F: // UTF-8 string (indefinite length)
9128             {
9129                 while (get() != 0xFF)
9130                 {
9131                     string_t chunk;
9132                     if (!get_cbor_string(chunk))
9133                     {
9134                         return false;
9135                     }
9136                     result.append(chunk);
9137                 }
9138                 return true;
9139             }
9140
9141             default:
9142             {
9143                 auto last_token = get_token_string();
9144                 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string"), BasicJsonType()));
9145             }
9146         }
9147     }
9148
9149     /*!
9150     @brief reads a CBOR byte array
9151
9152     This function first reads starting bytes to determine the expected
9153     byte array length and then copies this number of bytes into the byte array.
9154     Additionally, CBOR's byte arrays with indefinite lengths are supported.
9155
9156     @param[out] result  created byte array
9157
9158     @return whether byte array creation completed
9159     */
9160     bool get_cbor_binary(binary_t& result)
9161     {
9162         if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
9163         {
9164             return false;
9165         }
9166
9167         switch (current)
9168         {
9169             // Binary data (0x00..0x17 bytes follow)
9170             case 0x40:
9171             case 0x41:
9172             case 0x42:
9173             case 0x43:
9174             case 0x44:
9175             case 0x45:
9176             case 0x46:
9177             case 0x47:
9178             case 0x48:
9179             case 0x49:
9180             case 0x4A:
9181             case 0x4B:
9182             case 0x4C:
9183             case 0x4D:
9184             case 0x4E:
9185             case 0x4F:
9186             case 0x50:
9187             case 0x51:
9188             case 0x52:
9189             case 0x53:
9190             case 0x54:
9191             case 0x55:
9192             case 0x56:
9193             case 0x57:
9194             {
9195                 return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
9196             }
9197
9198             case 0x58: // Binary data (one-byte uint8_t for n follows)
9199             {
9200                 std::uint8_t len{};
9201                 return get_number(input_format_t::cbor, len) &&
9202                        get_binary(input_format_t::cbor, len, result);
9203             }
9204
9205             case 0x59: // Binary data (two-byte uint16_t for n follow)
9206             {
9207                 std::uint16_t len{};
9208                 return get_number(input_format_t::cbor, len) &&
9209                        get_binary(input_format_t::cbor, len, result);
9210             }
9211
9212             case 0x5A: // Binary data (four-byte uint32_t for n follow)
9213             {
9214                 std::uint32_t len{};
9215                 return get_number(input_format_t::cbor, len) &&
9216                        get_binary(input_format_t::cbor, len, result);
9217             }
9218
9219             case 0x5B: // Binary data (eight-byte uint64_t for n follow)
9220             {
9221                 std::uint64_t len{};
9222                 return get_number(input_format_t::cbor, len) &&
9223                        get_binary(input_format_t::cbor, len, result);
9224             }
9225
9226             case 0x5F: // Binary data (indefinite length)
9227             {
9228                 while (get() != 0xFF)
9229                 {
9230                     binary_t chunk;
9231                     if (!get_cbor_binary(chunk))
9232                     {
9233                         return false;
9234                     }
9235                     result.insert(result.end(), chunk.begin(), chunk.end());
9236                 }
9237                 return true;
9238             }
9239
9240             default:
9241             {
9242                 auto last_token = get_token_string();
9243                 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary"), BasicJsonType()));
9244             }
9245         }
9246     }
9247
9248     /*!
9249     @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
9250                     array of indefinite size
9251     @param[in] tag_handler how CBOR tags should be treated
9252     @return whether array creation completed
9253     */
9254     bool get_cbor_array(const std::size_t len,
9255                         const cbor_tag_handler_t tag_handler)
9256     {
9257         if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9258         {
9259             return false;
9260         }
9261
9262         if (len != static_cast<std::size_t>(-1))
9263         {
9264             for (std::size_t i = 0; i < len; ++i)
9265             {
9266                 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
9267                 {
9268                     return false;
9269                 }
9270             }
9271         }
9272         else
9273         {
9274             while (get() != 0xFF)
9275             {
9276                 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
9277                 {
9278                     return false;
9279                 }
9280             }
9281         }
9282
9283         return sax->end_array();
9284     }
9285
9286     /*!
9287     @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
9288                     object of indefinite size
9289     @param[in] tag_handler how CBOR tags should be treated
9290     @return whether object creation completed
9291     */
9292     bool get_cbor_object(const std::size_t len,
9293                          const cbor_tag_handler_t tag_handler)
9294     {
9295         if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9296         {
9297             return false;
9298         }
9299
9300         if (len != 0)
9301         {
9302             string_t key;
9303             if (len != static_cast<std::size_t>(-1))
9304             {
9305                 for (std::size_t i = 0; i < len; ++i)
9306                 {
9307                     get();
9308                     if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9309                     {
9310                         return false;
9311                     }
9312
9313                     if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
9314                     {
9315                         return false;
9316                     }
9317                     key.clear();
9318                 }
9319             }
9320             else
9321             {
9322                 while (get() != 0xFF)
9323                 {
9324                     if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
9325                     {
9326                         return false;
9327                     }
9328
9329                     if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
9330                     {
9331                         return false;
9332                     }
9333                     key.clear();
9334                 }
9335             }
9336         }
9337
9338         return sax->end_object();
9339     }
9340
9341     /////////////
9342     // MsgPack //
9343     /////////////
9344
9345     /*!
9346     @return whether a valid MessagePack value was passed to the SAX parser
9347     */
9348     bool parse_msgpack_internal()
9349     {
9350         switch (get())
9351         {
9352             // EOF
9353             case std::char_traits<char_type>::eof():
9354                 return unexpect_eof(input_format_t::msgpack, "value");
9355
9356             // positive fixint
9357             case 0x00:
9358             case 0x01:
9359             case 0x02:
9360             case 0x03:
9361             case 0x04:
9362             case 0x05:
9363             case 0x06:
9364             case 0x07:
9365             case 0x08:
9366             case 0x09:
9367             case 0x0A:
9368             case 0x0B:
9369             case 0x0C:
9370             case 0x0D:
9371             case 0x0E:
9372             case 0x0F:
9373             case 0x10:
9374             case 0x11:
9375             case 0x12:
9376             case 0x13:
9377             case 0x14:
9378             case 0x15:
9379             case 0x16:
9380             case 0x17:
9381             case 0x18:
9382             case 0x19:
9383             case 0x1A:
9384             case 0x1B:
9385             case 0x1C:
9386             case 0x1D:
9387             case 0x1E:
9388             case 0x1F:
9389             case 0x20:
9390             case 0x21:
9391             case 0x22:
9392             case 0x23:
9393             case 0x24:
9394             case 0x25:
9395             case 0x26:
9396             case 0x27:
9397             case 0x28:
9398             case 0x29:
9399             case 0x2A:
9400             case 0x2B:
9401             case 0x2C:
9402             case 0x2D:
9403             case 0x2E:
9404             case 0x2F:
9405             case 0x30:
9406             case 0x31:
9407             case 0x32:
9408             case 0x33:
9409             case 0x34:
9410             case 0x35:
9411             case 0x36:
9412             case 0x37:
9413             case 0x38:
9414             case 0x39:
9415             case 0x3A:
9416             case 0x3B:
9417             case 0x3C:
9418             case 0x3D:
9419             case 0x3E:
9420             case 0x3F:
9421             case 0x40:
9422             case 0x41:
9423             case 0x42:
9424             case 0x43:
9425             case 0x44:
9426             case 0x45:
9427             case 0x46:
9428             case 0x47:
9429             case 0x48:
9430             case 0x49:
9431             case 0x4A:
9432             case 0x4B:
9433             case 0x4C:
9434             case 0x4D:
9435             case 0x4E:
9436             case 0x4F:
9437             case 0x50:
9438             case 0x51:
9439             case 0x52:
9440             case 0x53:
9441             case 0x54:
9442             case 0x55:
9443             case 0x56:
9444             case 0x57:
9445             case 0x58:
9446             case 0x59:
9447             case 0x5A:
9448             case 0x5B:
9449             case 0x5C:
9450             case 0x5D:
9451             case 0x5E:
9452             case 0x5F:
9453             case 0x60:
9454             case 0x61:
9455             case 0x62:
9456             case 0x63:
9457             case 0x64:
9458             case 0x65:
9459             case 0x66:
9460             case 0x67:
9461             case 0x68:
9462             case 0x69:
9463             case 0x6A:
9464             case 0x6B:
9465             case 0x6C:
9466             case 0x6D:
9467             case 0x6E:
9468             case 0x6F:
9469             case 0x70:
9470             case 0x71:
9471             case 0x72:
9472             case 0x73:
9473             case 0x74:
9474             case 0x75:
9475             case 0x76:
9476             case 0x77:
9477             case 0x78:
9478             case 0x79:
9479             case 0x7A:
9480             case 0x7B:
9481             case 0x7C:
9482             case 0x7D:
9483             case 0x7E:
9484             case 0x7F:
9485                 return sax->number_unsigned(static_cast<number_unsigned_t>(current));
9486
9487             // fixmap
9488             case 0x80:
9489             case 0x81:
9490             case 0x82:
9491             case 0x83:
9492             case 0x84:
9493             case 0x85:
9494             case 0x86:
9495             case 0x87:
9496             case 0x88:
9497             case 0x89:
9498             case 0x8A:
9499             case 0x8B:
9500             case 0x8C:
9501             case 0x8D:
9502             case 0x8E:
9503             case 0x8F:
9504                 return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
9505
9506             // fixarray
9507             case 0x90:
9508             case 0x91:
9509             case 0x92:
9510             case 0x93:
9511             case 0x94:
9512             case 0x95:
9513             case 0x96:
9514             case 0x97:
9515             case 0x98:
9516             case 0x99:
9517             case 0x9A:
9518             case 0x9B:
9519             case 0x9C:
9520             case 0x9D:
9521             case 0x9E:
9522             case 0x9F:
9523                 return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
9524
9525             // fixstr
9526             case 0xA0:
9527             case 0xA1:
9528             case 0xA2:
9529             case 0xA3:
9530             case 0xA4:
9531             case 0xA5:
9532             case 0xA6:
9533             case 0xA7:
9534             case 0xA8:
9535             case 0xA9:
9536             case 0xAA:
9537             case 0xAB:
9538             case 0xAC:
9539             case 0xAD:
9540             case 0xAE:
9541             case 0xAF:
9542             case 0xB0:
9543             case 0xB1:
9544             case 0xB2:
9545             case 0xB3:
9546             case 0xB4:
9547             case 0xB5:
9548             case 0xB6:
9549             case 0xB7:
9550             case 0xB8:
9551             case 0xB9:
9552             case 0xBA:
9553             case 0xBB:
9554             case 0xBC:
9555             case 0xBD:
9556             case 0xBE:
9557             case 0xBF:
9558             case 0xD9: // str 8
9559             case 0xDA: // str 16
9560             case 0xDB: // str 32
9561             {
9562                 string_t s;
9563                 return get_msgpack_string(s) && sax->string(s);
9564             }
9565
9566             case 0xC0: // nil
9567                 return sax->null();
9568
9569             case 0xC2: // false
9570                 return sax->boolean(false);
9571
9572             case 0xC3: // true
9573                 return sax->boolean(true);
9574
9575             case 0xC4: // bin 8
9576             case 0xC5: // bin 16
9577             case 0xC6: // bin 32
9578             case 0xC7: // ext 8
9579             case 0xC8: // ext 16
9580             case 0xC9: // ext 32
9581             case 0xD4: // fixext 1
9582             case 0xD5: // fixext 2
9583             case 0xD6: // fixext 4
9584             case 0xD7: // fixext 8
9585             case 0xD8: // fixext 16
9586             {
9587                 binary_t b;
9588                 return get_msgpack_binary(b) && sax->binary(b);
9589             }
9590
9591             case 0xCA: // float 32
9592             {
9593                 float number{};
9594                 return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9595             }
9596
9597             case 0xCB: // float 64
9598             {
9599                 double number{};
9600                 return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9601             }
9602
9603             case 0xCC: // uint 8
9604             {
9605                 std::uint8_t number{};
9606                 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9607             }
9608
9609             case 0xCD: // uint 16
9610             {
9611                 std::uint16_t number{};
9612                 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9613             }
9614
9615             case 0xCE: // uint 32
9616             {
9617                 std::uint32_t number{};
9618                 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9619             }
9620
9621             case 0xCF: // uint 64
9622             {
9623                 std::uint64_t number{};
9624                 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9625             }
9626
9627             case 0xD0: // int 8
9628             {
9629                 std::int8_t number{};
9630                 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9631             }
9632
9633             case 0xD1: // int 16
9634             {
9635                 std::int16_t number{};
9636                 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9637             }
9638
9639             case 0xD2: // int 32
9640             {
9641                 std::int32_t number{};
9642                 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9643             }
9644
9645             case 0xD3: // int 64
9646             {
9647                 std::int64_t number{};
9648                 return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9649             }
9650
9651             case 0xDC: // array 16
9652             {
9653                 std::uint16_t len{};
9654                 return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9655             }
9656
9657             case 0xDD: // array 32
9658             {
9659                 std::uint32_t len{};
9660                 return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9661             }
9662
9663             case 0xDE: // map 16
9664             {
9665                 std::uint16_t len{};
9666                 return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9667             }
9668
9669             case 0xDF: // map 32
9670             {
9671                 std::uint32_t len{};
9672                 return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9673             }
9674
9675             // negative fixint
9676             case 0xE0:
9677             case 0xE1:
9678             case 0xE2:
9679             case 0xE3:
9680             case 0xE4:
9681             case 0xE5:
9682             case 0xE6:
9683             case 0xE7:
9684             case 0xE8:
9685             case 0xE9:
9686             case 0xEA:
9687             case 0xEB:
9688             case 0xEC:
9689             case 0xED:
9690             case 0xEE:
9691             case 0xEF:
9692             case 0xF0:
9693             case 0xF1:
9694             case 0xF2:
9695             case 0xF3:
9696             case 0xF4:
9697             case 0xF5:
9698             case 0xF6:
9699             case 0xF7:
9700             case 0xF8:
9701             case 0xF9:
9702             case 0xFA:
9703             case 0xFB:
9704             case 0xFC:
9705             case 0xFD:
9706             case 0xFE:
9707             case 0xFF:
9708                 return sax->number_integer(static_cast<std::int8_t>(current));
9709
9710             default: // anything else
9711             {
9712                 auto last_token = get_token_string();
9713                 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
9714             }
9715         }
9716     }
9717
9718     /*!
9719     @brief reads a MessagePack string
9720
9721     This function first reads starting bytes to determine the expected
9722     string length and then copies this number of bytes into a string.
9723
9724     @param[out] result  created string
9725
9726     @return whether string creation completed
9727     */
9728     bool get_msgpack_string(string_t& result)
9729     {
9730         if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
9731         {
9732             return false;
9733         }
9734
9735         switch (current)
9736         {
9737             // fixstr
9738             case 0xA0:
9739             case 0xA1:
9740             case 0xA2:
9741             case 0xA3:
9742             case 0xA4:
9743             case 0xA5:
9744             case 0xA6:
9745             case 0xA7:
9746             case 0xA8:
9747             case 0xA9:
9748             case 0xAA:
9749             case 0xAB:
9750             case 0xAC:
9751             case 0xAD:
9752             case 0xAE:
9753             case 0xAF:
9754             case 0xB0:
9755             case 0xB1:
9756             case 0xB2:
9757             case 0xB3:
9758             case 0xB4:
9759             case 0xB5:
9760             case 0xB6:
9761             case 0xB7:
9762             case 0xB8:
9763             case 0xB9:
9764             case 0xBA:
9765             case 0xBB:
9766             case 0xBC:
9767             case 0xBD:
9768             case 0xBE:
9769             case 0xBF:
9770             {
9771                 return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
9772             }
9773
9774             case 0xD9: // str 8
9775             {
9776                 std::uint8_t len{};
9777                 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9778             }
9779
9780             case 0xDA: // str 16
9781             {
9782                 std::uint16_t len{};
9783                 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9784             }
9785
9786             case 0xDB: // str 32
9787             {
9788                 std::uint32_t len{};
9789                 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9790             }
9791
9792             default:
9793             {
9794                 auto last_token = get_token_string();
9795                 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string"), BasicJsonType()));
9796             }
9797         }
9798     }
9799
9800     /*!
9801     @brief reads a MessagePack byte array
9802
9803     This function first reads starting bytes to determine the expected
9804     byte array length and then copies this number of bytes into a byte array.
9805
9806     @param[out] result  created byte array
9807
9808     @return whether byte array creation completed
9809     */
9810     bool get_msgpack_binary(binary_t& result)
9811     {
9812         // helper function to set the subtype
9813         auto assign_and_return_true = [&result](std::int8_t subtype)
9814         {
9815             result.set_subtype(static_cast<std::uint8_t>(subtype));
9816             return true;
9817         };
9818
9819         switch (current)
9820         {
9821             case 0xC4: // bin 8
9822             {
9823                 std::uint8_t len{};
9824                 return get_number(input_format_t::msgpack, len) &&
9825                        get_binary(input_format_t::msgpack, len, result);
9826             }
9827
9828             case 0xC5: // bin 16
9829             {
9830                 std::uint16_t len{};
9831                 return get_number(input_format_t::msgpack, len) &&
9832                        get_binary(input_format_t::msgpack, len, result);
9833             }
9834
9835             case 0xC6: // bin 32
9836             {
9837                 std::uint32_t len{};
9838                 return get_number(input_format_t::msgpack, len) &&
9839                        get_binary(input_format_t::msgpack, len, result);
9840             }
9841
9842             case 0xC7: // ext 8
9843             {
9844                 std::uint8_t len{};
9845                 std::int8_t subtype{};
9846                 return get_number(input_format_t::msgpack, len) &&
9847                        get_number(input_format_t::msgpack, subtype) &&
9848                        get_binary(input_format_t::msgpack, len, result) &&
9849                        assign_and_return_true(subtype);
9850             }
9851
9852             case 0xC8: // ext 16
9853             {
9854                 std::uint16_t len{};
9855                 std::int8_t subtype{};
9856                 return get_number(input_format_t::msgpack, len) &&
9857                        get_number(input_format_t::msgpack, subtype) &&
9858                        get_binary(input_format_t::msgpack, len, result) &&
9859                        assign_and_return_true(subtype);
9860             }
9861
9862             case 0xC9: // ext 32
9863             {
9864                 std::uint32_t len{};
9865                 std::int8_t subtype{};
9866                 return get_number(input_format_t::msgpack, len) &&
9867                        get_number(input_format_t::msgpack, subtype) &&
9868                        get_binary(input_format_t::msgpack, len, result) &&
9869                        assign_and_return_true(subtype);
9870             }
9871
9872             case 0xD4: // fixext 1
9873             {
9874                 std::int8_t subtype{};
9875                 return get_number(input_format_t::msgpack, subtype) &&
9876                        get_binary(input_format_t::msgpack, 1, result) &&
9877                        assign_and_return_true(subtype);
9878             }
9879
9880             case 0xD5: // fixext 2
9881             {
9882                 std::int8_t subtype{};
9883                 return get_number(input_format_t::msgpack, subtype) &&
9884                        get_binary(input_format_t::msgpack, 2, result) &&
9885                        assign_and_return_true(subtype);
9886             }
9887
9888             case 0xD6: // fixext 4
9889             {
9890                 std::int8_t subtype{};
9891                 return get_number(input_format_t::msgpack, subtype) &&
9892                        get_binary(input_format_t::msgpack, 4, result) &&
9893                        assign_and_return_true(subtype);
9894             }
9895
9896             case 0xD7: // fixext 8
9897             {
9898                 std::int8_t subtype{};
9899                 return get_number(input_format_t::msgpack, subtype) &&
9900                        get_binary(input_format_t::msgpack, 8, result) &&
9901                        assign_and_return_true(subtype);
9902             }
9903
9904             case 0xD8: // fixext 16
9905             {
9906                 std::int8_t subtype{};
9907                 return get_number(input_format_t::msgpack, subtype) &&
9908                        get_binary(input_format_t::msgpack, 16, result) &&
9909                        assign_and_return_true(subtype);
9910             }
9911
9912             default:           // LCOV_EXCL_LINE
9913                 return false;  // LCOV_EXCL_LINE
9914         }
9915     }
9916
9917     /*!
9918     @param[in] len  the length of the array
9919     @return whether array creation completed
9920     */
9921     bool get_msgpack_array(const std::size_t len)
9922     {
9923         if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9924         {
9925             return false;
9926         }
9927
9928         for (std::size_t i = 0; i < len; ++i)
9929         {
9930             if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9931             {
9932                 return false;
9933             }
9934         }
9935
9936         return sax->end_array();
9937     }
9938
9939     /*!
9940     @param[in] len  the length of the object
9941     @return whether object creation completed
9942     */
9943     bool get_msgpack_object(const std::size_t len)
9944     {
9945         if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9946         {
9947             return false;
9948         }
9949
9950         string_t key;
9951         for (std::size_t i = 0; i < len; ++i)
9952         {
9953             get();
9954             if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
9955             {
9956                 return false;
9957             }
9958
9959             if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9960             {
9961                 return false;
9962             }
9963             key.clear();
9964         }
9965
9966         return sax->end_object();
9967     }
9968
9969     ////////////
9970     // UBJSON //
9971     ////////////
9972
9973     /*!
9974     @param[in] get_char  whether a new character should be retrieved from the
9975                          input (true, default) or whether the last read
9976                          character should be considered instead
9977
9978     @return whether a valid UBJSON value was passed to the SAX parser
9979     */
9980     bool parse_ubjson_internal(const bool get_char = true)
9981     {
9982         return get_ubjson_value(get_char ? get_ignore_noop() : current);
9983     }
9984
9985     /*!
9986     @brief reads a UBJSON string
9987
9988     This function is either called after reading the 'S' byte explicitly
9989     indicating a string, or in case of an object key where the 'S' byte can be
9990     left out.
9991
9992     @param[out] result   created string
9993     @param[in] get_char  whether a new character should be retrieved from the
9994                          input (true, default) or whether the last read
9995                          character should be considered instead
9996
9997     @return whether string creation completed
9998     */
9999     bool get_ubjson_string(string_t& result, const bool get_char = true)
10000     {
10001         if (get_char)
10002         {
10003             get();  // TODO(niels): may we ignore N here?
10004         }
10005
10006         if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
10007         {
10008             return false;
10009         }
10010
10011         switch (current)
10012         {
10013             case 'U':
10014             {
10015                 std::uint8_t len{};
10016                 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10017             }
10018
10019             case 'i':
10020             {
10021                 std::int8_t len{};
10022                 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10023             }
10024
10025             case 'I':
10026             {
10027                 std::int16_t len{};
10028                 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10029             }
10030
10031             case 'l':
10032             {
10033                 std::int32_t len{};
10034                 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10035             }
10036
10037             case 'L':
10038             {
10039                 std::int64_t len{};
10040                 return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
10041             }
10042
10043             default:
10044                 auto last_token = get_token_string();
10045                 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string"), BasicJsonType()));
10046         }
10047     }
10048
10049     /*!
10050     @param[out] result  determined size
10051     @return whether size determination completed
10052     */
10053     bool get_ubjson_size_value(std::size_t& result)
10054     {
10055         switch (get_ignore_noop())
10056         {
10057             case 'U':
10058             {
10059                 std::uint8_t number{};
10060                 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10061                 {
10062                     return false;
10063                 }
10064                 result = static_cast<std::size_t>(number);
10065                 return true;
10066             }
10067
10068             case 'i':
10069             {
10070                 std::int8_t number{};
10071                 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10072                 {
10073                     return false;
10074                 }
10075                 result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
10076                 return true;
10077             }
10078
10079             case 'I':
10080             {
10081                 std::int16_t number{};
10082                 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10083                 {
10084                     return false;
10085                 }
10086                 result = static_cast<std::size_t>(number);
10087                 return true;
10088             }
10089
10090             case 'l':
10091             {
10092                 std::int32_t number{};
10093                 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10094                 {
10095                     return false;
10096                 }
10097                 result = static_cast<std::size_t>(number);
10098                 return true;
10099             }
10100
10101             case 'L':
10102             {
10103                 std::int64_t number{};
10104                 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
10105                 {
10106                     return false;
10107                 }
10108                 result = static_cast<std::size_t>(number);
10109                 return true;
10110             }
10111
10112             default:
10113             {
10114                 auto last_token = get_token_string();
10115                 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size"), BasicJsonType()));
10116             }
10117         }
10118     }
10119
10120     /*!
10121     @brief determine the type and size for a container
10122
10123     In the optimized UBJSON format, a type and a size can be provided to allow
10124     for a more compact representation.
10125
10126     @param[out] result  pair of the size and the type
10127
10128     @return whether pair creation completed
10129     */
10130     bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
10131     {
10132         result.first = string_t::npos; // size
10133         result.second = 0; // type
10134
10135         get_ignore_noop();
10136
10137         if (current == '$')
10138         {
10139             result.second = get();  // must not ignore 'N', because 'N' maybe the type
10140             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
10141             {
10142                 return false;
10143             }
10144
10145             get_ignore_noop();
10146             if (JSON_HEDLEY_UNLIKELY(current != '#'))
10147             {
10148                 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
10149                 {
10150                     return false;
10151                 }
10152                 auto last_token = get_token_string();
10153                 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size"), BasicJsonType()));
10154             }
10155
10156             return get_ubjson_size_value(result.first);
10157         }
10158
10159         if (current == '#')
10160         {
10161             return get_ubjson_size_value(result.first);
10162         }
10163
10164         return true;
10165     }
10166
10167     /*!
10168     @param prefix  the previously read or set type prefix
10169     @return whether value creation completed
10170     */
10171     bool get_ubjson_value(const char_int_type prefix)
10172     {
10173         switch (prefix)
10174         {
10175             case std::char_traits<char_type>::eof():  // EOF
10176                 return unexpect_eof(input_format_t::ubjson, "value");
10177
10178             case 'T':  // true
10179                 return sax->boolean(true);
10180             case 'F':  // false
10181                 return sax->boolean(false);
10182
10183             case 'Z':  // null
10184                 return sax->null();
10185
10186             case 'U':
10187             {
10188                 std::uint8_t number{};
10189                 return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
10190             }
10191
10192             case 'i':
10193             {
10194                 std::int8_t number{};
10195                 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10196             }
10197
10198             case 'I':
10199             {
10200                 std::int16_t number{};
10201                 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10202             }
10203
10204             case 'l':
10205             {
10206                 std::int32_t number{};
10207                 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10208             }
10209
10210             case 'L':
10211             {
10212                 std::int64_t number{};
10213                 return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
10214             }
10215
10216             case 'd':
10217             {
10218                 float number{};
10219                 return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
10220             }
10221
10222             case 'D':
10223             {
10224                 double number{};
10225                 return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
10226             }
10227
10228             case 'H':
10229             {
10230                 return get_ubjson_high_precision_number();
10231             }
10232
10233             case 'C':  // char
10234             {
10235                 get();
10236                 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
10237                 {
10238                     return false;
10239                 }
10240                 if (JSON_HEDLEY_UNLIKELY(current > 127))
10241                 {
10242                     auto last_token = get_token_string();
10243                     return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char"), BasicJsonType()));
10244                 }
10245                 string_t s(1, static_cast<typename string_t::value_type>(current));
10246                 return sax->string(s);
10247             }
10248
10249             case 'S':  // string
10250             {
10251                 string_t s;
10252                 return get_ubjson_string(s) && sax->string(s);
10253             }
10254
10255             case '[':  // array
10256                 return get_ubjson_array();
10257
10258             case '{':  // object
10259                 return get_ubjson_object();
10260
10261             default: // anything else
10262             {
10263                 auto last_token = get_token_string();
10264                 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
10265             }
10266         }
10267     }
10268
10269     /*!
10270     @return whether array creation completed
10271     */
10272     bool get_ubjson_array()
10273     {
10274         std::pair<std::size_t, char_int_type> size_and_type;
10275         if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10276         {
10277             return false;
10278         }
10279
10280         if (size_and_type.first != string_t::npos)
10281         {
10282             if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
10283             {
10284                 return false;
10285             }
10286
10287             if (size_and_type.second != 0)
10288             {
10289                 if (size_and_type.second != 'N')
10290                 {
10291                     for (std::size_t i = 0; i < size_and_type.first; ++i)
10292                     {
10293                         if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10294                         {
10295                             return false;
10296                         }
10297                     }
10298                 }
10299             }
10300             else
10301             {
10302                 for (std::size_t i = 0; i < size_and_type.first; ++i)
10303                 {
10304                     if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10305                     {
10306                         return false;
10307                     }
10308                 }
10309             }
10310         }
10311         else
10312         {
10313             if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
10314             {
10315                 return false;
10316             }
10317
10318             while (current != ']')
10319             {
10320                 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
10321                 {
10322                     return false;
10323                 }
10324                 get_ignore_noop();
10325             }
10326         }
10327
10328         return sax->end_array();
10329     }
10330
10331     /*!
10332     @return whether object creation completed
10333     */
10334     bool get_ubjson_object()
10335     {
10336         std::pair<std::size_t, char_int_type> size_and_type;
10337         if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
10338         {
10339             return false;
10340         }
10341
10342         string_t key;
10343         if (size_and_type.first != string_t::npos)
10344         {
10345             if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
10346             {
10347                 return false;
10348             }
10349
10350             if (size_and_type.second != 0)
10351             {
10352                 for (std::size_t i = 0; i < size_and_type.first; ++i)
10353                 {
10354                     if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10355                     {
10356                         return false;
10357                     }
10358                     if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
10359                     {
10360                         return false;
10361                     }
10362                     key.clear();
10363                 }
10364             }
10365             else
10366             {
10367                 for (std::size_t i = 0; i < size_and_type.first; ++i)
10368                 {
10369                     if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
10370                     {
10371                         return false;
10372                     }
10373                     if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10374                     {
10375                         return false;
10376                     }
10377                     key.clear();
10378                 }
10379             }
10380         }
10381         else
10382         {
10383             if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
10384             {
10385                 return false;
10386             }
10387
10388             while (current != '}')
10389             {
10390                 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
10391                 {
10392                     return false;
10393                 }
10394                 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
10395                 {
10396                     return false;
10397                 }
10398                 get_ignore_noop();
10399                 key.clear();
10400             }
10401         }
10402
10403         return sax->end_object();
10404     }
10405
10406     // Note, no reader for UBJSON binary types is implemented because they do
10407     // not exist
10408
10409     bool get_ubjson_high_precision_number()
10410     {
10411         // get size of following number string
10412         std::size_t size{};
10413         auto res = get_ubjson_size_value(size);
10414         if (JSON_HEDLEY_UNLIKELY(!res))
10415         {
10416             return res;
10417         }
10418
10419         // get number string
10420         std::vector<char> number_vector;
10421         for (std::size_t i = 0; i < size; ++i)
10422         {
10423             get();
10424             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
10425             {
10426                 return false;
10427             }
10428             number_vector.push_back(static_cast<char>(current));
10429         }
10430
10431         // parse number string
10432         using ia_type = decltype(detail::input_adapter(number_vector));
10433         auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
10434         const auto result_number = number_lexer.scan();
10435         const auto number_string = number_lexer.get_token_string();
10436         const auto result_remainder = number_lexer.scan();
10437
10438         using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
10439
10440         if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
10441         {
10442             return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
10443         }
10444
10445         switch (result_number)
10446         {
10447             case token_type::value_integer:
10448                 return sax->number_integer(number_lexer.get_number_integer());
10449             case token_type::value_unsigned:
10450                 return sax->number_unsigned(number_lexer.get_number_unsigned());
10451             case token_type::value_float:
10452                 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
10453             case token_type::uninitialized:
10454             case token_type::literal_true:
10455             case token_type::literal_false:
10456             case token_type::literal_null:
10457             case token_type::value_string:
10458             case token_type::begin_array:
10459             case token_type::begin_object:
10460             case token_type::end_array:
10461             case token_type::end_object:
10462             case token_type::name_separator:
10463             case token_type::value_separator:
10464             case token_type::parse_error:
10465             case token_type::end_of_input:
10466             case token_type::literal_or_value:
10467             default:
10468                 return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
10469         }
10470     }
10471
10472     ///////////////////////
10473     // Utility functions //
10474     ///////////////////////
10475
10476     /*!
10477     @brief get next character from the input
10478
10479     This function provides the interface to the used input adapter. It does
10480     not throw in case the input reached EOF, but returns a -'ve valued
10481     `std::char_traits<char_type>::eof()` in that case.
10482
10483     @return character read from the input
10484     */
10485     char_int_type get()
10486     {
10487         ++chars_read;
10488         return current = ia.get_character();
10489     }
10490
10491     /*!
10492     @return character read from the input after ignoring all 'N' entries
10493     */
10494     char_int_type get_ignore_noop()
10495     {
10496         do
10497         {
10498             get();
10499         }
10500         while (current == 'N');
10501
10502         return current;
10503     }
10504
10505     /*
10506     @brief read a number from the input
10507
10508     @tparam NumberType the type of the number
10509     @param[in] format   the current format (for diagnostics)
10510     @param[out] result  number of type @a NumberType
10511
10512     @return whether conversion completed
10513
10514     @note This function needs to respect the system's endianness, because
10515           bytes in CBOR, MessagePack, and UBJSON are stored in network order
10516           (big endian) and therefore need reordering on little endian systems.
10517     */
10518     template<typename NumberType, bool InputIsLittleEndian = false>
10519     bool get_number(const input_format_t format, NumberType& result)
10520     {
10521         // step 1: read input into array with system's byte order
10522         std::array<std::uint8_t, sizeof(NumberType)> vec{};
10523         for (std::size_t i = 0; i < sizeof(NumberType); ++i)
10524         {
10525             get();
10526             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
10527             {
10528                 return false;
10529             }
10530
10531             // reverse byte order prior to conversion if necessary
10532             if (is_little_endian != InputIsLittleEndian)
10533             {
10534                 vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
10535             }
10536             else
10537             {
10538                 vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
10539             }
10540         }
10541
10542         // step 2: convert array into number of type T and return
10543         std::memcpy(&result, vec.data(), sizeof(NumberType));
10544         return true;
10545     }
10546
10547     /*!
10548     @brief create a string by reading characters from the input
10549
10550     @tparam NumberType the type of the number
10551     @param[in] format the current format (for diagnostics)
10552     @param[in] len number of characters to read
10553     @param[out] result string created by reading @a len bytes
10554
10555     @return whether string creation completed
10556
10557     @note We can not reserve @a len bytes for the result, because @a len
10558           may be too large. Usually, @ref unexpect_eof() detects the end of
10559           the input before we run out of string memory.
10560     */
10561     template<typename NumberType>
10562     bool get_string(const input_format_t format,
10563                     const NumberType len,
10564                     string_t& result)
10565     {
10566         bool success = true;
10567         for (NumberType i = 0; i < len; i++)
10568         {
10569             get();
10570             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
10571             {
10572                 success = false;
10573                 break;
10574             }
10575             result.push_back(static_cast<typename string_t::value_type>(current));
10576         }
10577         return success;
10578     }
10579
10580     /*!
10581     @brief create a byte array by reading bytes from the input
10582
10583     @tparam NumberType the type of the number
10584     @param[in] format the current format (for diagnostics)
10585     @param[in] len number of bytes to read
10586     @param[out] result byte array created by reading @a len bytes
10587
10588     @return whether byte array creation completed
10589
10590     @note We can not reserve @a len bytes for the result, because @a len
10591           may be too large. Usually, @ref unexpect_eof() detects the end of
10592           the input before we run out of memory.
10593     */
10594     template<typename NumberType>
10595     bool get_binary(const input_format_t format,
10596                     const NumberType len,
10597                     binary_t& result)
10598     {
10599         bool success = true;
10600         for (NumberType i = 0; i < len; i++)
10601         {
10602             get();
10603             if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
10604             {
10605                 success = false;
10606                 break;
10607             }
10608             result.push_back(static_cast<std::uint8_t>(current));
10609         }
10610         return success;
10611     }
10612
10613     /*!
10614     @param[in] format   the current format (for diagnostics)
10615     @param[in] context  further context information (for diagnostics)
10616     @return whether the last read character is not EOF
10617     */
10618     JSON_HEDLEY_NON_NULL(3)
10619     bool unexpect_eof(const input_format_t format, const char* context) const
10620     {
10621         if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10622         {
10623             return sax->parse_error(chars_read, "<end of file>",
10624                                     parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), BasicJsonType()));
10625         }
10626         return true;
10627     }
10628
10629     /*!
10630     @return a string representation of the last read byte
10631     */
10632     std::string get_token_string() const
10633     {
10634         std::array<char, 3> cr{{}};
10635         static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
10636         return std::string{cr.data()};
10637     }
10638
10639     /*!
10640     @param[in] format   the current format
10641     @param[in] detail   a detailed error message
10642     @param[in] context  further context information
10643     @return a message string to use in the parse_error exceptions
10644     */
10645     std::string exception_message(const input_format_t format,
10646                                   const std::string& detail,
10647                                   const std::string& context) const
10648     {
10649         std::string error_msg = "syntax error while parsing ";
10650
10651         switch (format)
10652         {
10653             case input_format_t::cbor:
10654                 error_msg += "CBOR";
10655                 break;
10656
10657             case input_format_t::msgpack:
10658                 error_msg += "MessagePack";
10659                 break;
10660
10661             case input_format_t::ubjson:
10662                 error_msg += "UBJSON";
10663                 break;
10664
10665             case input_format_t::bson:
10666                 error_msg += "BSON";
10667                 break;
10668
10669             case input_format_t::json: // LCOV_EXCL_LINE
10670             default:            // LCOV_EXCL_LINE
10671                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
10672         }
10673
10674         return error_msg + " " + context + ": " + detail;
10675     }
10676
10677   private:
10678     /// input adapter
10679     InputAdapterType ia;
10680
10681     /// the current character
10682     char_int_type current = std::char_traits<char_type>::eof();
10683
10684     /// the number of characters read
10685     std::size_t chars_read = 0;
10686
10687     /// whether we can assume little endianness
10688     const bool is_little_endian = little_endianness();
10689
10690     /// the SAX parser
10691     json_sax_t* sax = nullptr;
10692 };
10693 }  // namespace detail
10694 }  // namespace nlohmann
10695
10696 // #include <nlohmann/detail/input/input_adapters.hpp>
10697
10698 // #include <nlohmann/detail/input/lexer.hpp>
10699
10700 // #include <nlohmann/detail/input/parser.hpp>
10701
10702
10703 #include <cmath> // isfinite
10704 #include <cstdint> // uint8_t
10705 #include <functional> // function
10706 #include <string> // string
10707 #include <utility> // move
10708 #include <vector> // vector
10709
10710 // #include <nlohmann/detail/exceptions.hpp>
10711
10712 // #include <nlohmann/detail/input/input_adapters.hpp>
10713
10714 // #include <nlohmann/detail/input/json_sax.hpp>
10715
10716 // #include <nlohmann/detail/input/lexer.hpp>
10717
10718 // #include <nlohmann/detail/macro_scope.hpp>
10719
10720 // #include <nlohmann/detail/meta/is_sax.hpp>
10721
10722 // #include <nlohmann/detail/value_t.hpp>
10723
10724
10725 namespace nlohmann
10726 {
10727 namespace detail
10728 {
10729 ////////////
10730 // parser //
10731 ////////////
10732
10733 enum class parse_event_t : std::uint8_t
10734 {
10735     /// the parser read `{` and started to process a JSON object
10736     object_start,
10737     /// the parser read `}` and finished processing a JSON object
10738     object_end,
10739     /// the parser read `[` and started to process a JSON array
10740     array_start,
10741     /// the parser read `]` and finished processing a JSON array
10742     array_end,
10743     /// the parser read a key of a value in an object
10744     key,
10745     /// the parser finished reading a JSON value
10746     value
10747 };
10748
10749 template<typename BasicJsonType>
10750 using parser_callback_t =
10751     std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
10752
10753 /*!
10754 @brief syntax analysis
10755
10756 This class implements a recursive descent parser.
10757 */
10758 template<typename BasicJsonType, typename InputAdapterType>
10759 class parser
10760 {
10761     using number_integer_t = typename BasicJsonType::number_integer_t;
10762     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
10763     using number_float_t = typename BasicJsonType::number_float_t;
10764     using string_t = typename BasicJsonType::string_t;
10765     using lexer_t = lexer<BasicJsonType, InputAdapterType>;
10766     using token_type = typename lexer_t::token_type;
10767
10768   public:
10769     /// a parser reading from an input adapter
10770     explicit parser(InputAdapterType&& adapter,
10771                     const parser_callback_t<BasicJsonType> cb = nullptr,
10772                     const bool allow_exceptions_ = true,
10773                     const bool skip_comments = false)
10774         : callback(cb)
10775         , m_lexer(std::move(adapter), skip_comments)
10776         , allow_exceptions(allow_exceptions_)
10777     {
10778         // read first token
10779         get_token();
10780     }
10781
10782     /*!
10783     @brief public parser interface
10784
10785     @param[in] strict      whether to expect the last token to be EOF
10786     @param[in,out] result  parsed JSON value
10787
10788     @throw parse_error.101 in case of an unexpected token
10789     @throw parse_error.102 if to_unicode fails or surrogate error
10790     @throw parse_error.103 if to_unicode fails
10791     */
10792     void parse(const bool strict, BasicJsonType& result)
10793     {
10794         if (callback)
10795         {
10796             json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
10797             sax_parse_internal(&sdp);
10798
10799             // in strict mode, input must be completely read
10800             if (strict && (get_token() != token_type::end_of_input))
10801             {
10802                 sdp.parse_error(m_lexer.get_position(),
10803                                 m_lexer.get_token_string(),
10804                                 parse_error::create(101, m_lexer.get_position(),
10805                                                     exception_message(token_type::end_of_input, "value"), BasicJsonType()));
10806             }
10807
10808             // in case of an error, return discarded value
10809             if (sdp.is_errored())
10810             {
10811                 result = value_t::discarded;
10812                 return;
10813             }
10814
10815             // set top-level value to null if it was discarded by the callback
10816             // function
10817             if (result.is_discarded())
10818             {
10819                 result = nullptr;
10820             }
10821         }
10822         else
10823         {
10824             json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
10825             sax_parse_internal(&sdp);
10826
10827             // in strict mode, input must be completely read
10828             if (strict && (get_token() != token_type::end_of_input))
10829             {
10830                 sdp.parse_error(m_lexer.get_position(),
10831                                 m_lexer.get_token_string(),
10832                                 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
10833             }
10834
10835             // in case of an error, return discarded value
10836             if (sdp.is_errored())
10837             {
10838                 result = value_t::discarded;
10839                 return;
10840             }
10841         }
10842
10843         result.assert_invariant();
10844     }
10845
10846     /*!
10847     @brief public accept interface
10848
10849     @param[in] strict  whether to expect the last token to be EOF
10850     @return whether the input is a proper JSON text
10851     */
10852     bool accept(const bool strict = true)
10853     {
10854         json_sax_acceptor<BasicJsonType> sax_acceptor;
10855         return sax_parse(&sax_acceptor, strict);
10856     }
10857
10858     template<typename SAX>
10859     JSON_HEDLEY_NON_NULL(2)
10860     bool sax_parse(SAX* sax, const bool strict = true)
10861     {
10862         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
10863         const bool result = sax_parse_internal(sax);
10864
10865         // strict mode: next byte must be EOF
10866         if (result && strict && (get_token() != token_type::end_of_input))
10867         {
10868             return sax->parse_error(m_lexer.get_position(),
10869                                     m_lexer.get_token_string(),
10870                                     parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
10871         }
10872
10873         return result;
10874     }
10875
10876   private:
10877     template<typename SAX>
10878     JSON_HEDLEY_NON_NULL(2)
10879     bool sax_parse_internal(SAX* sax)
10880     {
10881         // stack to remember the hierarchy of structured values we are parsing
10882         // true = array; false = object
10883         std::vector<bool> states;
10884         // value to avoid a goto (see comment where set to true)
10885         bool skip_to_state_evaluation = false;
10886
10887         while (true)
10888         {
10889             if (!skip_to_state_evaluation)
10890             {
10891                 // invariant: get_token() was called before each iteration
10892                 switch (last_token)
10893                 {
10894                     case token_type::begin_object:
10895                     {
10896                         if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
10897                         {
10898                             return false;
10899                         }
10900
10901                         // closing } -> we are done
10902                         if (get_token() == token_type::end_object)
10903                         {
10904                             if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10905                             {
10906                                 return false;
10907                             }
10908                             break;
10909                         }
10910
10911                         // parse key
10912                         if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
10913                         {
10914                             return sax->parse_error(m_lexer.get_position(),
10915                                                     m_lexer.get_token_string(),
10916                                                     parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), BasicJsonType()));
10917                         }
10918                         if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10919                         {
10920                             return false;
10921                         }
10922
10923                         // parse separator (:)
10924                         if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10925                         {
10926                             return sax->parse_error(m_lexer.get_position(),
10927                                                     m_lexer.get_token_string(),
10928                                                     parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), BasicJsonType()));
10929                         }
10930
10931                         // remember we are now inside an object
10932                         states.push_back(false);
10933
10934                         // parse values
10935                         get_token();
10936                         continue;
10937                     }
10938
10939                     case token_type::begin_array:
10940                     {
10941                         if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
10942                         {
10943                             return false;
10944                         }
10945
10946                         // closing ] -> we are done
10947                         if (get_token() == token_type::end_array)
10948                         {
10949                             if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10950                             {
10951                                 return false;
10952                             }
10953                             break;
10954                         }
10955
10956                         // remember we are now inside an array
10957                         states.push_back(true);
10958
10959                         // parse values (no need to call get_token)
10960                         continue;
10961                     }
10962
10963                     case token_type::value_float:
10964                     {
10965                         const auto res = m_lexer.get_number_float();
10966
10967                         if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
10968                         {
10969                             return sax->parse_error(m_lexer.get_position(),
10970                                                     m_lexer.get_token_string(),
10971                                                     out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'", BasicJsonType()));
10972                         }
10973
10974                         if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
10975                         {
10976                             return false;
10977                         }
10978
10979                         break;
10980                     }
10981
10982                     case token_type::literal_false:
10983                     {
10984                         if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
10985                         {
10986                             return false;
10987                         }
10988                         break;
10989                     }
10990
10991                     case token_type::literal_null:
10992                     {
10993                         if (JSON_HEDLEY_UNLIKELY(!sax->null()))
10994                         {
10995                             return false;
10996                         }
10997                         break;
10998                     }
10999
11000                     case token_type::literal_true:
11001                     {
11002                         if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
11003                         {
11004                             return false;
11005                         }
11006                         break;
11007                     }
11008
11009                     case token_type::value_integer:
11010                     {
11011                         if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
11012                         {
11013                             return false;
11014                         }
11015                         break;
11016                     }
11017
11018                     case token_type::value_string:
11019                     {
11020                         if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
11021                         {
11022                             return false;
11023                         }
11024                         break;
11025                     }
11026
11027                     case token_type::value_unsigned:
11028                     {
11029                         if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
11030                         {
11031                             return false;
11032                         }
11033                         break;
11034                     }
11035
11036                     case token_type::parse_error:
11037                     {
11038                         // using "uninitialized" to avoid "expected" message
11039                         return sax->parse_error(m_lexer.get_position(),
11040                                                 m_lexer.get_token_string(),
11041                                                 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), BasicJsonType()));
11042                     }
11043
11044                     case token_type::uninitialized:
11045                     case token_type::end_array:
11046                     case token_type::end_object:
11047                     case token_type::name_separator:
11048                     case token_type::value_separator:
11049                     case token_type::end_of_input:
11050                     case token_type::literal_or_value:
11051                     default: // the last token was unexpected
11052                     {
11053                         return sax->parse_error(m_lexer.get_position(),
11054                                                 m_lexer.get_token_string(),
11055                                                 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), BasicJsonType()));
11056                     }
11057                 }
11058             }
11059             else
11060             {
11061                 skip_to_state_evaluation = false;
11062             }
11063
11064             // we reached this line after we successfully parsed a value
11065             if (states.empty())
11066             {
11067                 // empty stack: we reached the end of the hierarchy: done
11068                 return true;
11069             }
11070
11071             if (states.back())  // array
11072             {
11073                 // comma -> next value
11074                 if (get_token() == token_type::value_separator)
11075                 {
11076                     // parse a new value
11077                     get_token();
11078                     continue;
11079                 }
11080
11081                 // closing ]
11082                 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
11083                 {
11084                     if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
11085                     {
11086                         return false;
11087                     }
11088
11089                     // We are done with this array. Before we can parse a
11090                     // new value, we need to evaluate the new state first.
11091                     // By setting skip_to_state_evaluation to false, we
11092                     // are effectively jumping to the beginning of this if.
11093                     JSON_ASSERT(!states.empty());
11094                     states.pop_back();
11095                     skip_to_state_evaluation = true;
11096                     continue;
11097                 }
11098
11099                 return sax->parse_error(m_lexer.get_position(),
11100                                         m_lexer.get_token_string(),
11101                                         parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), BasicJsonType()));
11102             }
11103
11104             // states.back() is false -> object
11105
11106             // comma -> next value
11107             if (get_token() == token_type::value_separator)
11108             {
11109                 // parse key
11110                 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
11111                 {
11112                     return sax->parse_error(m_lexer.get_position(),
11113                                             m_lexer.get_token_string(),
11114                                             parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), BasicJsonType()));
11115                 }
11116
11117                 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
11118                 {
11119                     return false;
11120                 }
11121
11122                 // parse separator (:)
11123                 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
11124                 {
11125                     return sax->parse_error(m_lexer.get_position(),
11126                                             m_lexer.get_token_string(),
11127                                             parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), BasicJsonType()));
11128                 }
11129
11130                 // parse values
11131                 get_token();
11132                 continue;
11133             }
11134
11135             // closing }
11136             if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
11137             {
11138                 if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
11139                 {
11140                     return false;
11141                 }
11142
11143                 // We are done with this object. Before we can parse a
11144                 // new value, we need to evaluate the new state first.
11145                 // By setting skip_to_state_evaluation to false, we
11146                 // are effectively jumping to the beginning of this if.
11147                 JSON_ASSERT(!states.empty());
11148                 states.pop_back();
11149                 skip_to_state_evaluation = true;
11150                 continue;
11151             }
11152
11153             return sax->parse_error(m_lexer.get_position(),
11154                                     m_lexer.get_token_string(),
11155                                     parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), BasicJsonType()));
11156         }
11157     }
11158
11159     /// get next token from lexer
11160     token_type get_token()
11161     {
11162         return last_token = m_lexer.scan();
11163     }
11164
11165     std::string exception_message(const token_type expected, const std::string& context)
11166     {
11167         std::string error_msg = "syntax error ";
11168
11169         if (!context.empty())
11170         {
11171             error_msg += "while parsing " + context + " ";
11172         }
11173
11174         error_msg += "- ";
11175
11176         if (last_token == token_type::parse_error)
11177         {
11178             error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
11179                          m_lexer.get_token_string() + "'";
11180         }
11181         else
11182         {
11183             error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
11184         }
11185
11186         if (expected != token_type::uninitialized)
11187         {
11188             error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
11189         }
11190
11191         return error_msg;
11192     }
11193
11194   private:
11195     /// callback function
11196     const parser_callback_t<BasicJsonType> callback = nullptr;
11197     /// the type of the last read token
11198     token_type last_token = token_type::uninitialized;
11199     /// the lexer
11200     lexer_t m_lexer;
11201     /// whether to throw exceptions in case of errors
11202     const bool allow_exceptions = true;
11203 };
11204
11205 }  // namespace detail
11206 }  // namespace nlohmann
11207
11208 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
11209
11210
11211 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
11212
11213
11214 #include <cstddef> // ptrdiff_t
11215 #include <limits>  // numeric_limits
11216
11217 // #include <nlohmann/detail/macro_scope.hpp>
11218
11219
11220 namespace nlohmann
11221 {
11222 namespace detail
11223 {
11224 /*
11225 @brief an iterator for primitive JSON types
11226
11227 This class models an iterator for primitive JSON types (boolean, number,
11228 string). It's only purpose is to allow the iterator/const_iterator classes
11229 to "iterate" over primitive values. Internally, the iterator is modeled by
11230 a `difference_type` variable. Value begin_value (`0`) models the begin,
11231 end_value (`1`) models past the end.
11232 */
11233 class primitive_iterator_t
11234 {
11235   private:
11236     using difference_type = std::ptrdiff_t;
11237     static constexpr difference_type begin_value = 0;
11238     static constexpr difference_type end_value = begin_value + 1;
11239
11240   JSON_PRIVATE_UNLESS_TESTED:
11241     /// iterator as signed integer type
11242     difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
11243
11244   public:
11245     constexpr difference_type get_value() const noexcept
11246     {
11247         return m_it;
11248     }
11249
11250     /// set iterator to a defined beginning
11251     void set_begin() noexcept
11252     {
11253         m_it = begin_value;
11254     }
11255
11256     /// set iterator to a defined past the end
11257     void set_end() noexcept
11258     {
11259         m_it = end_value;
11260     }
11261
11262     /// return whether the iterator can be dereferenced
11263     constexpr bool is_begin() const noexcept
11264     {
11265         return m_it == begin_value;
11266     }
11267
11268     /// return whether the iterator is at end
11269     constexpr bool is_end() const noexcept
11270     {
11271         return m_it == end_value;
11272     }
11273
11274     friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11275     {
11276         return lhs.m_it == rhs.m_it;
11277     }
11278
11279     friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11280     {
11281         return lhs.m_it < rhs.m_it;
11282     }
11283
11284     primitive_iterator_t operator+(difference_type n) noexcept
11285     {
11286         auto result = *this;
11287         result += n;
11288         return result;
11289     }
11290
11291     friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
11292     {
11293         return lhs.m_it - rhs.m_it;
11294     }
11295
11296     primitive_iterator_t& operator++() noexcept
11297     {
11298         ++m_it;
11299         return *this;
11300     }
11301
11302     primitive_iterator_t const operator++(int) noexcept // NOLINT(readability-const-return-type)
11303     {
11304         auto result = *this;
11305         ++m_it;
11306         return result;
11307     }
11308
11309     primitive_iterator_t& operator--() noexcept
11310     {
11311         --m_it;
11312         return *this;
11313     }
11314
11315     primitive_iterator_t const operator--(int) noexcept // NOLINT(readability-const-return-type)
11316     {
11317         auto result = *this;
11318         --m_it;
11319         return result;
11320     }
11321
11322     primitive_iterator_t& operator+=(difference_type n) noexcept
11323     {
11324         m_it += n;
11325         return *this;
11326     }
11327
11328     primitive_iterator_t& operator-=(difference_type n) noexcept
11329     {
11330         m_it -= n;
11331         return *this;
11332     }
11333 };
11334 }  // namespace detail
11335 }  // namespace nlohmann
11336
11337
11338 namespace nlohmann
11339 {
11340 namespace detail
11341 {
11342 /*!
11343 @brief an iterator value
11344
11345 @note This structure could easily be a union, but MSVC currently does not allow
11346 unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
11347 */
11348 template<typename BasicJsonType> struct internal_iterator
11349 {
11350     /// iterator for JSON objects
11351     typename BasicJsonType::object_t::iterator object_iterator {};
11352     /// iterator for JSON arrays
11353     typename BasicJsonType::array_t::iterator array_iterator {};
11354     /// generic iterator for all other types
11355     primitive_iterator_t primitive_iterator {};
11356 };
11357 }  // namespace detail
11358 }  // namespace nlohmann
11359
11360 // #include <nlohmann/detail/iterators/iter_impl.hpp>
11361
11362
11363 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
11364 #include <type_traits> // conditional, is_const, remove_const
11365
11366 // #include <nlohmann/detail/exceptions.hpp>
11367
11368 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
11369
11370 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
11371
11372 // #include <nlohmann/detail/macro_scope.hpp>
11373
11374 // #include <nlohmann/detail/meta/cpp_future.hpp>
11375
11376 // #include <nlohmann/detail/meta/type_traits.hpp>
11377
11378 // #include <nlohmann/detail/value_t.hpp>
11379
11380
11381 namespace nlohmann
11382 {
11383 namespace detail
11384 {
11385 // forward declare, to be able to friend it later on
11386 template<typename IteratorType> class iteration_proxy;
11387 template<typename IteratorType> class iteration_proxy_value;
11388
11389 /*!
11390 @brief a template for a bidirectional iterator for the @ref basic_json class
11391 This class implements a both iterators (iterator and const_iterator) for the
11392 @ref basic_json class.
11393 @note An iterator is called *initialized* when a pointer to a JSON value has
11394       been set (e.g., by a constructor or a copy assignment). If the iterator is
11395       default-constructed, it is *uninitialized* and most methods are undefined.
11396       **The library uses assertions to detect calls on uninitialized iterators.**
11397 @requirement The class satisfies the following concept requirements:
11398 -
11399 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
11400   The iterator that can be moved can be moved in both directions (i.e.
11401   incremented and decremented).
11402 @since version 1.0.0, simplified in version 2.0.9, change to bidirectional
11403        iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
11404 */
11405 template<typename BasicJsonType>
11406 class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
11407 {
11408     /// the iterator with BasicJsonType of different const-ness
11409     using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
11410     /// allow basic_json to access private members
11411     friend other_iter_impl;
11412     friend BasicJsonType;
11413     friend iteration_proxy<iter_impl>;
11414     friend iteration_proxy_value<iter_impl>;
11415
11416     using object_t = typename BasicJsonType::object_t;
11417     using array_t = typename BasicJsonType::array_t;
11418     // make sure BasicJsonType is basic_json or const basic_json
11419     static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
11420                   "iter_impl only accepts (const) basic_json");
11421
11422   public:
11423
11424     /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
11425     /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
11426     /// A user-defined iterator should provide publicly accessible typedefs named
11427     /// iterator_category, value_type, difference_type, pointer, and reference.
11428     /// Note that value_type is required to be non-const, even for constant iterators.
11429     using iterator_category = std::bidirectional_iterator_tag;
11430
11431     /// the type of the values when the iterator is dereferenced
11432     using value_type = typename BasicJsonType::value_type;
11433     /// a type to represent differences between iterators
11434     using difference_type = typename BasicJsonType::difference_type;
11435     /// defines a pointer to the type iterated over (value_type)
11436     using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
11437           typename BasicJsonType::const_pointer,
11438           typename BasicJsonType::pointer>::type;
11439     /// defines a reference to the type iterated over (value_type)
11440     using reference =
11441         typename std::conditional<std::is_const<BasicJsonType>::value,
11442         typename BasicJsonType::const_reference,
11443         typename BasicJsonType::reference>::type;
11444
11445     iter_impl() = default;
11446     ~iter_impl() = default;
11447     iter_impl(iter_impl&&) noexcept = default;
11448     iter_impl& operator=(iter_impl&&) noexcept = default;
11449
11450     /*!
11451     @brief constructor for a given JSON instance
11452     @param[in] object  pointer to a JSON object for this iterator
11453     @pre object != nullptr
11454     @post The iterator is initialized; i.e. `m_object != nullptr`.
11455     */
11456     explicit iter_impl(pointer object) noexcept : m_object(object)
11457     {
11458         JSON_ASSERT(m_object != nullptr);
11459
11460         switch (m_object->m_type)
11461         {
11462             case value_t::object:
11463             {
11464                 m_it.object_iterator = typename object_t::iterator();
11465                 break;
11466             }
11467
11468             case value_t::array:
11469             {
11470                 m_it.array_iterator = typename array_t::iterator();
11471                 break;
11472             }
11473
11474             case value_t::null:
11475             case value_t::string:
11476             case value_t::boolean:
11477             case value_t::number_integer:
11478             case value_t::number_unsigned:
11479             case value_t::number_float:
11480             case value_t::binary:
11481             case value_t::discarded:
11482             default:
11483             {
11484                 m_it.primitive_iterator = primitive_iterator_t();
11485                 break;
11486             }
11487         }
11488     }
11489
11490     /*!
11491     @note The conventional copy constructor and copy assignment are implicitly
11492           defined. Combined with the following converting constructor and
11493           assignment, they support: (1) copy from iterator to iterator, (2)
11494           copy from const iterator to const iterator, and (3) conversion from
11495           iterator to const iterator. However conversion from const iterator
11496           to iterator is not defined.
11497     */
11498
11499     /*!
11500     @brief const copy constructor
11501     @param[in] other const iterator to copy from
11502     @note This copy constructor had to be defined explicitly to circumvent a bug
11503           occurring on msvc v19.0 compiler (VS 2015) debug build. For more
11504           information refer to: https://github.com/nlohmann/json/issues/1608
11505     */
11506     iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
11507         : m_object(other.m_object), m_it(other.m_it)
11508     {}
11509
11510     /*!
11511     @brief converting assignment
11512     @param[in] other const iterator to copy from
11513     @return const/non-const iterator
11514     @note It is not checked whether @a other is initialized.
11515     */
11516     iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
11517     {
11518         if (&other != this)
11519         {
11520             m_object = other.m_object;
11521             m_it = other.m_it;
11522         }
11523         return *this;
11524     }
11525
11526     /*!
11527     @brief converting constructor
11528     @param[in] other  non-const iterator to copy from
11529     @note It is not checked whether @a other is initialized.
11530     */
11531     iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
11532         : m_object(other.m_object), m_it(other.m_it)
11533     {}
11534
11535     /*!
11536     @brief converting assignment
11537     @param[in] other  non-const iterator to copy from
11538     @return const/non-const iterator
11539     @note It is not checked whether @a other is initialized.
11540     */
11541     iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
11542     {
11543         m_object = other.m_object;
11544         m_it = other.m_it;
11545         return *this;
11546     }
11547
11548   JSON_PRIVATE_UNLESS_TESTED:
11549     /*!
11550     @brief set the iterator to the first value
11551     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11552     */
11553     void set_begin() noexcept
11554     {
11555         JSON_ASSERT(m_object != nullptr);
11556
11557         switch (m_object->m_type)
11558         {
11559             case value_t::object:
11560             {
11561                 m_it.object_iterator = m_object->m_value.object->begin();
11562                 break;
11563             }
11564
11565             case value_t::array:
11566             {
11567                 m_it.array_iterator = m_object->m_value.array->begin();
11568                 break;
11569             }
11570
11571             case value_t::null:
11572             {
11573                 // set to end so begin()==end() is true: null is empty
11574                 m_it.primitive_iterator.set_end();
11575                 break;
11576             }
11577
11578             case value_t::string:
11579             case value_t::boolean:
11580             case value_t::number_integer:
11581             case value_t::number_unsigned:
11582             case value_t::number_float:
11583             case value_t::binary:
11584             case value_t::discarded:
11585             default:
11586             {
11587                 m_it.primitive_iterator.set_begin();
11588                 break;
11589             }
11590         }
11591     }
11592
11593     /*!
11594     @brief set the iterator past the last value
11595     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11596     */
11597     void set_end() noexcept
11598     {
11599         JSON_ASSERT(m_object != nullptr);
11600
11601         switch (m_object->m_type)
11602         {
11603             case value_t::object:
11604             {
11605                 m_it.object_iterator = m_object->m_value.object->end();
11606                 break;
11607             }
11608
11609             case value_t::array:
11610             {
11611                 m_it.array_iterator = m_object->m_value.array->end();
11612                 break;
11613             }
11614
11615             case value_t::null:
11616             case value_t::string:
11617             case value_t::boolean:
11618             case value_t::number_integer:
11619             case value_t::number_unsigned:
11620             case value_t::number_float:
11621             case value_t::binary:
11622             case value_t::discarded:
11623             default:
11624             {
11625                 m_it.primitive_iterator.set_end();
11626                 break;
11627             }
11628         }
11629     }
11630
11631   public:
11632     /*!
11633     @brief return a reference to the value pointed to by the iterator
11634     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11635     */
11636     reference operator*() const
11637     {
11638         JSON_ASSERT(m_object != nullptr);
11639
11640         switch (m_object->m_type)
11641         {
11642             case value_t::object:
11643             {
11644                 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11645                 return m_it.object_iterator->second;
11646             }
11647
11648             case value_t::array:
11649             {
11650                 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11651                 return *m_it.array_iterator;
11652             }
11653
11654             case value_t::null:
11655                 JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
11656
11657             case value_t::string:
11658             case value_t::boolean:
11659             case value_t::number_integer:
11660             case value_t::number_unsigned:
11661             case value_t::number_float:
11662             case value_t::binary:
11663             case value_t::discarded:
11664             default:
11665             {
11666                 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11667                 {
11668                     return *m_object;
11669                 }
11670
11671                 JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
11672             }
11673         }
11674     }
11675
11676     /*!
11677     @brief dereference the iterator
11678     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11679     */
11680     pointer operator->() const
11681     {
11682         JSON_ASSERT(m_object != nullptr);
11683
11684         switch (m_object->m_type)
11685         {
11686             case value_t::object:
11687             {
11688                 JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11689                 return &(m_it.object_iterator->second);
11690             }
11691
11692             case value_t::array:
11693             {
11694                 JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11695                 return &*m_it.array_iterator;
11696             }
11697
11698             case value_t::null:
11699             case value_t::string:
11700             case value_t::boolean:
11701             case value_t::number_integer:
11702             case value_t::number_unsigned:
11703             case value_t::number_float:
11704             case value_t::binary:
11705             case value_t::discarded:
11706             default:
11707             {
11708                 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11709                 {
11710                     return m_object;
11711                 }
11712
11713                 JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
11714             }
11715         }
11716     }
11717
11718     /*!
11719     @brief post-increment (it++)
11720     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11721     */
11722     iter_impl const operator++(int) // NOLINT(readability-const-return-type)
11723     {
11724         auto result = *this;
11725         ++(*this);
11726         return result;
11727     }
11728
11729     /*!
11730     @brief pre-increment (++it)
11731     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11732     */
11733     iter_impl& operator++()
11734     {
11735         JSON_ASSERT(m_object != nullptr);
11736
11737         switch (m_object->m_type)
11738         {
11739             case value_t::object:
11740             {
11741                 std::advance(m_it.object_iterator, 1);
11742                 break;
11743             }
11744
11745             case value_t::array:
11746             {
11747                 std::advance(m_it.array_iterator, 1);
11748                 break;
11749             }
11750
11751             case value_t::null:
11752             case value_t::string:
11753             case value_t::boolean:
11754             case value_t::number_integer:
11755             case value_t::number_unsigned:
11756             case value_t::number_float:
11757             case value_t::binary:
11758             case value_t::discarded:
11759             default:
11760             {
11761                 ++m_it.primitive_iterator;
11762                 break;
11763             }
11764         }
11765
11766         return *this;
11767     }
11768
11769     /*!
11770     @brief post-decrement (it--)
11771     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11772     */
11773     iter_impl const operator--(int) // NOLINT(readability-const-return-type)
11774     {
11775         auto result = *this;
11776         --(*this);
11777         return result;
11778     }
11779
11780     /*!
11781     @brief pre-decrement (--it)
11782     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11783     */
11784     iter_impl& operator--()
11785     {
11786         JSON_ASSERT(m_object != nullptr);
11787
11788         switch (m_object->m_type)
11789         {
11790             case value_t::object:
11791             {
11792                 std::advance(m_it.object_iterator, -1);
11793                 break;
11794             }
11795
11796             case value_t::array:
11797             {
11798                 std::advance(m_it.array_iterator, -1);
11799                 break;
11800             }
11801
11802             case value_t::null:
11803             case value_t::string:
11804             case value_t::boolean:
11805             case value_t::number_integer:
11806             case value_t::number_unsigned:
11807             case value_t::number_float:
11808             case value_t::binary:
11809             case value_t::discarded:
11810             default:
11811             {
11812                 --m_it.primitive_iterator;
11813                 break;
11814             }
11815         }
11816
11817         return *this;
11818     }
11819
11820     /*!
11821     @brief comparison: equal
11822     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11823     */
11824     template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
11825     bool operator==(const IterImpl& other) const
11826     {
11827         // if objects are not the same, the comparison is undefined
11828         if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11829         {
11830             JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
11831         }
11832
11833         JSON_ASSERT(m_object != nullptr);
11834
11835         switch (m_object->m_type)
11836         {
11837             case value_t::object:
11838                 return (m_it.object_iterator == other.m_it.object_iterator);
11839
11840             case value_t::array:
11841                 return (m_it.array_iterator == other.m_it.array_iterator);
11842
11843             case value_t::null:
11844             case value_t::string:
11845             case value_t::boolean:
11846             case value_t::number_integer:
11847             case value_t::number_unsigned:
11848             case value_t::number_float:
11849             case value_t::binary:
11850             case value_t::discarded:
11851             default:
11852                 return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11853         }
11854     }
11855
11856     /*!
11857     @brief comparison: not equal
11858     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11859     */
11860     template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
11861     bool operator!=(const IterImpl& other) const
11862     {
11863         return !operator==(other);
11864     }
11865
11866     /*!
11867     @brief comparison: smaller
11868     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11869     */
11870     bool operator<(const iter_impl& other) const
11871     {
11872         // if objects are not the same, the comparison is undefined
11873         if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11874         {
11875             JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
11876         }
11877
11878         JSON_ASSERT(m_object != nullptr);
11879
11880         switch (m_object->m_type)
11881         {
11882             case value_t::object:
11883                 JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", *m_object));
11884
11885             case value_t::array:
11886                 return (m_it.array_iterator < other.m_it.array_iterator);
11887
11888             case value_t::null:
11889             case value_t::string:
11890             case value_t::boolean:
11891             case value_t::number_integer:
11892             case value_t::number_unsigned:
11893             case value_t::number_float:
11894             case value_t::binary:
11895             case value_t::discarded:
11896             default:
11897                 return (m_it.primitive_iterator < other.m_it.primitive_iterator);
11898         }
11899     }
11900
11901     /*!
11902     @brief comparison: less than or equal
11903     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11904     */
11905     bool operator<=(const iter_impl& other) const
11906     {
11907         return !other.operator < (*this);
11908     }
11909
11910     /*!
11911     @brief comparison: greater than
11912     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11913     */
11914     bool operator>(const iter_impl& other) const
11915     {
11916         return !operator<=(other);
11917     }
11918
11919     /*!
11920     @brief comparison: greater than or equal
11921     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11922     */
11923     bool operator>=(const iter_impl& other) const
11924     {
11925         return !operator<(other);
11926     }
11927
11928     /*!
11929     @brief add to iterator
11930     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11931     */
11932     iter_impl& operator+=(difference_type i)
11933     {
11934         JSON_ASSERT(m_object != nullptr);
11935
11936         switch (m_object->m_type)
11937         {
11938             case value_t::object:
11939                 JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
11940
11941             case value_t::array:
11942             {
11943                 std::advance(m_it.array_iterator, i);
11944                 break;
11945             }
11946
11947             case value_t::null:
11948             case value_t::string:
11949             case value_t::boolean:
11950             case value_t::number_integer:
11951             case value_t::number_unsigned:
11952             case value_t::number_float:
11953             case value_t::binary:
11954             case value_t::discarded:
11955             default:
11956             {
11957                 m_it.primitive_iterator += i;
11958                 break;
11959             }
11960         }
11961
11962         return *this;
11963     }
11964
11965     /*!
11966     @brief subtract from iterator
11967     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11968     */
11969     iter_impl& operator-=(difference_type i)
11970     {
11971         return operator+=(-i);
11972     }
11973
11974     /*!
11975     @brief add to iterator
11976     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11977     */
11978     iter_impl operator+(difference_type i) const
11979     {
11980         auto result = *this;
11981         result += i;
11982         return result;
11983     }
11984
11985     /*!
11986     @brief addition of distance and iterator
11987     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11988     */
11989     friend iter_impl operator+(difference_type i, const iter_impl& it)
11990     {
11991         auto result = it;
11992         result += i;
11993         return result;
11994     }
11995
11996     /*!
11997     @brief subtract from iterator
11998     @pre The iterator is initialized; i.e. `m_object != nullptr`.
11999     */
12000     iter_impl operator-(difference_type i) const
12001     {
12002         auto result = *this;
12003         result -= i;
12004         return result;
12005     }
12006
12007     /*!
12008     @brief return difference
12009     @pre The iterator is initialized; i.e. `m_object != nullptr`.
12010     */
12011     difference_type operator-(const iter_impl& other) const
12012     {
12013         JSON_ASSERT(m_object != nullptr);
12014
12015         switch (m_object->m_type)
12016         {
12017             case value_t::object:
12018                 JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
12019
12020             case value_t::array:
12021                 return m_it.array_iterator - other.m_it.array_iterator;
12022
12023             case value_t::null:
12024             case value_t::string:
12025             case value_t::boolean:
12026             case value_t::number_integer:
12027             case value_t::number_unsigned:
12028             case value_t::number_float:
12029             case value_t::binary:
12030             case value_t::discarded:
12031             default:
12032                 return m_it.primitive_iterator - other.m_it.primitive_iterator;
12033         }
12034     }
12035
12036     /*!
12037     @brief access to successor
12038     @pre The iterator is initialized; i.e. `m_object != nullptr`.
12039     */
12040     reference operator[](difference_type n) const
12041     {
12042         JSON_ASSERT(m_object != nullptr);
12043
12044         switch (m_object->m_type)
12045         {
12046             case value_t::object:
12047                 JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", *m_object));
12048
12049             case value_t::array:
12050                 return *std::next(m_it.array_iterator, n);
12051
12052             case value_t::null:
12053                 JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
12054
12055             case value_t::string:
12056             case value_t::boolean:
12057             case value_t::number_integer:
12058             case value_t::number_unsigned:
12059             case value_t::number_float:
12060             case value_t::binary:
12061             case value_t::discarded:
12062             default:
12063             {
12064                 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
12065                 {
12066                     return *m_object;
12067                 }
12068
12069                 JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
12070             }
12071         }
12072     }
12073
12074     /*!
12075     @brief return the key of an object iterator
12076     @pre The iterator is initialized; i.e. `m_object != nullptr`.
12077     */
12078     const typename object_t::key_type& key() const
12079     {
12080         JSON_ASSERT(m_object != nullptr);
12081
12082         if (JSON_HEDLEY_LIKELY(m_object->is_object()))
12083         {
12084             return m_it.object_iterator->first;
12085         }
12086
12087         JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", *m_object));
12088     }
12089
12090     /*!
12091     @brief return the value of an iterator
12092     @pre The iterator is initialized; i.e. `m_object != nullptr`.
12093     */
12094     reference value() const
12095     {
12096         return operator*();
12097     }
12098
12099   JSON_PRIVATE_UNLESS_TESTED:
12100     /// associated JSON instance
12101     pointer m_object = nullptr;
12102     /// the actual iterator of the associated instance
12103     internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
12104 };
12105 } // namespace detail
12106 } // namespace nlohmann
12107
12108 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
12109
12110 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
12111
12112
12113 #include <cstddef> // ptrdiff_t
12114 #include <iterator> // reverse_iterator
12115 #include <utility> // declval
12116
12117 namespace nlohmann
12118 {
12119 namespace detail
12120 {
12121 //////////////////////
12122 // reverse_iterator //
12123 //////////////////////
12124
12125 /*!
12126 @brief a template for a reverse iterator class
12127
12128 @tparam Base the base iterator type to reverse. Valid types are @ref
12129 iterator (to create @ref reverse_iterator) and @ref const_iterator (to
12130 create @ref const_reverse_iterator).
12131
12132 @requirement The class satisfies the following concept requirements:
12133 -
12134 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
12135   The iterator that can be moved can be moved in both directions (i.e.
12136   incremented and decremented).
12137 - [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
12138   It is possible to write to the pointed-to element (only if @a Base is
12139   @ref iterator).
12140
12141 @since version 1.0.0
12142 */
12143 template<typename Base>
12144 class json_reverse_iterator : public std::reverse_iterator<Base>
12145 {
12146   public:
12147     using difference_type = std::ptrdiff_t;
12148     /// shortcut to the reverse iterator adapter
12149     using base_iterator = std::reverse_iterator<Base>;
12150     /// the reference type for the pointed-to element
12151     using reference = typename Base::reference;
12152
12153     /// create reverse iterator from iterator
12154     explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
12155         : base_iterator(it) {}
12156
12157     /// create reverse iterator from base class
12158     explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
12159
12160     /// post-increment (it++)
12161     json_reverse_iterator const operator++(int) // NOLINT(readability-const-return-type)
12162     {
12163         return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
12164     }
12165
12166     /// pre-increment (++it)
12167     json_reverse_iterator& operator++()
12168     {
12169         return static_cast<json_reverse_iterator&>(base_iterator::operator++());
12170     }
12171
12172     /// post-decrement (it--)
12173     json_reverse_iterator const operator--(int) // NOLINT(readability-const-return-type)
12174     {
12175         return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
12176     }
12177
12178     /// pre-decrement (--it)
12179     json_reverse_iterator& operator--()
12180     {
12181         return static_cast<json_reverse_iterator&>(base_iterator::operator--());
12182     }
12183
12184     /// add to iterator
12185     json_reverse_iterator& operator+=(difference_type i)
12186     {
12187         return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
12188     }
12189
12190     /// add to iterator
12191     json_reverse_iterator operator+(difference_type i) const
12192     {
12193         return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
12194     }
12195
12196     /// subtract from iterator
12197     json_reverse_iterator operator-(difference_type i) const
12198     {
12199         return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
12200     }
12201
12202     /// return difference
12203     difference_type operator-(const json_reverse_iterator& other) const
12204     {
12205         return base_iterator(*this) - base_iterator(other);
12206     }
12207
12208     /// access to successor
12209     reference operator[](difference_type n) const
12210     {
12211         return *(this->operator+(n));
12212     }
12213
12214     /// return the key of an object iterator
12215     auto key() const -> decltype(std::declval<Base>().key())
12216     {
12217         auto it = --this->base();
12218         return it.key();
12219     }
12220
12221     /// return the value of an iterator
12222     reference value() const
12223     {
12224         auto it = --this->base();
12225         return it.operator * ();
12226     }
12227 };
12228 }  // namespace detail
12229 }  // namespace nlohmann
12230
12231 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
12232
12233 // #include <nlohmann/detail/json_pointer.hpp>
12234
12235
12236 #include <algorithm> // all_of
12237 #include <cctype> // isdigit
12238 #include <limits> // max
12239 #include <numeric> // accumulate
12240 #include <string> // string
12241 #include <utility> // move
12242 #include <vector> // vector
12243
12244 // #include <nlohmann/detail/exceptions.hpp>
12245
12246 // #include <nlohmann/detail/macro_scope.hpp>
12247
12248 // #include <nlohmann/detail/string_escape.hpp>
12249
12250 // #include <nlohmann/detail/value_t.hpp>
12251
12252
12253 namespace nlohmann
12254 {
12255
12256 /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
12257 /// @sa https://json.nlohmann.me/api/json_pointer/
12258 template<typename BasicJsonType>
12259 class json_pointer
12260 {
12261     // allow basic_json to access private members
12262     NLOHMANN_BASIC_JSON_TPL_DECLARATION
12263     friend class basic_json;
12264
12265   public:
12266     /// @brief create JSON pointer
12267     /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
12268     explicit json_pointer(const std::string& s = "")
12269         : reference_tokens(split(s))
12270     {}
12271
12272     /// @brief return a string representation of the JSON pointer
12273     /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
12274     std::string to_string() const
12275     {
12276         return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
12277                                std::string{},
12278                                [](const std::string & a, const std::string & b)
12279         {
12280             return a + "/" + detail::escape(b);
12281         });
12282     }
12283
12284     /// @brief return a string representation of the JSON pointer
12285     /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
12286     operator std::string() const
12287     {
12288         return to_string();
12289     }
12290
12291     /// @brief append another JSON pointer at the end of this JSON pointer
12292     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
12293     json_pointer& operator/=(const json_pointer& ptr)
12294     {
12295         reference_tokens.insert(reference_tokens.end(),
12296                                 ptr.reference_tokens.begin(),
12297                                 ptr.reference_tokens.end());
12298         return *this;
12299     }
12300
12301     /// @brief append an unescaped reference token at the end of this JSON pointer
12302     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
12303     json_pointer& operator/=(std::string token)
12304     {
12305         push_back(std::move(token));
12306         return *this;
12307     }
12308
12309     /// @brief append an array index at the end of this JSON pointer
12310     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
12311     json_pointer& operator/=(std::size_t array_idx)
12312     {
12313         return *this /= std::to_string(array_idx);
12314     }
12315
12316     /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
12317     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
12318     friend json_pointer operator/(const json_pointer& lhs,
12319                                   const json_pointer& rhs)
12320     {
12321         return json_pointer(lhs) /= rhs;
12322     }
12323
12324     /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
12325     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
12326     friend json_pointer operator/(const json_pointer& lhs, std::string token) // NOLINT(performance-unnecessary-value-param)
12327     {
12328         return json_pointer(lhs) /= std::move(token);
12329     }
12330
12331     /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
12332     /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
12333     friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
12334     {
12335         return json_pointer(lhs) /= array_idx;
12336     }
12337
12338     /// @brief returns the parent of this JSON pointer
12339     /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
12340     json_pointer parent_pointer() const
12341     {
12342         if (empty())
12343         {
12344             return *this;
12345         }
12346
12347         json_pointer res = *this;
12348         res.pop_back();
12349         return res;
12350     }
12351
12352     /// @brief remove last reference token
12353     /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
12354     void pop_back()
12355     {
12356         if (JSON_HEDLEY_UNLIKELY(empty()))
12357         {
12358             JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
12359         }
12360
12361         reference_tokens.pop_back();
12362     }
12363
12364     /// @brief return last reference token
12365     /// @sa https://json.nlohmann.me/api/json_pointer/back/
12366     const std::string& back() const
12367     {
12368         if (JSON_HEDLEY_UNLIKELY(empty()))
12369         {
12370             JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
12371         }
12372
12373         return reference_tokens.back();
12374     }
12375
12376     /// @brief append an unescaped token at the end of the reference pointer
12377     /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
12378     void push_back(const std::string& token)
12379     {
12380         reference_tokens.push_back(token);
12381     }
12382
12383     /// @brief append an unescaped token at the end of the reference pointer
12384     /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
12385     void push_back(std::string&& token)
12386     {
12387         reference_tokens.push_back(std::move(token));
12388     }
12389
12390     /// @brief return whether pointer points to the root document
12391     /// @sa https://json.nlohmann.me/api/json_pointer/empty/
12392     bool empty() const noexcept
12393     {
12394         return reference_tokens.empty();
12395     }
12396
12397   private:
12398     /*!
12399     @param[in] s  reference token to be converted into an array index
12400
12401     @return integer representation of @a s
12402
12403     @throw parse_error.106  if an array index begins with '0'
12404     @throw parse_error.109  if an array index begins not with a digit
12405     @throw out_of_range.404 if string @a s could not be converted to an integer
12406     @throw out_of_range.410 if an array index exceeds size_type
12407     */
12408     static typename BasicJsonType::size_type array_index(const std::string& s)
12409     {
12410         using size_type = typename BasicJsonType::size_type;
12411
12412         // error condition (cf. RFC 6901, Sect. 4)
12413         if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
12414         {
12415             JSON_THROW(detail::parse_error::create(106, 0, "array index '" + s + "' must not begin with '0'", BasicJsonType()));
12416         }
12417
12418         // error condition (cf. RFC 6901, Sect. 4)
12419         if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
12420         {
12421             JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number", BasicJsonType()));
12422         }
12423
12424         std::size_t processed_chars = 0;
12425         unsigned long long res = 0;  // NOLINT(runtime/int)
12426         JSON_TRY
12427         {
12428             res = std::stoull(s, &processed_chars);
12429         }
12430         JSON_CATCH(std::out_of_range&)
12431         {
12432             JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
12433         }
12434
12435         // check if the string was completely read
12436         if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
12437         {
12438             JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
12439         }
12440
12441         // only triggered on special platforms (like 32bit), see also
12442         // https://github.com/nlohmann/json/pull/2203
12443         if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
12444         {
12445             JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type", BasicJsonType())); // LCOV_EXCL_LINE
12446         }
12447
12448         return static_cast<size_type>(res);
12449     }
12450
12451   JSON_PRIVATE_UNLESS_TESTED:
12452     json_pointer top() const
12453     {
12454         if (JSON_HEDLEY_UNLIKELY(empty()))
12455         {
12456             JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
12457         }
12458
12459         json_pointer result = *this;
12460         result.reference_tokens = {reference_tokens[0]};
12461         return result;
12462     }
12463
12464   private:
12465     /*!
12466     @brief create and return a reference to the pointed to value
12467
12468     @complexity Linear in the number of reference tokens.
12469
12470     @throw parse_error.109 if array index is not a number
12471     @throw type_error.313 if value cannot be unflattened
12472     */
12473     BasicJsonType& get_and_create(BasicJsonType& j) const
12474     {
12475         auto* result = &j;
12476
12477         // in case no reference tokens exist, return a reference to the JSON value
12478         // j which will be overwritten by a primitive value
12479         for (const auto& reference_token : reference_tokens)
12480         {
12481             switch (result->type())
12482             {
12483                 case detail::value_t::null:
12484                 {
12485                     if (reference_token == "0")
12486                     {
12487                         // start a new array if reference token is 0
12488                         result = &result->operator[](0);
12489                     }
12490                     else
12491                     {
12492                         // start a new object otherwise
12493                         result = &result->operator[](reference_token);
12494                     }
12495                     break;
12496                 }
12497
12498                 case detail::value_t::object:
12499                 {
12500                     // create an entry in the object
12501                     result = &result->operator[](reference_token);
12502                     break;
12503                 }
12504
12505                 case detail::value_t::array:
12506                 {
12507                     // create an entry in the array
12508                     result = &result->operator[](array_index(reference_token));
12509                     break;
12510                 }
12511
12512                 /*
12513                 The following code is only reached if there exists a reference
12514                 token _and_ the current value is primitive. In this case, we have
12515                 an error situation, because primitive values may only occur as
12516                 single value; that is, with an empty list of reference tokens.
12517                 */
12518                 case detail::value_t::string:
12519                 case detail::value_t::boolean:
12520                 case detail::value_t::number_integer:
12521                 case detail::value_t::number_unsigned:
12522                 case detail::value_t::number_float:
12523                 case detail::value_t::binary:
12524                 case detail::value_t::discarded:
12525                 default:
12526                     JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", j));
12527             }
12528         }
12529
12530         return *result;
12531     }
12532
12533     /*!
12534     @brief return a reference to the pointed to value
12535
12536     @note This version does not throw if a value is not present, but tries to
12537           create nested values instead. For instance, calling this function
12538           with pointer `"/this/that"` on a null value is equivalent to calling
12539           `operator[]("this").operator[]("that")` on that value, effectively
12540           changing the null value to an object.
12541
12542     @param[in] ptr  a JSON value
12543
12544     @return reference to the JSON value pointed to by the JSON pointer
12545
12546     @complexity Linear in the length of the JSON pointer.
12547
12548     @throw parse_error.106   if an array index begins with '0'
12549     @throw parse_error.109   if an array index was not a number
12550     @throw out_of_range.404  if the JSON pointer can not be resolved
12551     */
12552     BasicJsonType& get_unchecked(BasicJsonType* ptr) const
12553     {
12554         for (const auto& reference_token : reference_tokens)
12555         {
12556             // convert null values to arrays or objects before continuing
12557             if (ptr->is_null())
12558             {
12559                 // check if reference token is a number
12560                 const bool nums =
12561                     std::all_of(reference_token.begin(), reference_token.end(),
12562                                 [](const unsigned char x)
12563                 {
12564                     return std::isdigit(x);
12565                 });
12566
12567                 // change value to array for numbers or "-" or to object otherwise
12568                 *ptr = (nums || reference_token == "-")
12569                        ? detail::value_t::array
12570                        : detail::value_t::object;
12571             }
12572
12573             switch (ptr->type())
12574             {
12575                 case detail::value_t::object:
12576                 {
12577                     // use unchecked object access
12578                     ptr = &ptr->operator[](reference_token);
12579                     break;
12580                 }
12581
12582                 case detail::value_t::array:
12583                 {
12584                     if (reference_token == "-")
12585                     {
12586                         // explicitly treat "-" as index beyond the end
12587                         ptr = &ptr->operator[](ptr->m_value.array->size());
12588                     }
12589                     else
12590                     {
12591                         // convert array index to number; unchecked access
12592                         ptr = &ptr->operator[](array_index(reference_token));
12593                     }
12594                     break;
12595                 }
12596
12597                 case detail::value_t::null:
12598                 case detail::value_t::string:
12599                 case detail::value_t::boolean:
12600                 case detail::value_t::number_integer:
12601                 case detail::value_t::number_unsigned:
12602                 case detail::value_t::number_float:
12603                 case detail::value_t::binary:
12604                 case detail::value_t::discarded:
12605                 default:
12606                     JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12607             }
12608         }
12609
12610         return *ptr;
12611     }
12612
12613     /*!
12614     @throw parse_error.106   if an array index begins with '0'
12615     @throw parse_error.109   if an array index was not a number
12616     @throw out_of_range.402  if the array index '-' is used
12617     @throw out_of_range.404  if the JSON pointer can not be resolved
12618     */
12619     BasicJsonType& get_checked(BasicJsonType* ptr) const
12620     {
12621         for (const auto& reference_token : reference_tokens)
12622         {
12623             switch (ptr->type())
12624             {
12625                 case detail::value_t::object:
12626                 {
12627                     // note: at performs range check
12628                     ptr = &ptr->at(reference_token);
12629                     break;
12630                 }
12631
12632                 case detail::value_t::array:
12633                 {
12634                     if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12635                     {
12636                         // "-" always fails the range check
12637                         JSON_THROW(detail::out_of_range::create(402,
12638                                                                 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12639                                                                 ") is out of range", *ptr));
12640                     }
12641
12642                     // note: at performs range check
12643                     ptr = &ptr->at(array_index(reference_token));
12644                     break;
12645                 }
12646
12647                 case detail::value_t::null:
12648                 case detail::value_t::string:
12649                 case detail::value_t::boolean:
12650                 case detail::value_t::number_integer:
12651                 case detail::value_t::number_unsigned:
12652                 case detail::value_t::number_float:
12653                 case detail::value_t::binary:
12654                 case detail::value_t::discarded:
12655                 default:
12656                     JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12657             }
12658         }
12659
12660         return *ptr;
12661     }
12662
12663     /*!
12664     @brief return a const reference to the pointed to value
12665
12666     @param[in] ptr  a JSON value
12667
12668     @return const reference to the JSON value pointed to by the JSON
12669     pointer
12670
12671     @throw parse_error.106   if an array index begins with '0'
12672     @throw parse_error.109   if an array index was not a number
12673     @throw out_of_range.402  if the array index '-' is used
12674     @throw out_of_range.404  if the JSON pointer can not be resolved
12675     */
12676     const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
12677     {
12678         for (const auto& reference_token : reference_tokens)
12679         {
12680             switch (ptr->type())
12681             {
12682                 case detail::value_t::object:
12683                 {
12684                     // use unchecked object access
12685                     ptr = &ptr->operator[](reference_token);
12686                     break;
12687                 }
12688
12689                 case detail::value_t::array:
12690                 {
12691                     if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12692                     {
12693                         // "-" cannot be used for const access
12694                         JSON_THROW(detail::out_of_range::create(402, "array index '-' (" + std::to_string(ptr->m_value.array->size()) + ") is out of range", *ptr));
12695                     }
12696
12697                     // use unchecked array access
12698                     ptr = &ptr->operator[](array_index(reference_token));
12699                     break;
12700                 }
12701
12702                 case detail::value_t::null:
12703                 case detail::value_t::string:
12704                 case detail::value_t::boolean:
12705                 case detail::value_t::number_integer:
12706                 case detail::value_t::number_unsigned:
12707                 case detail::value_t::number_float:
12708                 case detail::value_t::binary:
12709                 case detail::value_t::discarded:
12710                 default:
12711                     JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12712             }
12713         }
12714
12715         return *ptr;
12716     }
12717
12718     /*!
12719     @throw parse_error.106   if an array index begins with '0'
12720     @throw parse_error.109   if an array index was not a number
12721     @throw out_of_range.402  if the array index '-' is used
12722     @throw out_of_range.404  if the JSON pointer can not be resolved
12723     */
12724     const BasicJsonType& get_checked(const BasicJsonType* ptr) const
12725     {
12726         for (const auto& reference_token : reference_tokens)
12727         {
12728             switch (ptr->type())
12729             {
12730                 case detail::value_t::object:
12731                 {
12732                     // note: at performs range check
12733                     ptr = &ptr->at(reference_token);
12734                     break;
12735                 }
12736
12737                 case detail::value_t::array:
12738                 {
12739                     if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12740                     {
12741                         // "-" always fails the range check
12742                         JSON_THROW(detail::out_of_range::create(402,
12743                                                                 "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12744                                                                 ") is out of range", *ptr));
12745                     }
12746
12747                     // note: at performs range check
12748                     ptr = &ptr->at(array_index(reference_token));
12749                     break;
12750                 }
12751
12752                 case detail::value_t::null:
12753                 case detail::value_t::string:
12754                 case detail::value_t::boolean:
12755                 case detail::value_t::number_integer:
12756                 case detail::value_t::number_unsigned:
12757                 case detail::value_t::number_float:
12758                 case detail::value_t::binary:
12759                 case detail::value_t::discarded:
12760                 default:
12761                     JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
12762             }
12763         }
12764
12765         return *ptr;
12766     }
12767
12768     /*!
12769     @throw parse_error.106   if an array index begins with '0'
12770     @throw parse_error.109   if an array index was not a number
12771     */
12772     bool contains(const BasicJsonType* ptr) const
12773     {
12774         for (const auto& reference_token : reference_tokens)
12775         {
12776             switch (ptr->type())
12777             {
12778                 case detail::value_t::object:
12779                 {
12780                     if (!ptr->contains(reference_token))
12781                     {
12782                         // we did not find the key in the object
12783                         return false;
12784                     }
12785
12786                     ptr = &ptr->operator[](reference_token);
12787                     break;
12788                 }
12789
12790                 case detail::value_t::array:
12791                 {
12792                     if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12793                     {
12794                         // "-" always fails the range check
12795                         return false;
12796                     }
12797                     if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
12798                     {
12799                         // invalid char
12800                         return false;
12801                     }
12802                     if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
12803                     {
12804                         if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
12805                         {
12806                             // first char should be between '1' and '9'
12807                             return false;
12808                         }
12809                         for (std::size_t i = 1; i < reference_token.size(); i++)
12810                         {
12811                             if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
12812                             {
12813                                 // other char should be between '0' and '9'
12814                                 return false;
12815                             }
12816                         }
12817                     }
12818
12819                     const auto idx = array_index(reference_token);
12820                     if (idx >= ptr->size())
12821                     {
12822                         // index out of range
12823                         return false;
12824                     }
12825
12826                     ptr = &ptr->operator[](idx);
12827                     break;
12828                 }
12829
12830                 case detail::value_t::null:
12831                 case detail::value_t::string:
12832                 case detail::value_t::boolean:
12833                 case detail::value_t::number_integer:
12834                 case detail::value_t::number_unsigned:
12835                 case detail::value_t::number_float:
12836                 case detail::value_t::binary:
12837                 case detail::value_t::discarded:
12838                 default:
12839                 {
12840                     // we do not expect primitive values if there is still a
12841                     // reference token to process
12842                     return false;
12843                 }
12844             }
12845         }
12846
12847         // no reference token left means we found a primitive value
12848         return true;
12849     }
12850
12851     /*!
12852     @brief split the string input to reference tokens
12853
12854     @note This function is only called by the json_pointer constructor.
12855           All exceptions below are documented there.
12856
12857     @throw parse_error.107  if the pointer is not empty or begins with '/'
12858     @throw parse_error.108  if character '~' is not followed by '0' or '1'
12859     */
12860     static std::vector<std::string> split(const std::string& reference_string)
12861     {
12862         std::vector<std::string> result;
12863
12864         // special case: empty reference string -> no reference tokens
12865         if (reference_string.empty())
12866         {
12867             return result;
12868         }
12869
12870         // check if nonempty reference string begins with slash
12871         if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
12872         {
12873             JSON_THROW(detail::parse_error::create(107, 1, "JSON pointer must be empty or begin with '/' - was: '" + reference_string + "'", BasicJsonType()));
12874         }
12875
12876         // extract the reference tokens:
12877         // - slash: position of the last read slash (or end of string)
12878         // - start: position after the previous slash
12879         for (
12880             // search for the first slash after the first character
12881             std::size_t slash = reference_string.find_first_of('/', 1),
12882             // set the beginning of the first reference token
12883             start = 1;
12884             // we can stop if start == 0 (if slash == std::string::npos)
12885             start != 0;
12886             // set the beginning of the next reference token
12887             // (will eventually be 0 if slash == std::string::npos)
12888             start = (slash == std::string::npos) ? 0 : slash + 1,
12889             // find next slash
12890             slash = reference_string.find_first_of('/', start))
12891         {
12892             // use the text between the beginning of the reference token
12893             // (start) and the last slash (slash).
12894             auto reference_token = reference_string.substr(start, slash - start);
12895
12896             // check reference tokens are properly escaped
12897             for (std::size_t pos = reference_token.find_first_of('~');
12898                     pos != std::string::npos;
12899                     pos = reference_token.find_first_of('~', pos + 1))
12900             {
12901                 JSON_ASSERT(reference_token[pos] == '~');
12902
12903                 // ~ must be followed by 0 or 1
12904                 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
12905                                          (reference_token[pos + 1] != '0' &&
12906                                           reference_token[pos + 1] != '1')))
12907                 {
12908                     JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", BasicJsonType()));
12909                 }
12910             }
12911
12912             // finally, store the reference token
12913             detail::unescape(reference_token);
12914             result.push_back(reference_token);
12915         }
12916
12917         return result;
12918     }
12919
12920   private:
12921     /*!
12922     @param[in] reference_string  the reference string to the current value
12923     @param[in] value             the value to consider
12924     @param[in,out] result        the result object to insert values to
12925
12926     @note Empty objects or arrays are flattened to `null`.
12927     */
12928     static void flatten(const std::string& reference_string,
12929                         const BasicJsonType& value,
12930                         BasicJsonType& result)
12931     {
12932         switch (value.type())
12933         {
12934             case detail::value_t::array:
12935             {
12936                 if (value.m_value.array->empty())
12937                 {
12938                     // flatten empty array as null
12939                     result[reference_string] = nullptr;
12940                 }
12941                 else
12942                 {
12943                     // iterate array and use index as reference string
12944                     for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
12945                     {
12946                         flatten(reference_string + "/" + std::to_string(i),
12947                                 value.m_value.array->operator[](i), result);
12948                     }
12949                 }
12950                 break;
12951             }
12952
12953             case detail::value_t::object:
12954             {
12955                 if (value.m_value.object->empty())
12956                 {
12957                     // flatten empty object as null
12958                     result[reference_string] = nullptr;
12959                 }
12960                 else
12961                 {
12962                     // iterate object and use keys as reference string
12963                     for (const auto& element : *value.m_value.object)
12964                     {
12965                         flatten(reference_string + "/" + detail::escape(element.first), element.second, result);
12966                     }
12967                 }
12968                 break;
12969             }
12970
12971             case detail::value_t::null:
12972             case detail::value_t::string:
12973             case detail::value_t::boolean:
12974             case detail::value_t::number_integer:
12975             case detail::value_t::number_unsigned:
12976             case detail::value_t::number_float:
12977             case detail::value_t::binary:
12978             case detail::value_t::discarded:
12979             default:
12980             {
12981                 // add primitive value with its reference string
12982                 result[reference_string] = value;
12983                 break;
12984             }
12985         }
12986     }
12987
12988     /*!
12989     @param[in] value  flattened JSON
12990
12991     @return unflattened JSON
12992
12993     @throw parse_error.109 if array index is not a number
12994     @throw type_error.314  if value is not an object
12995     @throw type_error.315  if object values are not primitive
12996     @throw type_error.313  if value cannot be unflattened
12997     */
12998     static BasicJsonType
12999     unflatten(const BasicJsonType& value)
13000     {
13001         if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
13002         {
13003             JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", value));
13004         }
13005
13006         BasicJsonType result;
13007
13008         // iterate the JSON object values
13009         for (const auto& element : *value.m_value.object)
13010         {
13011             if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
13012             {
13013                 JSON_THROW(detail::type_error::create(315, "values in object must be primitive", element.second));
13014             }
13015
13016             // assign value to reference pointed to by JSON pointer; Note that if
13017             // the JSON pointer is "" (i.e., points to the whole value), function
13018             // get_and_create returns a reference to result itself. An assignment
13019             // will then create a primitive value.
13020             json_pointer(element.first).get_and_create(result) = element.second;
13021         }
13022
13023         return result;
13024     }
13025
13026     /*!
13027     @brief compares two JSON pointers for equality
13028
13029     @param[in] lhs  JSON pointer to compare
13030     @param[in] rhs  JSON pointer to compare
13031     @return whether @a lhs is equal to @a rhs
13032
13033     @complexity Linear in the length of the JSON pointer
13034
13035     @exceptionsafety No-throw guarantee: this function never throws exceptions.
13036     */
13037     friend bool operator==(json_pointer const& lhs,
13038                            json_pointer const& rhs) noexcept
13039     {
13040         return lhs.reference_tokens == rhs.reference_tokens;
13041     }
13042
13043     /*!
13044     @brief compares two JSON pointers for inequality
13045
13046     @param[in] lhs  JSON pointer to compare
13047     @param[in] rhs  JSON pointer to compare
13048     @return whether @a lhs is not equal @a rhs
13049
13050     @complexity Linear in the length of the JSON pointer
13051
13052     @exceptionsafety No-throw guarantee: this function never throws exceptions.
13053     */
13054     friend bool operator!=(json_pointer const& lhs,
13055                            json_pointer const& rhs) noexcept
13056     {
13057         return !(lhs == rhs);
13058     }
13059
13060     /// the reference tokens
13061     std::vector<std::string> reference_tokens;
13062 };
13063 }  // namespace nlohmann
13064
13065 // #include <nlohmann/detail/json_ref.hpp>
13066
13067
13068 #include <initializer_list>
13069 #include <utility>
13070
13071 // #include <nlohmann/detail/meta/type_traits.hpp>
13072
13073
13074 namespace nlohmann
13075 {
13076 namespace detail
13077 {
13078 template<typename BasicJsonType>
13079 class json_ref
13080 {
13081   public:
13082     using value_type = BasicJsonType;
13083
13084     json_ref(value_type&& value)
13085         : owned_value(std::move(value))
13086     {}
13087
13088     json_ref(const value_type& value)
13089         : value_ref(&value)
13090     {}
13091
13092     json_ref(std::initializer_list<json_ref> init)
13093         : owned_value(init)
13094     {}
13095
13096     template <
13097         class... Args,
13098         enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
13099     json_ref(Args && ... args)
13100         : owned_value(std::forward<Args>(args)...)
13101     {}
13102
13103     // class should be movable only
13104     json_ref(json_ref&&) noexcept = default;
13105     json_ref(const json_ref&) = delete;
13106     json_ref& operator=(const json_ref&) = delete;
13107     json_ref& operator=(json_ref&&) = delete;
13108     ~json_ref() = default;
13109
13110     value_type moved_or_copied() const
13111     {
13112         if (value_ref == nullptr)
13113         {
13114             return std::move(owned_value);
13115         }
13116         return *value_ref;
13117     }
13118
13119     value_type const& operator*() const
13120     {
13121         return value_ref ? *value_ref : owned_value;
13122     }
13123
13124     value_type const* operator->() const
13125     {
13126         return &** this;
13127     }
13128
13129   private:
13130     mutable value_type owned_value = nullptr;
13131     value_type const* value_ref = nullptr;
13132 };
13133 }  // namespace detail
13134 }  // namespace nlohmann
13135
13136 // #include <nlohmann/detail/macro_scope.hpp>
13137
13138 // #include <nlohmann/detail/string_escape.hpp>
13139
13140 // #include <nlohmann/detail/meta/cpp_future.hpp>
13141
13142 // #include <nlohmann/detail/meta/type_traits.hpp>
13143
13144 // #include <nlohmann/detail/output/binary_writer.hpp>
13145
13146
13147 #include <algorithm> // reverse
13148 #include <array> // array
13149 #include <cmath> // isnan, isinf
13150 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
13151 #include <cstring> // memcpy
13152 #include <limits> // numeric_limits
13153 #include <string> // string
13154 #include <utility> // move
13155
13156 // #include <nlohmann/detail/input/binary_reader.hpp>
13157
13158 // #include <nlohmann/detail/macro_scope.hpp>
13159
13160 // #include <nlohmann/detail/output/output_adapters.hpp>
13161
13162
13163 #include <algorithm> // copy
13164 #include <cstddef> // size_t
13165 #include <iterator> // back_inserter
13166 #include <memory> // shared_ptr, make_shared
13167 #include <string> // basic_string
13168 #include <vector> // vector
13169
13170 #ifndef JSON_NO_IO
13171     #include <ios>      // streamsize
13172     #include <ostream>  // basic_ostream
13173 #endif  // JSON_NO_IO
13174
13175 // #include <nlohmann/detail/macro_scope.hpp>
13176
13177
13178 namespace nlohmann
13179 {
13180 namespace detail
13181 {
13182 /// abstract output adapter interface
13183 template<typename CharType> struct output_adapter_protocol
13184 {
13185     virtual void write_character(CharType c) = 0;
13186     virtual void write_characters(const CharType* s, std::size_t length) = 0;
13187     virtual ~output_adapter_protocol() = default;
13188
13189     output_adapter_protocol() = default;
13190     output_adapter_protocol(const output_adapter_protocol&) = default;
13191     output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
13192     output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
13193     output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
13194 };
13195
13196 /// a type to simplify interfaces
13197 template<typename CharType>
13198 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
13199
13200 /// output adapter for byte vectors
13201 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
13202 class output_vector_adapter : public output_adapter_protocol<CharType>
13203 {
13204   public:
13205     explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
13206         : v(vec)
13207     {}
13208
13209     void write_character(CharType c) override
13210     {
13211         v.push_back(c);
13212     }
13213
13214     JSON_HEDLEY_NON_NULL(2)
13215     void write_characters(const CharType* s, std::size_t length) override
13216     {
13217         std::copy(s, s + length, std::back_inserter(v));
13218     }
13219
13220   private:
13221     std::vector<CharType, AllocatorType>& v;
13222 };
13223
13224 #ifndef JSON_NO_IO
13225 /// output adapter for output streams
13226 template<typename CharType>
13227 class output_stream_adapter : public output_adapter_protocol<CharType>
13228 {
13229   public:
13230     explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
13231         : stream(s)
13232     {}
13233
13234     void write_character(CharType c) override
13235     {
13236         stream.put(c);
13237     }
13238
13239     JSON_HEDLEY_NON_NULL(2)
13240     void write_characters(const CharType* s, std::size_t length) override
13241     {
13242         stream.write(s, static_cast<std::streamsize>(length));
13243     }
13244
13245   private:
13246     std::basic_ostream<CharType>& stream;
13247 };
13248 #endif  // JSON_NO_IO
13249
13250 /// output adapter for basic_string
13251 template<typename CharType, typename StringType = std::basic_string<CharType>>
13252 class output_string_adapter : public output_adapter_protocol<CharType>
13253 {
13254   public:
13255     explicit output_string_adapter(StringType& s) noexcept
13256         : str(s)
13257     {}
13258
13259     void write_character(CharType c) override
13260     {
13261         str.push_back(c);
13262     }
13263
13264     JSON_HEDLEY_NON_NULL(2)
13265     void write_characters(const CharType* s, std::size_t length) override
13266     {
13267         str.append(s, length);
13268     }
13269
13270   private:
13271     StringType& str;
13272 };
13273
13274 template<typename CharType, typename StringType = std::basic_string<CharType>>
13275 class output_adapter
13276 {
13277   public:
13278     template<typename AllocatorType = std::allocator<CharType>>
13279     output_adapter(std::vector<CharType, AllocatorType>& vec)
13280         : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
13281
13282 #ifndef JSON_NO_IO
13283     output_adapter(std::basic_ostream<CharType>& s)
13284         : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
13285 #endif  // JSON_NO_IO
13286
13287     output_adapter(StringType& s)
13288         : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
13289
13290     operator output_adapter_t<CharType>()
13291     {
13292         return oa;
13293     }
13294
13295   private:
13296     output_adapter_t<CharType> oa = nullptr;
13297 };
13298 }  // namespace detail
13299 }  // namespace nlohmann
13300
13301
13302 namespace nlohmann
13303 {
13304 namespace detail
13305 {
13306 ///////////////////
13307 // binary writer //
13308 ///////////////////
13309
13310 /*!
13311 @brief serialization to CBOR and MessagePack values
13312 */
13313 template<typename BasicJsonType, typename CharType>
13314 class binary_writer
13315 {
13316     using string_t = typename BasicJsonType::string_t;
13317     using binary_t = typename BasicJsonType::binary_t;
13318     using number_float_t = typename BasicJsonType::number_float_t;
13319
13320   public:
13321     /*!
13322     @brief create a binary writer
13323
13324     @param[in] adapter  output adapter to write to
13325     */
13326     explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
13327     {
13328         JSON_ASSERT(oa);
13329     }
13330
13331     /*!
13332     @param[in] j  JSON value to serialize
13333     @pre       j.type() == value_t::object
13334     */
13335     void write_bson(const BasicJsonType& j)
13336     {
13337         switch (j.type())
13338         {
13339             case value_t::object:
13340             {
13341                 write_bson_object(*j.m_value.object);
13342                 break;
13343             }
13344
13345             case value_t::null:
13346             case value_t::array:
13347             case value_t::string:
13348             case value_t::boolean:
13349             case value_t::number_integer:
13350             case value_t::number_unsigned:
13351             case value_t::number_float:
13352             case value_t::binary:
13353             case value_t::discarded:
13354             default:
13355             {
13356                 JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));
13357             }
13358         }
13359     }
13360
13361     /*!
13362     @param[in] j  JSON value to serialize
13363     */
13364     void write_cbor(const BasicJsonType& j)
13365     {
13366         switch (j.type())
13367         {
13368             case value_t::null:
13369             {
13370                 oa->write_character(to_char_type(0xF6));
13371                 break;
13372             }
13373
13374             case value_t::boolean:
13375             {
13376                 oa->write_character(j.m_value.boolean
13377                                     ? to_char_type(0xF5)
13378                                     : to_char_type(0xF4));
13379                 break;
13380             }
13381
13382             case value_t::number_integer:
13383             {
13384                 if (j.m_value.number_integer >= 0)
13385                 {
13386                     // CBOR does not differentiate between positive signed
13387                     // integers and unsigned integers. Therefore, we used the
13388                     // code from the value_t::number_unsigned case here.
13389                     if (j.m_value.number_integer <= 0x17)
13390                     {
13391                         write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13392                     }
13393                     else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
13394                     {
13395                         oa->write_character(to_char_type(0x18));
13396                         write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13397                     }
13398                     else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
13399                     {
13400                         oa->write_character(to_char_type(0x19));
13401                         write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13402                     }
13403                     else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
13404                     {
13405                         oa->write_character(to_char_type(0x1A));
13406                         write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13407                     }
13408                     else
13409                     {
13410                         oa->write_character(to_char_type(0x1B));
13411                         write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13412                     }
13413                 }
13414                 else
13415                 {
13416                     // The conversions below encode the sign in the first
13417                     // byte, and the value is converted to a positive number.
13418                     const auto positive_number = -1 - j.m_value.number_integer;
13419                     if (j.m_value.number_integer >= -24)
13420                     {
13421                         write_number(static_cast<std::uint8_t>(0x20 + positive_number));
13422                     }
13423                     else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
13424                     {
13425                         oa->write_character(to_char_type(0x38));
13426                         write_number(static_cast<std::uint8_t>(positive_number));
13427                     }
13428                     else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
13429                     {
13430                         oa->write_character(to_char_type(0x39));
13431                         write_number(static_cast<std::uint16_t>(positive_number));
13432                     }
13433                     else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
13434                     {
13435                         oa->write_character(to_char_type(0x3A));
13436                         write_number(static_cast<std::uint32_t>(positive_number));
13437                     }
13438                     else
13439                     {
13440                         oa->write_character(to_char_type(0x3B));
13441                         write_number(static_cast<std::uint64_t>(positive_number));
13442                     }
13443                 }
13444                 break;
13445             }
13446
13447             case value_t::number_unsigned:
13448             {
13449                 if (j.m_value.number_unsigned <= 0x17)
13450                 {
13451                     write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
13452                 }
13453                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13454                 {
13455                     oa->write_character(to_char_type(0x18));
13456                     write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
13457                 }
13458                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13459                 {
13460                     oa->write_character(to_char_type(0x19));
13461                     write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
13462                 }
13463                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13464                 {
13465                     oa->write_character(to_char_type(0x1A));
13466                     write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
13467                 }
13468                 else
13469                 {
13470                     oa->write_character(to_char_type(0x1B));
13471                     write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
13472                 }
13473                 break;
13474             }
13475
13476             case value_t::number_float:
13477             {
13478                 if (std::isnan(j.m_value.number_float))
13479                 {
13480                     // NaN is 0xf97e00 in CBOR
13481                     oa->write_character(to_char_type(0xF9));
13482                     oa->write_character(to_char_type(0x7E));
13483                     oa->write_character(to_char_type(0x00));
13484                 }
13485                 else if (std::isinf(j.m_value.number_float))
13486                 {
13487                     // Infinity is 0xf97c00, -Infinity is 0xf9fc00
13488                     oa->write_character(to_char_type(0xf9));
13489                     oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
13490                     oa->write_character(to_char_type(0x00));
13491                 }
13492                 else
13493                 {
13494                     write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
13495                 }
13496                 break;
13497             }
13498
13499             case value_t::string:
13500             {
13501                 // step 1: write control byte and the string length
13502                 const auto N = j.m_value.string->size();
13503                 if (N <= 0x17)
13504                 {
13505                     write_number(static_cast<std::uint8_t>(0x60 + N));
13506                 }
13507                 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13508                 {
13509                     oa->write_character(to_char_type(0x78));
13510                     write_number(static_cast<std::uint8_t>(N));
13511                 }
13512                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13513                 {
13514                     oa->write_character(to_char_type(0x79));
13515                     write_number(static_cast<std::uint16_t>(N));
13516                 }
13517                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13518                 {
13519                     oa->write_character(to_char_type(0x7A));
13520                     write_number(static_cast<std::uint32_t>(N));
13521                 }
13522                 // LCOV_EXCL_START
13523                 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13524                 {
13525                     oa->write_character(to_char_type(0x7B));
13526                     write_number(static_cast<std::uint64_t>(N));
13527                 }
13528                 // LCOV_EXCL_STOP
13529
13530                 // step 2: write the string
13531                 oa->write_characters(
13532                     reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13533                     j.m_value.string->size());
13534                 break;
13535             }
13536
13537             case value_t::array:
13538             {
13539                 // step 1: write control byte and the array size
13540                 const auto N = j.m_value.array->size();
13541                 if (N <= 0x17)
13542                 {
13543                     write_number(static_cast<std::uint8_t>(0x80 + N));
13544                 }
13545                 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13546                 {
13547                     oa->write_character(to_char_type(0x98));
13548                     write_number(static_cast<std::uint8_t>(N));
13549                 }
13550                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13551                 {
13552                     oa->write_character(to_char_type(0x99));
13553                     write_number(static_cast<std::uint16_t>(N));
13554                 }
13555                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13556                 {
13557                     oa->write_character(to_char_type(0x9A));
13558                     write_number(static_cast<std::uint32_t>(N));
13559                 }
13560                 // LCOV_EXCL_START
13561                 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13562                 {
13563                     oa->write_character(to_char_type(0x9B));
13564                     write_number(static_cast<std::uint64_t>(N));
13565                 }
13566                 // LCOV_EXCL_STOP
13567
13568                 // step 2: write each element
13569                 for (const auto& el : *j.m_value.array)
13570                 {
13571                     write_cbor(el);
13572                 }
13573                 break;
13574             }
13575
13576             case value_t::binary:
13577             {
13578                 if (j.m_value.binary->has_subtype())
13579                 {
13580                     if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
13581                     {
13582                         write_number(static_cast<std::uint8_t>(0xd8));
13583                         write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
13584                     }
13585                     else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
13586                     {
13587                         write_number(static_cast<std::uint8_t>(0xd9));
13588                         write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
13589                     }
13590                     else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
13591                     {
13592                         write_number(static_cast<std::uint8_t>(0xda));
13593                         write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
13594                     }
13595                     else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
13596                     {
13597                         write_number(static_cast<std::uint8_t>(0xdb));
13598                         write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
13599                     }
13600                 }
13601
13602                 // step 1: write control byte and the binary array size
13603                 const auto N = j.m_value.binary->size();
13604                 if (N <= 0x17)
13605                 {
13606                     write_number(static_cast<std::uint8_t>(0x40 + N));
13607                 }
13608                 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13609                 {
13610                     oa->write_character(to_char_type(0x58));
13611                     write_number(static_cast<std::uint8_t>(N));
13612                 }
13613                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13614                 {
13615                     oa->write_character(to_char_type(0x59));
13616                     write_number(static_cast<std::uint16_t>(N));
13617                 }
13618                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13619                 {
13620                     oa->write_character(to_char_type(0x5A));
13621                     write_number(static_cast<std::uint32_t>(N));
13622                 }
13623                 // LCOV_EXCL_START
13624                 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13625                 {
13626                     oa->write_character(to_char_type(0x5B));
13627                     write_number(static_cast<std::uint64_t>(N));
13628                 }
13629                 // LCOV_EXCL_STOP
13630
13631                 // step 2: write each element
13632                 oa->write_characters(
13633                     reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13634                     N);
13635
13636                 break;
13637             }
13638
13639             case value_t::object:
13640             {
13641                 // step 1: write control byte and the object size
13642                 const auto N = j.m_value.object->size();
13643                 if (N <= 0x17)
13644                 {
13645                     write_number(static_cast<std::uint8_t>(0xA0 + N));
13646                 }
13647                 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13648                 {
13649                     oa->write_character(to_char_type(0xB8));
13650                     write_number(static_cast<std::uint8_t>(N));
13651                 }
13652                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13653                 {
13654                     oa->write_character(to_char_type(0xB9));
13655                     write_number(static_cast<std::uint16_t>(N));
13656                 }
13657                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13658                 {
13659                     oa->write_character(to_char_type(0xBA));
13660                     write_number(static_cast<std::uint32_t>(N));
13661                 }
13662                 // LCOV_EXCL_START
13663                 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13664                 {
13665                     oa->write_character(to_char_type(0xBB));
13666                     write_number(static_cast<std::uint64_t>(N));
13667                 }
13668                 // LCOV_EXCL_STOP
13669
13670                 // step 2: write each element
13671                 for (const auto& el : *j.m_value.object)
13672                 {
13673                     write_cbor(el.first);
13674                     write_cbor(el.second);
13675                 }
13676                 break;
13677             }
13678
13679             case value_t::discarded:
13680             default:
13681                 break;
13682         }
13683     }
13684
13685     /*!
13686     @param[in] j  JSON value to serialize
13687     */
13688     void write_msgpack(const BasicJsonType& j)
13689     {
13690         switch (j.type())
13691         {
13692             case value_t::null: // nil
13693             {
13694                 oa->write_character(to_char_type(0xC0));
13695                 break;
13696             }
13697
13698             case value_t::boolean: // true and false
13699             {
13700                 oa->write_character(j.m_value.boolean
13701                                     ? to_char_type(0xC3)
13702                                     : to_char_type(0xC2));
13703                 break;
13704             }
13705
13706             case value_t::number_integer:
13707             {
13708                 if (j.m_value.number_integer >= 0)
13709                 {
13710                     // MessagePack does not differentiate between positive
13711                     // signed integers and unsigned integers. Therefore, we used
13712                     // the code from the value_t::number_unsigned case here.
13713                     if (j.m_value.number_unsigned < 128)
13714                     {
13715                         // positive fixnum
13716                         write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13717                     }
13718                     else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13719                     {
13720                         // uint 8
13721                         oa->write_character(to_char_type(0xCC));
13722                         write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13723                     }
13724                     else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13725                     {
13726                         // uint 16
13727                         oa->write_character(to_char_type(0xCD));
13728                         write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13729                     }
13730                     else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13731                     {
13732                         // uint 32
13733                         oa->write_character(to_char_type(0xCE));
13734                         write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13735                     }
13736                     else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13737                     {
13738                         // uint 64
13739                         oa->write_character(to_char_type(0xCF));
13740                         write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13741                     }
13742                 }
13743                 else
13744                 {
13745                     if (j.m_value.number_integer >= -32)
13746                     {
13747                         // negative fixnum
13748                         write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13749                     }
13750                     else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
13751                              j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
13752                     {
13753                         // int 8
13754                         oa->write_character(to_char_type(0xD0));
13755                         write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13756                     }
13757                     else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
13758                              j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
13759                     {
13760                         // int 16
13761                         oa->write_character(to_char_type(0xD1));
13762                         write_number(static_cast<std::int16_t>(j.m_value.number_integer));
13763                     }
13764                     else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
13765                              j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
13766                     {
13767                         // int 32
13768                         oa->write_character(to_char_type(0xD2));
13769                         write_number(static_cast<std::int32_t>(j.m_value.number_integer));
13770                     }
13771                     else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
13772                              j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
13773                     {
13774                         // int 64
13775                         oa->write_character(to_char_type(0xD3));
13776                         write_number(static_cast<std::int64_t>(j.m_value.number_integer));
13777                     }
13778                 }
13779                 break;
13780             }
13781
13782             case value_t::number_unsigned:
13783             {
13784                 if (j.m_value.number_unsigned < 128)
13785                 {
13786                     // positive fixnum
13787                     write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13788                 }
13789                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13790                 {
13791                     // uint 8
13792                     oa->write_character(to_char_type(0xCC));
13793                     write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13794                 }
13795                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13796                 {
13797                     // uint 16
13798                     oa->write_character(to_char_type(0xCD));
13799                     write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13800                 }
13801                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13802                 {
13803                     // uint 32
13804                     oa->write_character(to_char_type(0xCE));
13805                     write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13806                 }
13807                 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13808                 {
13809                     // uint 64
13810                     oa->write_character(to_char_type(0xCF));
13811                     write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13812                 }
13813                 break;
13814             }
13815
13816             case value_t::number_float:
13817             {
13818                 write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
13819                 break;
13820             }
13821
13822             case value_t::string:
13823             {
13824                 // step 1: write control byte and the string length
13825                 const auto N = j.m_value.string->size();
13826                 if (N <= 31)
13827                 {
13828                     // fixstr
13829                     write_number(static_cast<std::uint8_t>(0xA0 | N));
13830                 }
13831                 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13832                 {
13833                     // str 8
13834                     oa->write_character(to_char_type(0xD9));
13835                     write_number(static_cast<std::uint8_t>(N));
13836                 }
13837                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13838                 {
13839                     // str 16
13840                     oa->write_character(to_char_type(0xDA));
13841                     write_number(static_cast<std::uint16_t>(N));
13842                 }
13843                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13844                 {
13845                     // str 32
13846                     oa->write_character(to_char_type(0xDB));
13847                     write_number(static_cast<std::uint32_t>(N));
13848                 }
13849
13850                 // step 2: write the string
13851                 oa->write_characters(
13852                     reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13853                     j.m_value.string->size());
13854                 break;
13855             }
13856
13857             case value_t::array:
13858             {
13859                 // step 1: write control byte and the array size
13860                 const auto N = j.m_value.array->size();
13861                 if (N <= 15)
13862                 {
13863                     // fixarray
13864                     write_number(static_cast<std::uint8_t>(0x90 | N));
13865                 }
13866                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13867                 {
13868                     // array 16
13869                     oa->write_character(to_char_type(0xDC));
13870                     write_number(static_cast<std::uint16_t>(N));
13871                 }
13872                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13873                 {
13874                     // array 32
13875                     oa->write_character(to_char_type(0xDD));
13876                     write_number(static_cast<std::uint32_t>(N));
13877                 }
13878
13879                 // step 2: write each element
13880                 for (const auto& el : *j.m_value.array)
13881                 {
13882                     write_msgpack(el);
13883                 }
13884                 break;
13885             }
13886
13887             case value_t::binary:
13888             {
13889                 // step 0: determine if the binary type has a set subtype to
13890                 // determine whether or not to use the ext or fixext types
13891                 const bool use_ext = j.m_value.binary->has_subtype();
13892
13893                 // step 1: write control byte and the byte string length
13894                 const auto N = j.m_value.binary->size();
13895                 if (N <= (std::numeric_limits<std::uint8_t>::max)())
13896                 {
13897                     std::uint8_t output_type{};
13898                     bool fixed = true;
13899                     if (use_ext)
13900                     {
13901                         switch (N)
13902                         {
13903                             case 1:
13904                                 output_type = 0xD4; // fixext 1
13905                                 break;
13906                             case 2:
13907                                 output_type = 0xD5; // fixext 2
13908                                 break;
13909                             case 4:
13910                                 output_type = 0xD6; // fixext 4
13911                                 break;
13912                             case 8:
13913                                 output_type = 0xD7; // fixext 8
13914                                 break;
13915                             case 16:
13916                                 output_type = 0xD8; // fixext 16
13917                                 break;
13918                             default:
13919                                 output_type = 0xC7; // ext 8
13920                                 fixed = false;
13921                                 break;
13922                         }
13923
13924                     }
13925                     else
13926                     {
13927                         output_type = 0xC4; // bin 8
13928                         fixed = false;
13929                     }
13930
13931                     oa->write_character(to_char_type(output_type));
13932                     if (!fixed)
13933                     {
13934                         write_number(static_cast<std::uint8_t>(N));
13935                     }
13936                 }
13937                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13938                 {
13939                     std::uint8_t output_type = use_ext
13940                                                ? 0xC8 // ext 16
13941                                                : 0xC5; // bin 16
13942
13943                     oa->write_character(to_char_type(output_type));
13944                     write_number(static_cast<std::uint16_t>(N));
13945                 }
13946                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13947                 {
13948                     std::uint8_t output_type = use_ext
13949                                                ? 0xC9 // ext 32
13950                                                : 0xC6; // bin 32
13951
13952                     oa->write_character(to_char_type(output_type));
13953                     write_number(static_cast<std::uint32_t>(N));
13954                 }
13955
13956                 // step 1.5: if this is an ext type, write the subtype
13957                 if (use_ext)
13958                 {
13959                     write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
13960                 }
13961
13962                 // step 2: write the byte string
13963                 oa->write_characters(
13964                     reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13965                     N);
13966
13967                 break;
13968             }
13969
13970             case value_t::object:
13971             {
13972                 // step 1: write control byte and the object size
13973                 const auto N = j.m_value.object->size();
13974                 if (N <= 15)
13975                 {
13976                     // fixmap
13977                     write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
13978                 }
13979                 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13980                 {
13981                     // map 16
13982                     oa->write_character(to_char_type(0xDE));
13983                     write_number(static_cast<std::uint16_t>(N));
13984                 }
13985                 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13986                 {
13987                     // map 32
13988                     oa->write_character(to_char_type(0xDF));
13989                     write_number(static_cast<std::uint32_t>(N));
13990                 }
13991
13992                 // step 2: write each element
13993                 for (const auto& el : *j.m_value.object)
13994                 {
13995                     write_msgpack(el.first);
13996                     write_msgpack(el.second);
13997                 }
13998                 break;
13999             }
14000
14001             case value_t::discarded:
14002             default:
14003                 break;
14004         }
14005     }
14006
14007     /*!
14008     @param[in] j  JSON value to serialize
14009     @param[in] use_count   whether to use '#' prefixes (optimized format)
14010     @param[in] use_type    whether to use '$' prefixes (optimized format)
14011     @param[in] add_prefix  whether prefixes need to be used for this value
14012     */
14013     void write_ubjson(const BasicJsonType& j, const bool use_count,
14014                       const bool use_type, const bool add_prefix = true)
14015     {
14016         switch (j.type())
14017         {
14018             case value_t::null:
14019             {
14020                 if (add_prefix)
14021                 {
14022                     oa->write_character(to_char_type('Z'));
14023                 }
14024                 break;
14025             }
14026
14027             case value_t::boolean:
14028             {
14029                 if (add_prefix)
14030                 {
14031                     oa->write_character(j.m_value.boolean
14032                                         ? to_char_type('T')
14033                                         : to_char_type('F'));
14034                 }
14035                 break;
14036             }
14037
14038             case value_t::number_integer:
14039             {
14040                 write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
14041                 break;
14042             }
14043
14044             case value_t::number_unsigned:
14045             {
14046                 write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
14047                 break;
14048             }
14049
14050             case value_t::number_float:
14051             {
14052                 write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
14053                 break;
14054             }
14055
14056             case value_t::string:
14057             {
14058                 if (add_prefix)
14059                 {
14060                     oa->write_character(to_char_type('S'));
14061                 }
14062                 write_number_with_ubjson_prefix(j.m_value.string->size(), true);
14063                 oa->write_characters(
14064                     reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
14065                     j.m_value.string->size());
14066                 break;
14067             }
14068
14069             case value_t::array:
14070             {
14071                 if (add_prefix)
14072                 {
14073                     oa->write_character(to_char_type('['));
14074                 }
14075
14076                 bool prefix_required = true;
14077                 if (use_type && !j.m_value.array->empty())
14078                 {
14079                     JSON_ASSERT(use_count);
14080                     const CharType first_prefix = ubjson_prefix(j.front());
14081                     const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
14082                                                          [this, first_prefix](const BasicJsonType & v)
14083                     {
14084                         return ubjson_prefix(v) == first_prefix;
14085                     });
14086
14087                     if (same_prefix)
14088                     {
14089                         prefix_required = false;
14090                         oa->write_character(to_char_type('$'));
14091                         oa->write_character(first_prefix);
14092                     }
14093                 }
14094
14095                 if (use_count)
14096                 {
14097                     oa->write_character(to_char_type('#'));
14098                     write_number_with_ubjson_prefix(j.m_value.array->size(), true);
14099                 }
14100
14101                 for (const auto& el : *j.m_value.array)
14102                 {
14103                     write_ubjson(el, use_count, use_type, prefix_required);
14104                 }
14105
14106                 if (!use_count)
14107                 {
14108                     oa->write_character(to_char_type(']'));
14109                 }
14110
14111                 break;
14112             }
14113
14114             case value_t::binary:
14115             {
14116                 if (add_prefix)
14117                 {
14118                     oa->write_character(to_char_type('['));
14119                 }
14120
14121                 if (use_type && !j.m_value.binary->empty())
14122                 {
14123                     JSON_ASSERT(use_count);
14124                     oa->write_character(to_char_type('$'));
14125                     oa->write_character('U');
14126                 }
14127
14128                 if (use_count)
14129                 {
14130                     oa->write_character(to_char_type('#'));
14131                     write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
14132                 }
14133
14134                 if (use_type)
14135                 {
14136                     oa->write_characters(
14137                         reinterpret_cast<const CharType*>(j.m_value.binary->data()),
14138                         j.m_value.binary->size());
14139                 }
14140                 else
14141                 {
14142                     for (size_t i = 0; i < j.m_value.binary->size(); ++i)
14143                     {
14144                         oa->write_character(to_char_type('U'));
14145                         oa->write_character(j.m_value.binary->data()[i]);
14146                     }
14147                 }
14148
14149                 if (!use_count)
14150                 {
14151                     oa->write_character(to_char_type(']'));
14152                 }
14153
14154                 break;
14155             }
14156
14157             case value_t::object:
14158             {
14159                 if (add_prefix)
14160                 {
14161                     oa->write_character(to_char_type('{'));
14162                 }
14163
14164                 bool prefix_required = true;
14165                 if (use_type && !j.m_value.object->empty())
14166                 {
14167                     JSON_ASSERT(use_count);
14168                     const CharType first_prefix = ubjson_prefix(j.front());
14169                     const bool same_prefix = std::all_of(j.begin(), j.end(),
14170                                                          [this, first_prefix](const BasicJsonType & v)
14171                     {
14172                         return ubjson_prefix(v) == first_prefix;
14173                     });
14174
14175                     if (same_prefix)
14176                     {
14177                         prefix_required = false;
14178                         oa->write_character(to_char_type('$'));
14179                         oa->write_character(first_prefix);
14180                     }
14181                 }
14182
14183                 if (use_count)
14184                 {
14185                     oa->write_character(to_char_type('#'));
14186                     write_number_with_ubjson_prefix(j.m_value.object->size(), true);
14187                 }
14188
14189                 for (const auto& el : *j.m_value.object)
14190                 {
14191                     write_number_with_ubjson_prefix(el.first.size(), true);
14192                     oa->write_characters(
14193                         reinterpret_cast<const CharType*>(el.first.c_str()),
14194                         el.first.size());
14195                     write_ubjson(el.second, use_count, use_type, prefix_required);
14196                 }
14197
14198                 if (!use_count)
14199                 {
14200                     oa->write_character(to_char_type('}'));
14201                 }
14202
14203                 break;
14204             }
14205
14206             case value_t::discarded:
14207             default:
14208                 break;
14209         }
14210     }
14211
14212   private:
14213     //////////
14214     // BSON //
14215     //////////
14216
14217     /*!
14218     @return The size of a BSON document entry header, including the id marker
14219             and the entry name size (and its null-terminator).
14220     */
14221     static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
14222     {
14223         const auto it = name.find(static_cast<typename string_t::value_type>(0));
14224         if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
14225         {
14226             JSON_THROW(out_of_range::create(409, "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")", j));
14227             static_cast<void>(j);
14228         }
14229
14230         return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
14231     }
14232
14233     /*!
14234     @brief Writes the given @a element_type and @a name to the output adapter
14235     */
14236     void write_bson_entry_header(const string_t& name,
14237                                  const std::uint8_t element_type)
14238     {
14239         oa->write_character(to_char_type(element_type)); // boolean
14240         oa->write_characters(
14241             reinterpret_cast<const CharType*>(name.c_str()),
14242             name.size() + 1u);
14243     }
14244
14245     /*!
14246     @brief Writes a BSON element with key @a name and boolean value @a value
14247     */
14248     void write_bson_boolean(const string_t& name,
14249                             const bool value)
14250     {
14251         write_bson_entry_header(name, 0x08);
14252         oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
14253     }
14254
14255     /*!
14256     @brief Writes a BSON element with key @a name and double value @a value
14257     */
14258     void write_bson_double(const string_t& name,
14259                            const double value)
14260     {
14261         write_bson_entry_header(name, 0x01);
14262         write_number<double, true>(value);
14263     }
14264
14265     /*!
14266     @return The size of the BSON-encoded string in @a value
14267     */
14268     static std::size_t calc_bson_string_size(const string_t& value)
14269     {
14270         return sizeof(std::int32_t) + value.size() + 1ul;
14271     }
14272
14273     /*!
14274     @brief Writes a BSON element with key @a name and string value @a value
14275     */
14276     void write_bson_string(const string_t& name,
14277                            const string_t& value)
14278     {
14279         write_bson_entry_header(name, 0x02);
14280
14281         write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
14282         oa->write_characters(
14283             reinterpret_cast<const CharType*>(value.c_str()),
14284             value.size() + 1);
14285     }
14286
14287     /*!
14288     @brief Writes a BSON element with key @a name and null value
14289     */
14290     void write_bson_null(const string_t& name)
14291     {
14292         write_bson_entry_header(name, 0x0A);
14293     }
14294
14295     /*!
14296     @return The size of the BSON-encoded integer @a value
14297     */
14298     static std::size_t calc_bson_integer_size(const std::int64_t value)
14299     {
14300         return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
14301                ? sizeof(std::int32_t)
14302                : sizeof(std::int64_t);
14303     }
14304
14305     /*!
14306     @brief Writes a BSON element with key @a name and integer @a value
14307     */
14308     void write_bson_integer(const string_t& name,
14309                             const std::int64_t value)
14310     {
14311         if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
14312         {
14313             write_bson_entry_header(name, 0x10); // int32
14314             write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
14315         }
14316         else
14317         {
14318             write_bson_entry_header(name, 0x12); // int64
14319             write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
14320         }
14321     }
14322
14323     /*!
14324     @return The size of the BSON-encoded unsigned integer in @a j
14325     */
14326     static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
14327     {
14328         return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14329                ? sizeof(std::int32_t)
14330                : sizeof(std::int64_t);
14331     }
14332
14333     /*!
14334     @brief Writes a BSON element with key @a name and unsigned @a value
14335     */
14336     void write_bson_unsigned(const string_t& name,
14337                              const BasicJsonType& j)
14338     {
14339         if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14340         {
14341             write_bson_entry_header(name, 0x10 /* int32 */);
14342             write_number<std::int32_t, true>(static_cast<std::int32_t>(j.m_value.number_unsigned));
14343         }
14344         else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14345         {
14346             write_bson_entry_header(name, 0x12 /* int64 */);
14347             write_number<std::int64_t, true>(static_cast<std::int64_t>(j.m_value.number_unsigned));
14348         }
14349         else
14350         {
14351             JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(j.m_value.number_unsigned) + " cannot be represented by BSON as it does not fit int64", j));
14352         }
14353     }
14354
14355     /*!
14356     @brief Writes a BSON element with key @a name and object @a value
14357     */
14358     void write_bson_object_entry(const string_t& name,
14359                                  const typename BasicJsonType::object_t& value)
14360     {
14361         write_bson_entry_header(name, 0x03); // object
14362         write_bson_object(value);
14363     }
14364
14365     /*!
14366     @return The size of the BSON-encoded array @a value
14367     */
14368     static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
14369     {
14370         std::size_t array_index = 0ul;
14371
14372         const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
14373         {
14374             return result + calc_bson_element_size(std::to_string(array_index++), el);
14375         });
14376
14377         return sizeof(std::int32_t) + embedded_document_size + 1ul;
14378     }
14379
14380     /*!
14381     @return The size of the BSON-encoded binary array @a value
14382     */
14383     static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
14384     {
14385         return sizeof(std::int32_t) + value.size() + 1ul;
14386     }
14387
14388     /*!
14389     @brief Writes a BSON element with key @a name and array @a value
14390     */
14391     void write_bson_array(const string_t& name,
14392                           const typename BasicJsonType::array_t& value)
14393     {
14394         write_bson_entry_header(name, 0x04); // array
14395         write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
14396
14397         std::size_t array_index = 0ul;
14398
14399         for (const auto& el : value)
14400         {
14401             write_bson_element(std::to_string(array_index++), el);
14402         }
14403
14404         oa->write_character(to_char_type(0x00));
14405     }
14406
14407     /*!
14408     @brief Writes a BSON element with key @a name and binary value @a value
14409     */
14410     void write_bson_binary(const string_t& name,
14411                            const binary_t& value)
14412     {
14413         write_bson_entry_header(name, 0x05);
14414
14415         write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
14416         write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
14417
14418         oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
14419     }
14420
14421     /*!
14422     @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
14423     @return The calculated size for the BSON document entry for @a j with the given @a name.
14424     */
14425     static std::size_t calc_bson_element_size(const string_t& name,
14426             const BasicJsonType& j)
14427     {
14428         const auto header_size = calc_bson_entry_header_size(name, j);
14429         switch (j.type())
14430         {
14431             case value_t::object:
14432                 return header_size + calc_bson_object_size(*j.m_value.object);
14433
14434             case value_t::array:
14435                 return header_size + calc_bson_array_size(*j.m_value.array);
14436
14437             case value_t::binary:
14438                 return header_size + calc_bson_binary_size(*j.m_value.binary);
14439
14440             case value_t::boolean:
14441                 return header_size + 1ul;
14442
14443             case value_t::number_float:
14444                 return header_size + 8ul;
14445
14446             case value_t::number_integer:
14447                 return header_size + calc_bson_integer_size(j.m_value.number_integer);
14448
14449             case value_t::number_unsigned:
14450                 return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
14451
14452             case value_t::string:
14453                 return header_size + calc_bson_string_size(*j.m_value.string);
14454
14455             case value_t::null:
14456                 return header_size + 0ul;
14457
14458             // LCOV_EXCL_START
14459             case value_t::discarded:
14460             default:
14461                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
14462                 return 0ul;
14463                 // LCOV_EXCL_STOP
14464         }
14465     }
14466
14467     /*!
14468     @brief Serializes the JSON value @a j to BSON and associates it with the
14469            key @a name.
14470     @param name The name to associate with the JSON entity @a j within the
14471                 current BSON document
14472     */
14473     void write_bson_element(const string_t& name,
14474                             const BasicJsonType& j)
14475     {
14476         switch (j.type())
14477         {
14478             case value_t::object:
14479                 return write_bson_object_entry(name, *j.m_value.object);
14480
14481             case value_t::array:
14482                 return write_bson_array(name, *j.m_value.array);
14483
14484             case value_t::binary:
14485                 return write_bson_binary(name, *j.m_value.binary);
14486
14487             case value_t::boolean:
14488                 return write_bson_boolean(name, j.m_value.boolean);
14489
14490             case value_t::number_float:
14491                 return write_bson_double(name, j.m_value.number_float);
14492
14493             case value_t::number_integer:
14494                 return write_bson_integer(name, j.m_value.number_integer);
14495
14496             case value_t::number_unsigned:
14497                 return write_bson_unsigned(name, j);
14498
14499             case value_t::string:
14500                 return write_bson_string(name, *j.m_value.string);
14501
14502             case value_t::null:
14503                 return write_bson_null(name);
14504
14505             // LCOV_EXCL_START
14506             case value_t::discarded:
14507             default:
14508                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
14509                 return;
14510                 // LCOV_EXCL_STOP
14511         }
14512     }
14513
14514     /*!
14515     @brief Calculates the size of the BSON serialization of the given
14516            JSON-object @a j.
14517     @param[in] value  JSON value to serialize
14518     @pre       value.type() == value_t::object
14519     */
14520     static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
14521     {
14522         std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
14523                                     [](size_t result, const typename BasicJsonType::object_t::value_type & el)
14524         {
14525             return result += calc_bson_element_size(el.first, el.second);
14526         });
14527
14528         return sizeof(std::int32_t) + document_size + 1ul;
14529     }
14530
14531     /*!
14532     @param[in] value  JSON value to serialize
14533     @pre       value.type() == value_t::object
14534     */
14535     void write_bson_object(const typename BasicJsonType::object_t& value)
14536     {
14537         write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
14538
14539         for (const auto& el : value)
14540         {
14541             write_bson_element(el.first, el.second);
14542         }
14543
14544         oa->write_character(to_char_type(0x00));
14545     }
14546
14547     //////////
14548     // CBOR //
14549     //////////
14550
14551     static constexpr CharType get_cbor_float_prefix(float /*unused*/)
14552     {
14553         return to_char_type(0xFA);  // Single-Precision Float
14554     }
14555
14556     static constexpr CharType get_cbor_float_prefix(double /*unused*/)
14557     {
14558         return to_char_type(0xFB);  // Double-Precision Float
14559     }
14560
14561     /////////////
14562     // MsgPack //
14563     /////////////
14564
14565     static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
14566     {
14567         return to_char_type(0xCA);  // float 32
14568     }
14569
14570     static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
14571     {
14572         return to_char_type(0xCB);  // float 64
14573     }
14574
14575     ////////////
14576     // UBJSON //
14577     ////////////
14578
14579     // UBJSON: write number (floating point)
14580     template<typename NumberType, typename std::enable_if<
14581                  std::is_floating_point<NumberType>::value, int>::type = 0>
14582     void write_number_with_ubjson_prefix(const NumberType n,
14583                                          const bool add_prefix)
14584     {
14585         if (add_prefix)
14586         {
14587             oa->write_character(get_ubjson_float_prefix(n));
14588         }
14589         write_number(n);
14590     }
14591
14592     // UBJSON: write number (unsigned integer)
14593     template<typename NumberType, typename std::enable_if<
14594                  std::is_unsigned<NumberType>::value, int>::type = 0>
14595     void write_number_with_ubjson_prefix(const NumberType n,
14596                                          const bool add_prefix)
14597     {
14598         if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14599         {
14600             if (add_prefix)
14601             {
14602                 oa->write_character(to_char_type('i'));  // int8
14603             }
14604             write_number(static_cast<std::uint8_t>(n));
14605         }
14606         else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14607         {
14608             if (add_prefix)
14609             {
14610                 oa->write_character(to_char_type('U'));  // uint8
14611             }
14612             write_number(static_cast<std::uint8_t>(n));
14613         }
14614         else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14615         {
14616             if (add_prefix)
14617             {
14618                 oa->write_character(to_char_type('I'));  // int16
14619             }
14620             write_number(static_cast<std::int16_t>(n));
14621         }
14622         else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14623         {
14624             if (add_prefix)
14625             {
14626                 oa->write_character(to_char_type('l'));  // int32
14627             }
14628             write_number(static_cast<std::int32_t>(n));
14629         }
14630         else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14631         {
14632             if (add_prefix)
14633             {
14634                 oa->write_character(to_char_type('L'));  // int64
14635             }
14636             write_number(static_cast<std::int64_t>(n));
14637         }
14638         else
14639         {
14640             if (add_prefix)
14641             {
14642                 oa->write_character(to_char_type('H'));  // high-precision number
14643             }
14644
14645             const auto number = BasicJsonType(n).dump();
14646             write_number_with_ubjson_prefix(number.size(), true);
14647             for (std::size_t i = 0; i < number.size(); ++i)
14648             {
14649                 oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14650             }
14651         }
14652     }
14653
14654     // UBJSON: write number (signed integer)
14655     template < typename NumberType, typename std::enable_if <
14656                    std::is_signed<NumberType>::value&&
14657                    !std::is_floating_point<NumberType>::value, int >::type = 0 >
14658     void write_number_with_ubjson_prefix(const NumberType n,
14659                                          const bool add_prefix)
14660     {
14661         if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14662         {
14663             if (add_prefix)
14664             {
14665                 oa->write_character(to_char_type('i'));  // int8
14666             }
14667             write_number(static_cast<std::int8_t>(n));
14668         }
14669         else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
14670         {
14671             if (add_prefix)
14672             {
14673                 oa->write_character(to_char_type('U'));  // uint8
14674             }
14675             write_number(static_cast<std::uint8_t>(n));
14676         }
14677         else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14678         {
14679             if (add_prefix)
14680             {
14681                 oa->write_character(to_char_type('I'));  // int16
14682             }
14683             write_number(static_cast<std::int16_t>(n));
14684         }
14685         else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14686         {
14687             if (add_prefix)
14688             {
14689                 oa->write_character(to_char_type('l'));  // int32
14690             }
14691             write_number(static_cast<std::int32_t>(n));
14692         }
14693         else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14694         {
14695             if (add_prefix)
14696             {
14697                 oa->write_character(to_char_type('L'));  // int64
14698             }
14699             write_number(static_cast<std::int64_t>(n));
14700         }
14701         // LCOV_EXCL_START
14702         else
14703         {
14704             if (add_prefix)
14705             {
14706                 oa->write_character(to_char_type('H'));  // high-precision number
14707             }
14708
14709             const auto number = BasicJsonType(n).dump();
14710             write_number_with_ubjson_prefix(number.size(), true);
14711             for (std::size_t i = 0; i < number.size(); ++i)
14712             {
14713                 oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14714             }
14715         }
14716         // LCOV_EXCL_STOP
14717     }
14718
14719     /*!
14720     @brief determine the type prefix of container values
14721     */
14722     CharType ubjson_prefix(const BasicJsonType& j) const noexcept
14723     {
14724         switch (j.type())
14725         {
14726             case value_t::null:
14727                 return 'Z';
14728
14729             case value_t::boolean:
14730                 return j.m_value.boolean ? 'T' : 'F';
14731
14732             case value_t::number_integer:
14733             {
14734                 if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
14735                 {
14736                     return 'i';
14737                 }
14738                 if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
14739                 {
14740                     return 'U';
14741                 }
14742                 if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
14743                 {
14744                     return 'I';
14745                 }
14746                 if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
14747                 {
14748                     return 'l';
14749                 }
14750                 if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
14751                 {
14752                     return 'L';
14753                 }
14754                 // anything else is treated as high-precision number
14755                 return 'H'; // LCOV_EXCL_LINE
14756             }
14757
14758             case value_t::number_unsigned:
14759             {
14760                 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14761                 {
14762                     return 'i';
14763                 }
14764                 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
14765                 {
14766                     return 'U';
14767                 }
14768                 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14769                 {
14770                     return 'I';
14771                 }
14772                 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14773                 {
14774                     return 'l';
14775                 }
14776                 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14777                 {
14778                     return 'L';
14779                 }
14780                 // anything else is treated as high-precision number
14781                 return 'H'; // LCOV_EXCL_LINE
14782             }
14783
14784             case value_t::number_float:
14785                 return get_ubjson_float_prefix(j.m_value.number_float);
14786
14787             case value_t::string:
14788                 return 'S';
14789
14790             case value_t::array: // fallthrough
14791             case value_t::binary:
14792                 return '[';
14793
14794             case value_t::object:
14795                 return '{';
14796
14797             case value_t::discarded:
14798             default:  // discarded values
14799                 return 'N';
14800         }
14801     }
14802
14803     static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
14804     {
14805         return 'd';  // float 32
14806     }
14807
14808     static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
14809     {
14810         return 'D';  // float 64
14811     }
14812
14813     ///////////////////////
14814     // Utility functions //
14815     ///////////////////////
14816
14817     /*
14818     @brief write a number to output input
14819     @param[in] n number of type @a NumberType
14820     @tparam NumberType the type of the number
14821     @tparam OutputIsLittleEndian Set to true if output data is
14822                                  required to be little endian
14823
14824     @note This function needs to respect the system's endianness, because bytes
14825           in CBOR, MessagePack, and UBJSON are stored in network order (big
14826           endian) and therefore need reordering on little endian systems.
14827     */
14828     template<typename NumberType, bool OutputIsLittleEndian = false>
14829     void write_number(const NumberType n)
14830     {
14831         // step 1: write number to array of length NumberType
14832         std::array<CharType, sizeof(NumberType)> vec{};
14833         std::memcpy(vec.data(), &n, sizeof(NumberType));
14834
14835         // step 2: write array to output (with possible reordering)
14836         if (is_little_endian != OutputIsLittleEndian)
14837         {
14838             // reverse byte order prior to conversion if necessary
14839             std::reverse(vec.begin(), vec.end());
14840         }
14841
14842         oa->write_characters(vec.data(), sizeof(NumberType));
14843     }
14844
14845     void write_compact_float(const number_float_t n, detail::input_format_t format)
14846     {
14847 #ifdef __GNUC__
14848 #pragma GCC diagnostic push
14849 #pragma GCC diagnostic ignored "-Wfloat-equal"
14850 #endif
14851         if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
14852                 static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
14853                 static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
14854         {
14855             oa->write_character(format == detail::input_format_t::cbor
14856                                 ? get_cbor_float_prefix(static_cast<float>(n))
14857                                 : get_msgpack_float_prefix(static_cast<float>(n)));
14858             write_number(static_cast<float>(n));
14859         }
14860         else
14861         {
14862             oa->write_character(format == detail::input_format_t::cbor
14863                                 ? get_cbor_float_prefix(n)
14864                                 : get_msgpack_float_prefix(n));
14865             write_number(n);
14866         }
14867 #ifdef __GNUC__
14868 #pragma GCC diagnostic pop
14869 #endif
14870     }
14871
14872   public:
14873     // The following to_char_type functions are implement the conversion
14874     // between uint8_t and CharType. In case CharType is not unsigned,
14875     // such a conversion is required to allow values greater than 128.
14876     // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
14877     template < typename C = CharType,
14878                enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
14879     static constexpr CharType to_char_type(std::uint8_t x) noexcept
14880     {
14881         return *reinterpret_cast<char*>(&x);
14882     }
14883
14884     template < typename C = CharType,
14885                enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
14886     static CharType to_char_type(std::uint8_t x) noexcept
14887     {
14888         static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
14889         static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
14890         CharType result;
14891         std::memcpy(&result, &x, sizeof(x));
14892         return result;
14893     }
14894
14895     template<typename C = CharType,
14896              enable_if_t<std::is_unsigned<C>::value>* = nullptr>
14897     static constexpr CharType to_char_type(std::uint8_t x) noexcept
14898     {
14899         return x;
14900     }
14901
14902     template < typename InputCharType, typename C = CharType,
14903                enable_if_t <
14904                    std::is_signed<C>::value &&
14905                    std::is_signed<char>::value &&
14906                    std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
14907                    > * = nullptr >
14908     static constexpr CharType to_char_type(InputCharType x) noexcept
14909     {
14910         return x;
14911     }
14912
14913   private:
14914     /// whether we can assume little endianness
14915     const bool is_little_endian = little_endianness();
14916
14917     /// the output
14918     output_adapter_t<CharType> oa = nullptr;
14919 };
14920 }  // namespace detail
14921 }  // namespace nlohmann
14922
14923 // #include <nlohmann/detail/output/output_adapters.hpp>
14924
14925 // #include <nlohmann/detail/output/serializer.hpp>
14926
14927
14928 #include <algorithm> // reverse, remove, fill, find, none_of
14929 #include <array> // array
14930 #include <clocale> // localeconv, lconv
14931 #include <cmath> // labs, isfinite, isnan, signbit
14932 #include <cstddef> // size_t, ptrdiff_t
14933 #include <cstdint> // uint8_t
14934 #include <cstdio> // snprintf
14935 #include <limits> // numeric_limits
14936 #include <string> // string, char_traits
14937 #include <iomanip> // setfill, setw
14938 #include <sstream> // stringstream
14939 #include <type_traits> // is_same
14940 #include <utility> // move
14941
14942 // #include <nlohmann/detail/conversions/to_chars.hpp>
14943
14944
14945 #include <array> // array
14946 #include <cmath>   // signbit, isfinite
14947 #include <cstdint> // intN_t, uintN_t
14948 #include <cstring> // memcpy, memmove
14949 #include <limits> // numeric_limits
14950 #include <type_traits> // conditional
14951
14952 // #include <nlohmann/detail/macro_scope.hpp>
14953
14954
14955 namespace nlohmann
14956 {
14957 namespace detail
14958 {
14959
14960 /*!
14961 @brief implements the Grisu2 algorithm for binary to decimal floating-point
14962 conversion.
14963
14964 This implementation is a slightly modified version of the reference
14965 implementation which may be obtained from
14966 http://florian.loitsch.com/publications (bench.tar.gz).
14967
14968 The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
14969
14970 For a detailed description of the algorithm see:
14971
14972 [1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
14973     Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
14974     Language Design and Implementation, PLDI 2010
14975 [2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
14976     Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
14977     Design and Implementation, PLDI 1996
14978 */
14979 namespace dtoa_impl
14980 {
14981
14982 template<typename Target, typename Source>
14983 Target reinterpret_bits(const Source source)
14984 {
14985     static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
14986
14987     Target target;
14988     std::memcpy(&target, &source, sizeof(Source));
14989     return target;
14990 }
14991
14992 struct diyfp // f * 2^e
14993 {
14994     static constexpr int kPrecision = 64; // = q
14995
14996     std::uint64_t f = 0;
14997     int e = 0;
14998
14999     constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
15000
15001     /*!
15002     @brief returns x - y
15003     @pre x.e == y.e and x.f >= y.f
15004     */
15005     static diyfp sub(const diyfp& x, const diyfp& y) noexcept
15006     {
15007         JSON_ASSERT(x.e == y.e);
15008         JSON_ASSERT(x.f >= y.f);
15009
15010         return {x.f - y.f, x.e};
15011     }
15012
15013     /*!
15014     @brief returns x * y
15015     @note The result is rounded. (Only the upper q bits are returned.)
15016     */
15017     static diyfp mul(const diyfp& x, const diyfp& y) noexcept
15018     {
15019         static_assert(kPrecision == 64, "internal error");
15020
15021         // Computes:
15022         //  f = round((x.f * y.f) / 2^q)
15023         //  e = x.e + y.e + q
15024
15025         // Emulate the 64-bit * 64-bit multiplication:
15026         //
15027         // p = u * v
15028         //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
15029         //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
15030         //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
15031         //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
15032         //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
15033         //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
15034         //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
15035         //
15036         // (Since Q might be larger than 2^32 - 1)
15037         //
15038         //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
15039         //
15040         // (Q_hi + H does not overflow a 64-bit int)
15041         //
15042         //   = p_lo + 2^64 p_hi
15043
15044         const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
15045         const std::uint64_t u_hi = x.f >> 32u;
15046         const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
15047         const std::uint64_t v_hi = y.f >> 32u;
15048
15049         const std::uint64_t p0 = u_lo * v_lo;
15050         const std::uint64_t p1 = u_lo * v_hi;
15051         const std::uint64_t p2 = u_hi * v_lo;
15052         const std::uint64_t p3 = u_hi * v_hi;
15053
15054         const std::uint64_t p0_hi = p0 >> 32u;
15055         const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
15056         const std::uint64_t p1_hi = p1 >> 32u;
15057         const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
15058         const std::uint64_t p2_hi = p2 >> 32u;
15059
15060         std::uint64_t Q = p0_hi + p1_lo + p2_lo;
15061
15062         // The full product might now be computed as
15063         //
15064         // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
15065         // p_lo = p0_lo + (Q << 32)
15066         //
15067         // But in this particular case here, the full p_lo is not required.
15068         // Effectively we only need to add the highest bit in p_lo to p_hi (and
15069         // Q_hi + 1 does not overflow).
15070
15071         Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
15072
15073         const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
15074
15075         return {h, x.e + y.e + 64};
15076     }
15077
15078     /*!
15079     @brief normalize x such that the significand is >= 2^(q-1)
15080     @pre x.f != 0
15081     */
15082     static diyfp normalize(diyfp x) noexcept
15083     {
15084         JSON_ASSERT(x.f != 0);
15085
15086         while ((x.f >> 63u) == 0)
15087         {
15088             x.f <<= 1u;
15089             x.e--;
15090         }
15091
15092         return x;
15093     }
15094
15095     /*!
15096     @brief normalize x such that the result has the exponent E
15097     @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
15098     */
15099     static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
15100     {
15101         const int delta = x.e - target_exponent;
15102
15103         JSON_ASSERT(delta >= 0);
15104         JSON_ASSERT(((x.f << delta) >> delta) == x.f);
15105
15106         return {x.f << delta, target_exponent};
15107     }
15108 };
15109
15110 struct boundaries
15111 {
15112     diyfp w;
15113     diyfp minus;
15114     diyfp plus;
15115 };
15116
15117 /*!
15118 Compute the (normalized) diyfp representing the input number 'value' and its
15119 boundaries.
15120
15121 @pre value must be finite and positive
15122 */
15123 template<typename FloatType>
15124 boundaries compute_boundaries(FloatType value)
15125 {
15126     JSON_ASSERT(std::isfinite(value));
15127     JSON_ASSERT(value > 0);
15128
15129     // Convert the IEEE representation into a diyfp.
15130     //
15131     // If v is denormal:
15132     //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
15133     // If v is normalized:
15134     //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
15135
15136     static_assert(std::numeric_limits<FloatType>::is_iec559,
15137                   "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
15138
15139     constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
15140     constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
15141     constexpr int      kMinExp    = 1 - kBias;
15142     constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
15143
15144     using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
15145
15146     const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
15147     const std::uint64_t E = bits >> (kPrecision - 1);
15148     const std::uint64_t F = bits & (kHiddenBit - 1);
15149
15150     const bool is_denormal = E == 0;
15151     const diyfp v = is_denormal
15152                     ? diyfp(F, kMinExp)
15153                     : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
15154
15155     // Compute the boundaries m- and m+ of the floating-point value
15156     // v = f * 2^e.
15157     //
15158     // Determine v- and v+, the floating-point predecessor and successor if v,
15159     // respectively.
15160     //
15161     //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
15162     //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
15163     //
15164     //      v+ = v + 2^e
15165     //
15166     // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
15167     // between m- and m+ round to v, regardless of how the input rounding
15168     // algorithm breaks ties.
15169     //
15170     //      ---+-------------+-------------+-------------+-------------+---  (A)
15171     //         v-            m-            v             m+            v+
15172     //
15173     //      -----------------+------+------+-------------+-------------+---  (B)
15174     //                       v-     m-     v             m+            v+
15175
15176     const bool lower_boundary_is_closer = F == 0 && E > 1;
15177     const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
15178     const diyfp m_minus = lower_boundary_is_closer
15179                           ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
15180                           : diyfp(2 * v.f - 1, v.e - 1); // (A)
15181
15182     // Determine the normalized w+ = m+.
15183     const diyfp w_plus = diyfp::normalize(m_plus);
15184
15185     // Determine w- = m- such that e_(w-) = e_(w+).
15186     const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
15187
15188     return {diyfp::normalize(v), w_minus, w_plus};
15189 }
15190
15191 // Given normalized diyfp w, Grisu needs to find a (normalized) cached
15192 // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
15193 // within a certain range [alpha, gamma] (Definition 3.2 from [1])
15194 //
15195 //      alpha <= e = e_c + e_w + q <= gamma
15196 //
15197 // or
15198 //
15199 //      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
15200 //                          <= f_c * f_w * 2^gamma
15201 //
15202 // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
15203 //
15204 //      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
15205 //
15206 // or
15207 //
15208 //      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
15209 //
15210 // The choice of (alpha,gamma) determines the size of the table and the form of
15211 // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
15212 // in practice:
15213 //
15214 // The idea is to cut the number c * w = f * 2^e into two parts, which can be
15215 // processed independently: An integral part p1, and a fractional part p2:
15216 //
15217 //      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
15218 //              = (f div 2^-e) + (f mod 2^-e) * 2^e
15219 //              = p1 + p2 * 2^e
15220 //
15221 // The conversion of p1 into decimal form requires a series of divisions and
15222 // modulos by (a power of) 10. These operations are faster for 32-bit than for
15223 // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
15224 // achieved by choosing
15225 //
15226 //      -e >= 32   or   e <= -32 := gamma
15227 //
15228 // In order to convert the fractional part
15229 //
15230 //      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
15231 //
15232 // into decimal form, the fraction is repeatedly multiplied by 10 and the digits
15233 // d[-i] are extracted in order:
15234 //
15235 //      (10 * p2) div 2^-e = d[-1]
15236 //      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
15237 //
15238 // The multiplication by 10 must not overflow. It is sufficient to choose
15239 //
15240 //      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
15241 //
15242 // Since p2 = f mod 2^-e < 2^-e,
15243 //
15244 //      -e <= 60   or   e >= -60 := alpha
15245
15246 constexpr int kAlpha = -60;
15247 constexpr int kGamma = -32;
15248
15249 struct cached_power // c = f * 2^e ~= 10^k
15250 {
15251     std::uint64_t f;
15252     int e;
15253     int k;
15254 };
15255
15256 /*!
15257 For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
15258 power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
15259 satisfies (Definition 3.2 from [1])
15260
15261      alpha <= e_c + e + q <= gamma.
15262 */
15263 inline cached_power get_cached_power_for_binary_exponent(int e)
15264 {
15265     // Now
15266     //
15267     //      alpha <= e_c + e + q <= gamma                                    (1)
15268     //      ==> f_c * 2^alpha <= c * 2^e * 2^q
15269     //
15270     // and since the c's are normalized, 2^(q-1) <= f_c,
15271     //
15272     //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
15273     //      ==> 2^(alpha - e - 1) <= c
15274     //
15275     // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
15276     //
15277     //      k = ceil( log_10( 2^(alpha - e - 1) ) )
15278     //        = ceil( (alpha - e - 1) * log_10(2) )
15279     //
15280     // From the paper:
15281     // "In theory the result of the procedure could be wrong since c is rounded,
15282     //  and the computation itself is approximated [...]. In practice, however,
15283     //  this simple function is sufficient."
15284     //
15285     // For IEEE double precision floating-point numbers converted into
15286     // normalized diyfp's w = f * 2^e, with q = 64,
15287     //
15288     //      e >= -1022      (min IEEE exponent)
15289     //           -52        (p - 1)
15290     //           -52        (p - 1, possibly normalize denormal IEEE numbers)
15291     //           -11        (normalize the diyfp)
15292     //         = -1137
15293     //
15294     // and
15295     //
15296     //      e <= +1023      (max IEEE exponent)
15297     //           -52        (p - 1)
15298     //           -11        (normalize the diyfp)
15299     //         = 960
15300     //
15301     // This binary exponent range [-1137,960] results in a decimal exponent
15302     // range [-307,324]. One does not need to store a cached power for each
15303     // k in this range. For each such k it suffices to find a cached power
15304     // such that the exponent of the product lies in [alpha,gamma].
15305     // This implies that the difference of the decimal exponents of adjacent
15306     // table entries must be less than or equal to
15307     //
15308     //      floor( (gamma - alpha) * log_10(2) ) = 8.
15309     //
15310     // (A smaller distance gamma-alpha would require a larger table.)
15311
15312     // NB:
15313     // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
15314
15315     constexpr int kCachedPowersMinDecExp = -300;
15316     constexpr int kCachedPowersDecStep = 8;
15317
15318     static constexpr std::array<cached_power, 79> kCachedPowers =
15319     {
15320         {
15321             { 0xAB70FE17C79AC6CA, -1060, -300 },
15322             { 0xFF77B1FCBEBCDC4F, -1034, -292 },
15323             { 0xBE5691EF416BD60C, -1007, -284 },
15324             { 0x8DD01FAD907FFC3C,  -980, -276 },
15325             { 0xD3515C2831559A83,  -954, -268 },
15326             { 0x9D71AC8FADA6C9B5,  -927, -260 },
15327             { 0xEA9C227723EE8BCB,  -901, -252 },
15328             { 0xAECC49914078536D,  -874, -244 },
15329             { 0x823C12795DB6CE57,  -847, -236 },
15330             { 0xC21094364DFB5637,  -821, -228 },
15331             { 0x9096EA6F3848984F,  -794, -220 },
15332             { 0xD77485CB25823AC7,  -768, -212 },
15333             { 0xA086CFCD97BF97F4,  -741, -204 },
15334             { 0xEF340A98172AACE5,  -715, -196 },
15335             { 0xB23867FB2A35B28E,  -688, -188 },
15336             { 0x84C8D4DFD2C63F3B,  -661, -180 },
15337             { 0xC5DD44271AD3CDBA,  -635, -172 },
15338             { 0x936B9FCEBB25C996,  -608, -164 },
15339             { 0xDBAC6C247D62A584,  -582, -156 },
15340             { 0xA3AB66580D5FDAF6,  -555, -148 },
15341             { 0xF3E2F893DEC3F126,  -529, -140 },
15342             { 0xB5B5ADA8AAFF80B8,  -502, -132 },
15343             { 0x87625F056C7C4A8B,  -475, -124 },
15344             { 0xC9BCFF6034C13053,  -449, -116 },
15345             { 0x964E858C91BA2655,  -422, -108 },
15346             { 0xDFF9772470297EBD,  -396, -100 },
15347             { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
15348             { 0xF8A95FCF88747D94,  -343,  -84 },
15349             { 0xB94470938FA89BCF,  -316,  -76 },
15350             { 0x8A08F0F8BF0F156B,  -289,  -68 },
15351             { 0xCDB02555653131B6,  -263,  -60 },
15352             { 0x993FE2C6D07B7FAC,  -236,  -52 },
15353             { 0xE45C10C42A2B3B06,  -210,  -44 },
15354             { 0xAA242499697392D3,  -183,  -36 },
15355             { 0xFD87B5F28300CA0E,  -157,  -28 },
15356             { 0xBCE5086492111AEB,  -130,  -20 },
15357             { 0x8CBCCC096F5088CC,  -103,  -12 },
15358             { 0xD1B71758E219652C,   -77,   -4 },
15359             { 0x9C40000000000000,   -50,    4 },
15360             { 0xE8D4A51000000000,   -24,   12 },
15361             { 0xAD78EBC5AC620000,     3,   20 },
15362             { 0x813F3978F8940984,    30,   28 },
15363             { 0xC097CE7BC90715B3,    56,   36 },
15364             { 0x8F7E32CE7BEA5C70,    83,   44 },
15365             { 0xD5D238A4ABE98068,   109,   52 },
15366             { 0x9F4F2726179A2245,   136,   60 },
15367             { 0xED63A231D4C4FB27,   162,   68 },
15368             { 0xB0DE65388CC8ADA8,   189,   76 },
15369             { 0x83C7088E1AAB65DB,   216,   84 },
15370             { 0xC45D1DF942711D9A,   242,   92 },
15371             { 0x924D692CA61BE758,   269,  100 },
15372             { 0xDA01EE641A708DEA,   295,  108 },
15373             { 0xA26DA3999AEF774A,   322,  116 },
15374             { 0xF209787BB47D6B85,   348,  124 },
15375             { 0xB454E4A179DD1877,   375,  132 },
15376             { 0x865B86925B9BC5C2,   402,  140 },
15377             { 0xC83553C5C8965D3D,   428,  148 },
15378             { 0x952AB45CFA97A0B3,   455,  156 },
15379             { 0xDE469FBD99A05FE3,   481,  164 },
15380             { 0xA59BC234DB398C25,   508,  172 },
15381             { 0xF6C69A72A3989F5C,   534,  180 },
15382             { 0xB7DCBF5354E9BECE,   561,  188 },
15383             { 0x88FCF317F22241E2,   588,  196 },
15384             { 0xCC20CE9BD35C78A5,   614,  204 },
15385             { 0x98165AF37B2153DF,   641,  212 },
15386             { 0xE2A0B5DC971F303A,   667,  220 },
15387             { 0xA8D9D1535CE3B396,   694,  228 },
15388             { 0xFB9B7CD9A4A7443C,   720,  236 },
15389             { 0xBB764C4CA7A44410,   747,  244 },
15390             { 0x8BAB8EEFB6409C1A,   774,  252 },
15391             { 0xD01FEF10A657842C,   800,  260 },
15392             { 0x9B10A4E5E9913129,   827,  268 },
15393             { 0xE7109BFBA19C0C9D,   853,  276 },
15394             { 0xAC2820D9623BF429,   880,  284 },
15395             { 0x80444B5E7AA7CF85,   907,  292 },
15396             { 0xBF21E44003ACDD2D,   933,  300 },
15397             { 0x8E679C2F5E44FF8F,   960,  308 },
15398             { 0xD433179D9C8CB841,   986,  316 },
15399             { 0x9E19DB92B4E31BA9,  1013,  324 },
15400         }
15401     };
15402
15403     // This computation gives exactly the same results for k as
15404     //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
15405     // for |e| <= 1500, but doesn't require floating-point operations.
15406     // NB: log_10(2) ~= 78913 / 2^18
15407     JSON_ASSERT(e >= -1500);
15408     JSON_ASSERT(e <=  1500);
15409     const int f = kAlpha - e - 1;
15410     const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
15411
15412     const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
15413     JSON_ASSERT(index >= 0);
15414     JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
15415
15416     const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
15417     JSON_ASSERT(kAlpha <= cached.e + e + 64);
15418     JSON_ASSERT(kGamma >= cached.e + e + 64);
15419
15420     return cached;
15421 }
15422
15423 /*!
15424 For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
15425 For n == 0, returns 1 and sets pow10 := 1.
15426 */
15427 inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
15428 {
15429     // LCOV_EXCL_START
15430     if (n >= 1000000000)
15431     {
15432         pow10 = 1000000000;
15433         return 10;
15434     }
15435     // LCOV_EXCL_STOP
15436     if (n >= 100000000)
15437     {
15438         pow10 = 100000000;
15439         return  9;
15440     }
15441     if (n >= 10000000)
15442     {
15443         pow10 = 10000000;
15444         return  8;
15445     }
15446     if (n >= 1000000)
15447     {
15448         pow10 = 1000000;
15449         return  7;
15450     }
15451     if (n >= 100000)
15452     {
15453         pow10 = 100000;
15454         return  6;
15455     }
15456     if (n >= 10000)
15457     {
15458         pow10 = 10000;
15459         return  5;
15460     }
15461     if (n >= 1000)
15462     {
15463         pow10 = 1000;
15464         return  4;
15465     }
15466     if (n >= 100)
15467     {
15468         pow10 = 100;
15469         return  3;
15470     }
15471     if (n >= 10)
15472     {
15473         pow10 = 10;
15474         return  2;
15475     }
15476
15477     pow10 = 1;
15478     return 1;
15479 }
15480
15481 inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
15482                          std::uint64_t rest, std::uint64_t ten_k)
15483 {
15484     JSON_ASSERT(len >= 1);
15485     JSON_ASSERT(dist <= delta);
15486     JSON_ASSERT(rest <= delta);
15487     JSON_ASSERT(ten_k > 0);
15488
15489     //               <--------------------------- delta ---->
15490     //                                  <---- dist --------->
15491     // --------------[------------------+-------------------]--------------
15492     //               M-                 w                   M+
15493     //
15494     //                                  ten_k
15495     //                                <------>
15496     //                                       <---- rest ---->
15497     // --------------[------------------+----+--------------]--------------
15498     //                                  w    V
15499     //                                       = buf * 10^k
15500     //
15501     // ten_k represents a unit-in-the-last-place in the decimal representation
15502     // stored in buf.
15503     // Decrement buf by ten_k while this takes buf closer to w.
15504
15505     // The tests are written in this order to avoid overflow in unsigned
15506     // integer arithmetic.
15507
15508     while (rest < dist
15509             && delta - rest >= ten_k
15510             && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
15511     {
15512         JSON_ASSERT(buf[len - 1] != '0');
15513         buf[len - 1]--;
15514         rest += ten_k;
15515     }
15516 }
15517
15518 /*!
15519 Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
15520 M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
15521 */
15522 inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
15523                              diyfp M_minus, diyfp w, diyfp M_plus)
15524 {
15525     static_assert(kAlpha >= -60, "internal error");
15526     static_assert(kGamma <= -32, "internal error");
15527
15528     // Generates the digits (and the exponent) of a decimal floating-point
15529     // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
15530     // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
15531     //
15532     //               <--------------------------- delta ---->
15533     //                                  <---- dist --------->
15534     // --------------[------------------+-------------------]--------------
15535     //               M-                 w                   M+
15536     //
15537     // Grisu2 generates the digits of M+ from left to right and stops as soon as
15538     // V is in [M-,M+].
15539
15540     JSON_ASSERT(M_plus.e >= kAlpha);
15541     JSON_ASSERT(M_plus.e <= kGamma);
15542
15543     std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
15544     std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
15545
15546     // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
15547     //
15548     //      M+ = f * 2^e
15549     //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
15550     //         = ((p1        ) * 2^-e + (p2        )) * 2^e
15551     //         = p1 + p2 * 2^e
15552
15553     const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
15554
15555     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.)
15556     std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
15557
15558     // 1)
15559     //
15560     // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
15561
15562     JSON_ASSERT(p1 > 0);
15563
15564     std::uint32_t pow10{};
15565     const int k = find_largest_pow10(p1, pow10);
15566
15567     //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
15568     //
15569     //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
15570     //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
15571     //
15572     //      M+ = p1                                             + p2 * 2^e
15573     //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
15574     //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
15575     //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
15576     //
15577     // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
15578     //
15579     //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
15580     //
15581     // but stop as soon as
15582     //
15583     //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
15584
15585     int n = k;
15586     while (n > 0)
15587     {
15588         // Invariants:
15589         //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
15590         //      pow10 = 10^(n-1) <= p1 < 10^n
15591         //
15592         const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
15593         const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
15594         //
15595         //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
15596         //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
15597         //
15598         JSON_ASSERT(d <= 9);
15599         buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
15600         //
15601         //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
15602         //
15603         p1 = r;
15604         n--;
15605         //
15606         //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
15607         //      pow10 = 10^n
15608         //
15609
15610         // Now check if enough digits have been generated.
15611         // Compute
15612         //
15613         //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
15614         //
15615         // Note:
15616         // Since rest and delta share the same exponent e, it suffices to
15617         // compare the significands.
15618         const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15619         if (rest <= delta)
15620         {
15621             // V = buffer * 10^n, with M- <= V <= M+.
15622
15623             decimal_exponent += n;
15624
15625             // We may now just stop. But instead look if the buffer could be
15626             // decremented to bring V closer to w.
15627             //
15628             // pow10 = 10^n is now 1 ulp in the decimal representation V.
15629             // The rounding procedure works with diyfp's with an implicit
15630             // exponent of e.
15631             //
15632             //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
15633             //
15634             const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15635             grisu2_round(buffer, length, dist, delta, rest, ten_n);
15636
15637             return;
15638         }
15639
15640         pow10 /= 10;
15641         //
15642         //      pow10 = 10^(n-1) <= p1 < 10^n
15643         // Invariants restored.
15644     }
15645
15646     // 2)
15647     //
15648     // The digits of the integral part have been generated:
15649     //
15650     //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
15651     //         = buffer            + p2 * 2^e
15652     //
15653     // Now generate the digits of the fractional part p2 * 2^e.
15654     //
15655     // Note:
15656     // No decimal point is generated: the exponent is adjusted instead.
15657     //
15658     // p2 actually represents the fraction
15659     //
15660     //      p2 * 2^e
15661     //          = p2 / 2^-e
15662     //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
15663     //
15664     // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
15665     //
15666     //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
15667     //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
15668     //
15669     // using
15670     //
15671     //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
15672     //                = (                   d) * 2^-e + (                   r)
15673     //
15674     // or
15675     //      10^m * p2 * 2^e = d + r * 2^e
15676     //
15677     // i.e.
15678     //
15679     //      M+ = buffer + p2 * 2^e
15680     //         = buffer + 10^-m * (d + r * 2^e)
15681     //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
15682     //
15683     // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
15684
15685     JSON_ASSERT(p2 > delta);
15686
15687     int m = 0;
15688     for (;;)
15689     {
15690         // Invariant:
15691         //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
15692         //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
15693         //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
15694         //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
15695         //
15696         JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15697         p2 *= 10;
15698         const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
15699         const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
15700         //
15701         //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
15702         //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
15703         //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
15704         //
15705         JSON_ASSERT(d <= 9);
15706         buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
15707         //
15708         //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
15709         //
15710         p2 = r;
15711         m++;
15712         //
15713         //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
15714         // Invariant restored.
15715
15716         // Check if enough digits have been generated.
15717         //
15718         //      10^-m * p2 * 2^e <= delta * 2^e
15719         //              p2 * 2^e <= 10^m * delta * 2^e
15720         //                    p2 <= 10^m * delta
15721         delta *= 10;
15722         dist  *= 10;
15723         if (p2 <= delta)
15724         {
15725             break;
15726         }
15727     }
15728
15729     // V = buffer * 10^-m, with M- <= V <= M+.
15730
15731     decimal_exponent -= m;
15732
15733     // 1 ulp in the decimal representation is now 10^-m.
15734     // Since delta and dist are now scaled by 10^m, we need to do the
15735     // same with ulp in order to keep the units in sync.
15736     //
15737     //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
15738     //
15739     const std::uint64_t ten_m = one.f;
15740     grisu2_round(buffer, length, dist, delta, p2, ten_m);
15741
15742     // By construction this algorithm generates the shortest possible decimal
15743     // number (Loitsch, Theorem 6.2) which rounds back to w.
15744     // For an input number of precision p, at least
15745     //
15746     //      N = 1 + ceil(p * log_10(2))
15747     //
15748     // decimal digits are sufficient to identify all binary floating-point
15749     // numbers (Matula, "In-and-Out conversions").
15750     // This implies that the algorithm does not produce more than N decimal
15751     // digits.
15752     //
15753     //      N = 17 for p = 53 (IEEE double precision)
15754     //      N = 9  for p = 24 (IEEE single precision)
15755 }
15756
15757 /*!
15758 v = buf * 10^decimal_exponent
15759 len is the length of the buffer (number of decimal digits)
15760 The buffer must be large enough, i.e. >= max_digits10.
15761 */
15762 JSON_HEDLEY_NON_NULL(1)
15763 inline void grisu2(char* buf, int& len, int& decimal_exponent,
15764                    diyfp m_minus, diyfp v, diyfp m_plus)
15765 {
15766     JSON_ASSERT(m_plus.e == m_minus.e);
15767     JSON_ASSERT(m_plus.e == v.e);
15768
15769     //  --------(-----------------------+-----------------------)--------    (A)
15770     //          m-                      v                       m+
15771     //
15772     //  --------------------(-----------+-----------------------)--------    (B)
15773     //                      m-          v                       m+
15774     //
15775     // First scale v (and m- and m+) such that the exponent is in the range
15776     // [alpha, gamma].
15777
15778     const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
15779
15780     const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
15781
15782     // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
15783     const diyfp w       = diyfp::mul(v,       c_minus_k);
15784     const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
15785     const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
15786
15787     //  ----(---+---)---------------(---+---)---------------(---+---)----
15788     //          w-                      w                       w+
15789     //          = c*m-                  = c*v                   = c*m+
15790     //
15791     // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
15792     // w+ are now off by a small amount.
15793     // In fact:
15794     //
15795     //      w - v * 10^k < 1 ulp
15796     //
15797     // To account for this inaccuracy, add resp. subtract 1 ulp.
15798     //
15799     //  --------+---[---------------(---+---)---------------]---+--------
15800     //          w-  M-                  w                   M+  w+
15801     //
15802     // Now any number in [M-, M+] (bounds included) will round to w when input,
15803     // regardless of how the input rounding algorithm breaks ties.
15804     //
15805     // And digit_gen generates the shortest possible such number in [M-, M+].
15806     // Note that this does not mean that Grisu2 always generates the shortest
15807     // possible number in the interval (m-, m+).
15808     const diyfp M_minus(w_minus.f + 1, w_minus.e);
15809     const diyfp M_plus (w_plus.f  - 1, w_plus.e );
15810
15811     decimal_exponent = -cached.k; // = -(-k) = k
15812
15813     grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
15814 }
15815
15816 /*!
15817 v = buf * 10^decimal_exponent
15818 len is the length of the buffer (number of decimal digits)
15819 The buffer must be large enough, i.e. >= max_digits10.
15820 */
15821 template<typename FloatType>
15822 JSON_HEDLEY_NON_NULL(1)
15823 void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
15824 {
15825     static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
15826                   "internal error: not enough precision");
15827
15828     JSON_ASSERT(std::isfinite(value));
15829     JSON_ASSERT(value > 0);
15830
15831     // If the neighbors (and boundaries) of 'value' are always computed for double-precision
15832     // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
15833     // decimal representations are not exactly "short".
15834     //
15835     // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
15836     // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
15837     // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
15838     // does.
15839     // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
15840     // representation using the corresponding std::from_chars function recovers value exactly". That
15841     // indicates that single precision floating-point numbers should be recovered using
15842     // 'std::strtof'.
15843     //
15844     // NB: If the neighbors are computed for single-precision numbers, there is a single float
15845     //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
15846     //     value is off by 1 ulp.
15847 #if 0
15848     const boundaries w = compute_boundaries(static_cast<double>(value));
15849 #else
15850     const boundaries w = compute_boundaries(value);
15851 #endif
15852
15853     grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
15854 }
15855
15856 /*!
15857 @brief appends a decimal representation of e to buf
15858 @return a pointer to the element following the exponent.
15859 @pre -1000 < e < 1000
15860 */
15861 JSON_HEDLEY_NON_NULL(1)
15862 JSON_HEDLEY_RETURNS_NON_NULL
15863 inline char* append_exponent(char* buf, int e)
15864 {
15865     JSON_ASSERT(e > -1000);
15866     JSON_ASSERT(e <  1000);
15867
15868     if (e < 0)
15869     {
15870         e = -e;
15871         *buf++ = '-';
15872     }
15873     else
15874     {
15875         *buf++ = '+';
15876     }
15877
15878     auto k = static_cast<std::uint32_t>(e);
15879     if (k < 10)
15880     {
15881         // Always print at least two digits in the exponent.
15882         // This is for compatibility with printf("%g").
15883         *buf++ = '0';
15884         *buf++ = static_cast<char>('0' + k);
15885     }
15886     else if (k < 100)
15887     {
15888         *buf++ = static_cast<char>('0' + k / 10);
15889         k %= 10;
15890         *buf++ = static_cast<char>('0' + k);
15891     }
15892     else
15893     {
15894         *buf++ = static_cast<char>('0' + k / 100);
15895         k %= 100;
15896         *buf++ = static_cast<char>('0' + k / 10);
15897         k %= 10;
15898         *buf++ = static_cast<char>('0' + k);
15899     }
15900
15901     return buf;
15902 }
15903
15904 /*!
15905 @brief prettify v = buf * 10^decimal_exponent
15906
15907 If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
15908 notation. Otherwise it will be printed in exponential notation.
15909
15910 @pre min_exp < 0
15911 @pre max_exp > 0
15912 */
15913 JSON_HEDLEY_NON_NULL(1)
15914 JSON_HEDLEY_RETURNS_NON_NULL
15915 inline char* format_buffer(char* buf, int len, int decimal_exponent,
15916                            int min_exp, int max_exp)
15917 {
15918     JSON_ASSERT(min_exp < 0);
15919     JSON_ASSERT(max_exp > 0);
15920
15921     const int k = len;
15922     const int n = len + decimal_exponent;
15923
15924     // v = buf * 10^(n-k)
15925     // k is the length of the buffer (number of decimal digits)
15926     // n is the position of the decimal point relative to the start of the buffer.
15927
15928     if (k <= n && n <= max_exp)
15929     {
15930         // digits[000]
15931         // len <= max_exp + 2
15932
15933         std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
15934         // Make it look like a floating-point number (#362, #378)
15935         buf[n + 0] = '.';
15936         buf[n + 1] = '0';
15937         return buf + (static_cast<size_t>(n) + 2);
15938     }
15939
15940     if (0 < n && n <= max_exp)
15941     {
15942         // dig.its
15943         // len <= max_digits10 + 1
15944
15945         JSON_ASSERT(k > n);
15946
15947         std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
15948         buf[n] = '.';
15949         return buf + (static_cast<size_t>(k) + 1U);
15950     }
15951
15952     if (min_exp < n && n <= 0)
15953     {
15954         // 0.[000]digits
15955         // len <= 2 + (-min_exp - 1) + max_digits10
15956
15957         std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
15958         buf[0] = '0';
15959         buf[1] = '.';
15960         std::memset(buf + 2, '0', static_cast<size_t>(-n));
15961         return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
15962     }
15963
15964     if (k == 1)
15965     {
15966         // dE+123
15967         // len <= 1 + 5
15968
15969         buf += 1;
15970     }
15971     else
15972     {
15973         // d.igitsE+123
15974         // len <= max_digits10 + 1 + 5
15975
15976         std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
15977         buf[1] = '.';
15978         buf += 1 + static_cast<size_t>(k);
15979     }
15980
15981     *buf++ = 'e';
15982     return append_exponent(buf, n - 1);
15983 }
15984
15985 } // namespace dtoa_impl
15986
15987 /*!
15988 @brief generates a decimal representation of the floating-point number value in [first, last).
15989
15990 The format of the resulting decimal representation is similar to printf's %g
15991 format. Returns an iterator pointing past-the-end of the decimal representation.
15992
15993 @note The input number must be finite, i.e. NaN's and Inf's are not supported.
15994 @note The buffer must be large enough.
15995 @note The result is NOT null-terminated.
15996 */
15997 template<typename FloatType>
15998 JSON_HEDLEY_NON_NULL(1, 2)
15999 JSON_HEDLEY_RETURNS_NON_NULL
16000 char* to_chars(char* first, const char* last, FloatType value)
16001 {
16002     static_cast<void>(last); // maybe unused - fix warning
16003     JSON_ASSERT(std::isfinite(value));
16004
16005     // Use signbit(value) instead of (value < 0) since signbit works for -0.
16006     if (std::signbit(value))
16007     {
16008         value = -value;
16009         *first++ = '-';
16010     }
16011
16012 #ifdef __GNUC__
16013 #pragma GCC diagnostic push
16014 #pragma GCC diagnostic ignored "-Wfloat-equal"
16015 #endif
16016     if (value == 0) // +-0
16017     {
16018         *first++ = '0';
16019         // Make it look like a floating-point number (#362, #378)
16020         *first++ = '.';
16021         *first++ = '0';
16022         return first;
16023     }
16024 #ifdef __GNUC__
16025 #pragma GCC diagnostic pop
16026 #endif
16027
16028     JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
16029
16030     // Compute v = buffer * 10^decimal_exponent.
16031     // The decimal digits are stored in the buffer, which needs to be interpreted
16032     // as an unsigned decimal integer.
16033     // len is the length of the buffer, i.e. the number of decimal digits.
16034     int len = 0;
16035     int decimal_exponent = 0;
16036     dtoa_impl::grisu2(first, len, decimal_exponent, value);
16037
16038     JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
16039
16040     // Format the buffer like printf("%.*g", prec, value)
16041     constexpr int kMinExp = -4;
16042     // Use digits10 here to increase compatibility with version 2.
16043     constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
16044
16045     JSON_ASSERT(last - first >= kMaxExp + 2);
16046     JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
16047     JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
16048
16049     return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
16050 }
16051
16052 } // namespace detail
16053 } // namespace nlohmann
16054
16055 // #include <nlohmann/detail/exceptions.hpp>
16056
16057 // #include <nlohmann/detail/macro_scope.hpp>
16058
16059 // #include <nlohmann/detail/meta/cpp_future.hpp>
16060
16061 // #include <nlohmann/detail/output/binary_writer.hpp>
16062
16063 // #include <nlohmann/detail/output/output_adapters.hpp>
16064
16065 // #include <nlohmann/detail/value_t.hpp>
16066
16067
16068 namespace nlohmann
16069 {
16070 namespace detail
16071 {
16072 ///////////////////
16073 // serialization //
16074 ///////////////////
16075
16076 /// how to treat decoding errors
16077 enum class error_handler_t
16078 {
16079     strict,  ///< throw a type_error exception in case of invalid UTF-8
16080     replace, ///< replace invalid UTF-8 sequences with U+FFFD
16081     ignore   ///< ignore invalid UTF-8 sequences
16082 };
16083
16084 template<typename BasicJsonType>
16085 class serializer
16086 {
16087     using string_t = typename BasicJsonType::string_t;
16088     using number_float_t = typename BasicJsonType::number_float_t;
16089     using number_integer_t = typename BasicJsonType::number_integer_t;
16090     using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
16091     using binary_char_t = typename BasicJsonType::binary_t::value_type;
16092     static constexpr std::uint8_t UTF8_ACCEPT = 0;
16093     static constexpr std::uint8_t UTF8_REJECT = 1;
16094
16095   public:
16096     /*!
16097     @param[in] s  output stream to serialize to
16098     @param[in] ichar  indentation character to use
16099     @param[in] error_handler_  how to react on decoding errors
16100     */
16101     serializer(output_adapter_t<char> s, const char ichar,
16102                error_handler_t error_handler_ = error_handler_t::strict)
16103         : o(std::move(s))
16104         , loc(std::localeconv())
16105         , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
16106         , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
16107         , indent_char(ichar)
16108         , indent_string(512, indent_char)
16109         , error_handler(error_handler_)
16110     {}
16111
16112     // delete because of pointer members
16113     serializer(const serializer&) = delete;
16114     serializer& operator=(const serializer&) = delete;
16115     serializer(serializer&&) = delete;
16116     serializer& operator=(serializer&&) = delete;
16117     ~serializer() = default;
16118
16119     /*!
16120     @brief internal implementation of the serialization function
16121
16122     This function is called by the public member function dump and organizes
16123     the serialization internally. The indentation level is propagated as
16124     additional parameter. In case of arrays and objects, the function is
16125     called recursively.
16126
16127     - strings and object keys are escaped using `escape_string()`
16128     - integer numbers are converted implicitly via `operator<<`
16129     - floating-point numbers are converted to a string using `"%g"` format
16130     - binary values are serialized as objects containing the subtype and the
16131       byte array
16132
16133     @param[in] val               value to serialize
16134     @param[in] pretty_print      whether the output shall be pretty-printed
16135     @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
16136     in the output are escaped with `\uXXXX` sequences, and the result consists
16137     of ASCII characters only.
16138     @param[in] indent_step       the indent level
16139     @param[in] current_indent    the current indent level (only used internally)
16140     */
16141     void dump(const BasicJsonType& val,
16142               const bool pretty_print,
16143               const bool ensure_ascii,
16144               const unsigned int indent_step,
16145               const unsigned int current_indent = 0)
16146     {
16147         switch (val.m_type)
16148         {
16149             case value_t::object:
16150             {
16151                 if (val.m_value.object->empty())
16152                 {
16153                     o->write_characters("{}", 2);
16154                     return;
16155                 }
16156
16157                 if (pretty_print)
16158                 {
16159                     o->write_characters("{\n", 2);
16160
16161                     // variable to hold indentation for recursive calls
16162                     const auto new_indent = current_indent + indent_step;
16163                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16164                     {
16165                         indent_string.resize(indent_string.size() * 2, ' ');
16166                     }
16167
16168                     // first n-1 elements
16169                     auto i = val.m_value.object->cbegin();
16170                     for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16171                     {
16172                         o->write_characters(indent_string.c_str(), new_indent);
16173                         o->write_character('\"');
16174                         dump_escaped(i->first, ensure_ascii);
16175                         o->write_characters("\": ", 3);
16176                         dump(i->second, true, ensure_ascii, indent_step, new_indent);
16177                         o->write_characters(",\n", 2);
16178                     }
16179
16180                     // last element
16181                     JSON_ASSERT(i != val.m_value.object->cend());
16182                     JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16183                     o->write_characters(indent_string.c_str(), new_indent);
16184                     o->write_character('\"');
16185                     dump_escaped(i->first, ensure_ascii);
16186                     o->write_characters("\": ", 3);
16187                     dump(i->second, true, ensure_ascii, indent_step, new_indent);
16188
16189                     o->write_character('\n');
16190                     o->write_characters(indent_string.c_str(), current_indent);
16191                     o->write_character('}');
16192                 }
16193                 else
16194                 {
16195                     o->write_character('{');
16196
16197                     // first n-1 elements
16198                     auto i = val.m_value.object->cbegin();
16199                     for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
16200                     {
16201                         o->write_character('\"');
16202                         dump_escaped(i->first, ensure_ascii);
16203                         o->write_characters("\":", 2);
16204                         dump(i->second, false, ensure_ascii, indent_step, current_indent);
16205                         o->write_character(',');
16206                     }
16207
16208                     // last element
16209                     JSON_ASSERT(i != val.m_value.object->cend());
16210                     JSON_ASSERT(std::next(i) == val.m_value.object->cend());
16211                     o->write_character('\"');
16212                     dump_escaped(i->first, ensure_ascii);
16213                     o->write_characters("\":", 2);
16214                     dump(i->second, false, ensure_ascii, indent_step, current_indent);
16215
16216                     o->write_character('}');
16217                 }
16218
16219                 return;
16220             }
16221
16222             case value_t::array:
16223             {
16224                 if (val.m_value.array->empty())
16225                 {
16226                     o->write_characters("[]", 2);
16227                     return;
16228                 }
16229
16230                 if (pretty_print)
16231                 {
16232                     o->write_characters("[\n", 2);
16233
16234                     // variable to hold indentation for recursive calls
16235                     const auto new_indent = current_indent + indent_step;
16236                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16237                     {
16238                         indent_string.resize(indent_string.size() * 2, ' ');
16239                     }
16240
16241                     // first n-1 elements
16242                     for (auto i = val.m_value.array->cbegin();
16243                             i != val.m_value.array->cend() - 1; ++i)
16244                     {
16245                         o->write_characters(indent_string.c_str(), new_indent);
16246                         dump(*i, true, ensure_ascii, indent_step, new_indent);
16247                         o->write_characters(",\n", 2);
16248                     }
16249
16250                     // last element
16251                     JSON_ASSERT(!val.m_value.array->empty());
16252                     o->write_characters(indent_string.c_str(), new_indent);
16253                     dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
16254
16255                     o->write_character('\n');
16256                     o->write_characters(indent_string.c_str(), current_indent);
16257                     o->write_character(']');
16258                 }
16259                 else
16260                 {
16261                     o->write_character('[');
16262
16263                     // first n-1 elements
16264                     for (auto i = val.m_value.array->cbegin();
16265                             i != val.m_value.array->cend() - 1; ++i)
16266                     {
16267                         dump(*i, false, ensure_ascii, indent_step, current_indent);
16268                         o->write_character(',');
16269                     }
16270
16271                     // last element
16272                     JSON_ASSERT(!val.m_value.array->empty());
16273                     dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
16274
16275                     o->write_character(']');
16276                 }
16277
16278                 return;
16279             }
16280
16281             case value_t::string:
16282             {
16283                 o->write_character('\"');
16284                 dump_escaped(*val.m_value.string, ensure_ascii);
16285                 o->write_character('\"');
16286                 return;
16287             }
16288
16289             case value_t::binary:
16290             {
16291                 if (pretty_print)
16292                 {
16293                     o->write_characters("{\n", 2);
16294
16295                     // variable to hold indentation for recursive calls
16296                     const auto new_indent = current_indent + indent_step;
16297                     if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
16298                     {
16299                         indent_string.resize(indent_string.size() * 2, ' ');
16300                     }
16301
16302                     o->write_characters(indent_string.c_str(), new_indent);
16303
16304                     o->write_characters("\"bytes\": [", 10);
16305
16306                     if (!val.m_value.binary->empty())
16307                     {
16308                         for (auto i = val.m_value.binary->cbegin();
16309                                 i != val.m_value.binary->cend() - 1; ++i)
16310                         {
16311                             dump_integer(*i);
16312                             o->write_characters(", ", 2);
16313                         }
16314                         dump_integer(val.m_value.binary->back());
16315                     }
16316
16317                     o->write_characters("],\n", 3);
16318                     o->write_characters(indent_string.c_str(), new_indent);
16319
16320                     o->write_characters("\"subtype\": ", 11);
16321                     if (val.m_value.binary->has_subtype())
16322                     {
16323                         dump_integer(val.m_value.binary->subtype());
16324                     }
16325                     else
16326                     {
16327                         o->write_characters("null", 4);
16328                     }
16329                     o->write_character('\n');
16330                     o->write_characters(indent_string.c_str(), current_indent);
16331                     o->write_character('}');
16332                 }
16333                 else
16334                 {
16335                     o->write_characters("{\"bytes\":[", 10);
16336
16337                     if (!val.m_value.binary->empty())
16338                     {
16339                         for (auto i = val.m_value.binary->cbegin();
16340                                 i != val.m_value.binary->cend() - 1; ++i)
16341                         {
16342                             dump_integer(*i);
16343                             o->write_character(',');
16344                         }
16345                         dump_integer(val.m_value.binary->back());
16346                     }
16347
16348                     o->write_characters("],\"subtype\":", 12);
16349                     if (val.m_value.binary->has_subtype())
16350                     {
16351                         dump_integer(val.m_value.binary->subtype());
16352                         o->write_character('}');
16353                     }
16354                     else
16355                     {
16356                         o->write_characters("null}", 5);
16357                     }
16358                 }
16359                 return;
16360             }
16361
16362             case value_t::boolean:
16363             {
16364                 if (val.m_value.boolean)
16365                 {
16366                     o->write_characters("true", 4);
16367                 }
16368                 else
16369                 {
16370                     o->write_characters("false", 5);
16371                 }
16372                 return;
16373             }
16374
16375             case value_t::number_integer:
16376             {
16377                 dump_integer(val.m_value.number_integer);
16378                 return;
16379             }
16380
16381             case value_t::number_unsigned:
16382             {
16383                 dump_integer(val.m_value.number_unsigned);
16384                 return;
16385             }
16386
16387             case value_t::number_float:
16388             {
16389                 dump_float(val.m_value.number_float);
16390                 return;
16391             }
16392
16393             case value_t::discarded:
16394             {
16395                 o->write_characters("<discarded>", 11);
16396                 return;
16397             }
16398
16399             case value_t::null:
16400             {
16401                 o->write_characters("null", 4);
16402                 return;
16403             }
16404
16405             default:            // LCOV_EXCL_LINE
16406                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16407         }
16408     }
16409
16410   JSON_PRIVATE_UNLESS_TESTED:
16411     /*!
16412     @brief dump escaped string
16413
16414     Escape a string by replacing certain special characters by a sequence of an
16415     escape character (backslash) and another character and other control
16416     characters by a sequence of "\u" followed by a four-digit hex
16417     representation. The escaped string is written to output stream @a o.
16418
16419     @param[in] s  the string to escape
16420     @param[in] ensure_ascii  whether to escape non-ASCII characters with
16421                              \uXXXX sequences
16422
16423     @complexity Linear in the length of string @a s.
16424     */
16425     void dump_escaped(const string_t& s, const bool ensure_ascii)
16426     {
16427         std::uint32_t codepoint{};
16428         std::uint8_t state = UTF8_ACCEPT;
16429         std::size_t bytes = 0;  // number of bytes written to string_buffer
16430
16431         // number of bytes written at the point of the last valid byte
16432         std::size_t bytes_after_last_accept = 0;
16433         std::size_t undumped_chars = 0;
16434
16435         for (std::size_t i = 0; i < s.size(); ++i)
16436         {
16437             const auto byte = static_cast<std::uint8_t>(s[i]);
16438
16439             switch (decode(state, codepoint, byte))
16440             {
16441                 case UTF8_ACCEPT:  // decode found a new code point
16442                 {
16443                     switch (codepoint)
16444                     {
16445                         case 0x08: // backspace
16446                         {
16447                             string_buffer[bytes++] = '\\';
16448                             string_buffer[bytes++] = 'b';
16449                             break;
16450                         }
16451
16452                         case 0x09: // horizontal tab
16453                         {
16454                             string_buffer[bytes++] = '\\';
16455                             string_buffer[bytes++] = 't';
16456                             break;
16457                         }
16458
16459                         case 0x0A: // newline
16460                         {
16461                             string_buffer[bytes++] = '\\';
16462                             string_buffer[bytes++] = 'n';
16463                             break;
16464                         }
16465
16466                         case 0x0C: // formfeed
16467                         {
16468                             string_buffer[bytes++] = '\\';
16469                             string_buffer[bytes++] = 'f';
16470                             break;
16471                         }
16472
16473                         case 0x0D: // carriage return
16474                         {
16475                             string_buffer[bytes++] = '\\';
16476                             string_buffer[bytes++] = 'r';
16477                             break;
16478                         }
16479
16480                         case 0x22: // quotation mark
16481                         {
16482                             string_buffer[bytes++] = '\\';
16483                             string_buffer[bytes++] = '\"';
16484                             break;
16485                         }
16486
16487                         case 0x5C: // reverse solidus
16488                         {
16489                             string_buffer[bytes++] = '\\';
16490                             string_buffer[bytes++] = '\\';
16491                             break;
16492                         }
16493
16494                         default:
16495                         {
16496                             // escape control characters (0x00..0x1F) or, if
16497                             // ensure_ascii parameter is used, non-ASCII characters
16498                             if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
16499                             {
16500                                 if (codepoint <= 0xFFFF)
16501                                 {
16502                                     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16503                                     static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
16504                                                                       static_cast<std::uint16_t>(codepoint)));
16505                                     bytes += 6;
16506                                 }
16507                                 else
16508                                 {
16509                                     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16510                                     static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
16511                                                                       static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
16512                                                                       static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
16513                                     bytes += 12;
16514                                 }
16515                             }
16516                             else
16517                             {
16518                                 // copy byte to buffer (all previous bytes
16519                                 // been copied have in default case above)
16520                                 string_buffer[bytes++] = s[i];
16521                             }
16522                             break;
16523                         }
16524                     }
16525
16526                     // write buffer and reset index; there must be 13 bytes
16527                     // left, as this is the maximal number of bytes to be
16528                     // written ("\uxxxx\uxxxx\0") for one code point
16529                     if (string_buffer.size() - bytes < 13)
16530                     {
16531                         o->write_characters(string_buffer.data(), bytes);
16532                         bytes = 0;
16533                     }
16534
16535                     // remember the byte position of this accept
16536                     bytes_after_last_accept = bytes;
16537                     undumped_chars = 0;
16538                     break;
16539                 }
16540
16541                 case UTF8_REJECT:  // decode found invalid UTF-8 byte
16542                 {
16543                     switch (error_handler)
16544                     {
16545                         case error_handler_t::strict:
16546                         {
16547                             std::stringstream ss;
16548                             ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (byte | 0);
16549                             JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str(), BasicJsonType()));
16550                         }
16551
16552                         case error_handler_t::ignore:
16553                         case error_handler_t::replace:
16554                         {
16555                             // in case we saw this character the first time, we
16556                             // would like to read it again, because the byte
16557                             // may be OK for itself, but just not OK for the
16558                             // previous sequence
16559                             if (undumped_chars > 0)
16560                             {
16561                                 --i;
16562                             }
16563
16564                             // reset length buffer to the last accepted index;
16565                             // thus removing/ignoring the invalid characters
16566                             bytes = bytes_after_last_accept;
16567
16568                             if (error_handler == error_handler_t::replace)
16569                             {
16570                                 // add a replacement character
16571                                 if (ensure_ascii)
16572                                 {
16573                                     string_buffer[bytes++] = '\\';
16574                                     string_buffer[bytes++] = 'u';
16575                                     string_buffer[bytes++] = 'f';
16576                                     string_buffer[bytes++] = 'f';
16577                                     string_buffer[bytes++] = 'f';
16578                                     string_buffer[bytes++] = 'd';
16579                                 }
16580                                 else
16581                                 {
16582                                     string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
16583                                     string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
16584                                     string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
16585                                 }
16586
16587                                 // write buffer and reset index; there must be 13 bytes
16588                                 // left, as this is the maximal number of bytes to be
16589                                 // written ("\uxxxx\uxxxx\0") for one code point
16590                                 if (string_buffer.size() - bytes < 13)
16591                                 {
16592                                     o->write_characters(string_buffer.data(), bytes);
16593                                     bytes = 0;
16594                                 }
16595
16596                                 bytes_after_last_accept = bytes;
16597                             }
16598
16599                             undumped_chars = 0;
16600
16601                             // continue processing the string
16602                             state = UTF8_ACCEPT;
16603                             break;
16604                         }
16605
16606                         default:            // LCOV_EXCL_LINE
16607                             JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16608                     }
16609                     break;
16610                 }
16611
16612                 default:  // decode found yet incomplete multi-byte code point
16613                 {
16614                     if (!ensure_ascii)
16615                     {
16616                         // code point will not be escaped - copy byte to buffer
16617                         string_buffer[bytes++] = s[i];
16618                     }
16619                     ++undumped_chars;
16620                     break;
16621                 }
16622             }
16623         }
16624
16625         // we finished processing the string
16626         if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16627         {
16628             // write buffer
16629             if (bytes > 0)
16630             {
16631                 o->write_characters(string_buffer.data(), bytes);
16632             }
16633         }
16634         else
16635         {
16636             // we finish reading, but do not accept: string was incomplete
16637             switch (error_handler)
16638             {
16639                 case error_handler_t::strict:
16640                 {
16641                     std::stringstream ss;
16642                     ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (static_cast<std::uint8_t>(s.back()) | 0);
16643                     JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str(), BasicJsonType()));
16644                 }
16645
16646                 case error_handler_t::ignore:
16647                 {
16648                     // write all accepted bytes
16649                     o->write_characters(string_buffer.data(), bytes_after_last_accept);
16650                     break;
16651                 }
16652
16653                 case error_handler_t::replace:
16654                 {
16655                     // write all accepted bytes
16656                     o->write_characters(string_buffer.data(), bytes_after_last_accept);
16657                     // add a replacement character
16658                     if (ensure_ascii)
16659                     {
16660                         o->write_characters("\\ufffd", 6);
16661                     }
16662                     else
16663                     {
16664                         o->write_characters("\xEF\xBF\xBD", 3);
16665                     }
16666                     break;
16667                 }
16668
16669                 default:            // LCOV_EXCL_LINE
16670                     JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16671             }
16672         }
16673     }
16674
16675   private:
16676     /*!
16677     @brief count digits
16678
16679     Count the number of decimal (base 10) digits for an input unsigned integer.
16680
16681     @param[in] x  unsigned integer number to count its digits
16682     @return    number of decimal digits
16683     */
16684     inline unsigned int count_digits(number_unsigned_t x) noexcept
16685     {
16686         unsigned int n_digits = 1;
16687         for (;;)
16688         {
16689             if (x < 10)
16690             {
16691                 return n_digits;
16692             }
16693             if (x < 100)
16694             {
16695                 return n_digits + 1;
16696             }
16697             if (x < 1000)
16698             {
16699                 return n_digits + 2;
16700             }
16701             if (x < 10000)
16702             {
16703                 return n_digits + 3;
16704             }
16705             x = x / 10000u;
16706             n_digits += 4;
16707         }
16708     }
16709
16710     // templates to avoid warnings about useless casts
16711     template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
16712     bool is_negative_number(NumberType x)
16713     {
16714         return x < 0;
16715     }
16716
16717     template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
16718     bool is_negative_number(NumberType /*unused*/)
16719     {
16720         return false;
16721     }
16722
16723     /*!
16724     @brief dump an integer
16725
16726     Dump a given integer to output stream @a o. Works internally with
16727     @a number_buffer.
16728
16729     @param[in] x  integer number (signed or unsigned) to dump
16730     @tparam NumberType either @a number_integer_t or @a number_unsigned_t
16731     */
16732     template < typename NumberType, detail::enable_if_t <
16733                    std::is_integral<NumberType>::value ||
16734                    std::is_same<NumberType, number_unsigned_t>::value ||
16735                    std::is_same<NumberType, number_integer_t>::value ||
16736                    std::is_same<NumberType, binary_char_t>::value,
16737                    int > = 0 >
16738     void dump_integer(NumberType x)
16739     {
16740         static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16741         {
16742             {
16743                 {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
16744                 {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
16745                 {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
16746                 {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
16747                 {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
16748                 {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
16749                 {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
16750                 {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
16751                 {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
16752                 {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
16753             }
16754         };
16755
16756         // special case for "0"
16757         if (x == 0)
16758         {
16759             o->write_character('0');
16760             return;
16761         }
16762
16763         // use a pointer to fill the buffer
16764         auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16765
16766         number_unsigned_t abs_value;
16767
16768         unsigned int n_chars{};
16769
16770         if (is_negative_number(x))
16771         {
16772             *buffer_ptr = '-';
16773             abs_value = remove_sign(static_cast<number_integer_t>(x));
16774
16775             // account one more byte for the minus sign
16776             n_chars = 1 + count_digits(abs_value);
16777         }
16778         else
16779         {
16780             abs_value = static_cast<number_unsigned_t>(x);
16781             n_chars = count_digits(abs_value);
16782         }
16783
16784         // spare 1 byte for '\0'
16785         JSON_ASSERT(n_chars < number_buffer.size() - 1);
16786
16787         // jump to the end to generate the string from backward,
16788         // so we later avoid reversing the result
16789         buffer_ptr += n_chars;
16790
16791         // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
16792         // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
16793         while (abs_value >= 100)
16794         {
16795             const auto digits_index = static_cast<unsigned>((abs_value % 100));
16796             abs_value /= 100;
16797             *(--buffer_ptr) = digits_to_99[digits_index][1];
16798             *(--buffer_ptr) = digits_to_99[digits_index][0];
16799         }
16800
16801         if (abs_value >= 10)
16802         {
16803             const auto digits_index = static_cast<unsigned>(abs_value);
16804             *(--buffer_ptr) = digits_to_99[digits_index][1];
16805             *(--buffer_ptr) = digits_to_99[digits_index][0];
16806         }
16807         else
16808         {
16809             *(--buffer_ptr) = static_cast<char>('0' + abs_value);
16810         }
16811
16812         o->write_characters(number_buffer.data(), n_chars);
16813     }
16814
16815     /*!
16816     @brief dump a floating-point number
16817
16818     Dump a given floating-point number to output stream @a o. Works internally
16819     with @a number_buffer.
16820
16821     @param[in] x  floating-point number to dump
16822     */
16823     void dump_float(number_float_t x)
16824     {
16825         // NaN / inf
16826         if (!std::isfinite(x))
16827         {
16828             o->write_characters("null", 4);
16829             return;
16830         }
16831
16832         // If number_float_t is an IEEE-754 single or double precision number,
16833         // use the Grisu2 algorithm to produce short numbers which are
16834         // guaranteed to round-trip, using strtof and strtod, resp.
16835         //
16836         // NB: The test below works if <long double> == <double>.
16837         static constexpr bool is_ieee_single_or_double
16838             = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
16839               (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
16840
16841         dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
16842     }
16843
16844     void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
16845     {
16846         auto* begin = number_buffer.data();
16847         auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
16848
16849         o->write_characters(begin, static_cast<size_t>(end - begin));
16850     }
16851
16852     void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
16853     {
16854         // get number of digits for a float -> text -> float round-trip
16855         static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
16856
16857         // the actual conversion
16858         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
16859         std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
16860
16861         // negative value indicates an error
16862         JSON_ASSERT(len > 0);
16863         // check if buffer was large enough
16864         JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
16865
16866         // erase thousands separator
16867         if (thousands_sep != '\0')
16868         {
16869             // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
16870             const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
16871             std::fill(end, number_buffer.end(), '\0');
16872             JSON_ASSERT((end - number_buffer.begin()) <= len);
16873             len = (end - number_buffer.begin());
16874         }
16875
16876         // convert decimal point to '.'
16877         if (decimal_point != '\0' && decimal_point != '.')
16878         {
16879             // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
16880             const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
16881             if (dec_pos != number_buffer.end())
16882             {
16883                 *dec_pos = '.';
16884             }
16885         }
16886
16887         o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
16888
16889         // determine if we need to append ".0"
16890         const bool value_is_int_like =
16891             std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
16892                          [](char c)
16893         {
16894             return c == '.' || c == 'e';
16895         });
16896
16897         if (value_is_int_like)
16898         {
16899             o->write_characters(".0", 2);
16900         }
16901     }
16902
16903     /*!
16904     @brief check whether a string is UTF-8 encoded
16905
16906     The function checks each byte of a string whether it is UTF-8 encoded. The
16907     result of the check is stored in the @a state parameter. The function must
16908     be called initially with state 0 (accept). State 1 means the string must
16909     be rejected, because the current byte is not allowed. If the string is
16910     completely processed, but the state is non-zero, the string ended
16911     prematurely; that is, the last byte indicated more bytes should have
16912     followed.
16913
16914     @param[in,out] state  the state of the decoding
16915     @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
16916     @param[in] byte       next byte to decode
16917     @return               new state
16918
16919     @note The function has been edited: a std::array is used.
16920
16921     @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
16922     @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
16923     */
16924     static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
16925     {
16926         static const std::array<std::uint8_t, 400> utf8d =
16927         {
16928             {
16929                 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
16930                 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
16931                 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
16932                 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
16933                 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
16934                 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
16935                 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
16936                 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
16937                 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
16938                 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
16939                 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
16940                 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
16941                 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
16942                 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
16943             }
16944         };
16945
16946         JSON_ASSERT(byte < utf8d.size());
16947         const std::uint8_t type = utf8d[byte];
16948
16949         codep = (state != UTF8_ACCEPT)
16950                 ? (byte & 0x3fu) | (codep << 6u)
16951                 : (0xFFu >> type) & (byte);
16952
16953         std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
16954         JSON_ASSERT(index < 400);
16955         state = utf8d[index];
16956         return state;
16957     }
16958
16959     /*
16960      * Overload to make the compiler happy while it is instantiating
16961      * dump_integer for number_unsigned_t.
16962      * Must never be called.
16963      */
16964     number_unsigned_t remove_sign(number_unsigned_t x)
16965     {
16966         JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
16967         return x; // LCOV_EXCL_LINE
16968     }
16969
16970     /*
16971      * Helper function for dump_integer
16972      *
16973      * This function takes a negative signed integer and returns its absolute
16974      * value as unsigned integer. The plus/minus shuffling is necessary as we can
16975      * not directly remove the sign of an arbitrary signed integer as the
16976      * absolute values of INT_MIN and INT_MAX are usually not the same. See
16977      * #1708 for details.
16978      */
16979     inline number_unsigned_t remove_sign(number_integer_t x) noexcept
16980     {
16981         JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
16982         return static_cast<number_unsigned_t>(-(x + 1)) + 1;
16983     }
16984
16985   private:
16986     /// the output of the serializer
16987     output_adapter_t<char> o = nullptr;
16988
16989     /// a (hopefully) large enough character buffer
16990     std::array<char, 64> number_buffer{{}};
16991
16992     /// the locale
16993     const std::lconv* loc = nullptr;
16994     /// the locale's thousand separator character
16995     const char thousands_sep = '\0';
16996     /// the locale's decimal point character
16997     const char decimal_point = '\0';
16998
16999     /// string buffer
17000     std::array<char, 512> string_buffer{{}};
17001
17002     /// the indentation character
17003     const char indent_char;
17004     /// the indentation string
17005     string_t indent_string;
17006
17007     /// error_handler how to react on decoding errors
17008     const error_handler_t error_handler;
17009 };
17010 }  // namespace detail
17011 }  // namespace nlohmann
17012
17013 // #include <nlohmann/detail/value_t.hpp>
17014
17015 // #include <nlohmann/json_fwd.hpp>
17016
17017 // #include <nlohmann/ordered_map.hpp>
17018
17019
17020 #include <functional> // less
17021 #include <initializer_list> // initializer_list
17022 #include <iterator> // input_iterator_tag, iterator_traits
17023 #include <memory> // allocator
17024 #include <stdexcept> // for out_of_range
17025 #include <type_traits> // enable_if, is_convertible
17026 #include <utility> // pair
17027 #include <vector> // vector
17028
17029 // #include <nlohmann/detail/macro_scope.hpp>
17030
17031
17032 namespace nlohmann
17033 {
17034
17035 /// ordered_map: a minimal map-like container that preserves insertion order
17036 /// for use within nlohmann::basic_json<ordered_map>
17037 template <class Key, class T, class IgnoredLess = std::less<Key>,
17038           class Allocator = std::allocator<std::pair<const Key, T>>>
17039                   struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
17040 {
17041     using key_type = Key;
17042     using mapped_type = T;
17043     using Container = std::vector<std::pair<const Key, T>, Allocator>;
17044     using iterator = typename Container::iterator;
17045     using const_iterator = typename Container::const_iterator;
17046     using size_type = typename Container::size_type;
17047     using value_type = typename Container::value_type;
17048
17049     // Explicit constructors instead of `using Container::Container`
17050     // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
17051     ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
17052     template <class It>
17053     ordered_map(It first, It last, const Allocator& alloc = Allocator())
17054         : Container{first, last, alloc} {}
17055     ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
17056         : Container{init, alloc} {}
17057
17058     std::pair<iterator, bool> emplace(const key_type& key, T&& t)
17059     {
17060         for (auto it = this->begin(); it != this->end(); ++it)
17061         {
17062             if (it->first == key)
17063             {
17064                 return {it, false};
17065             }
17066         }
17067         Container::emplace_back(key, t);
17068         return {--this->end(), true};
17069     }
17070
17071     T& operator[](const Key& key)
17072     {
17073         return emplace(key, T{}).first->second;
17074     }
17075
17076     const T& operator[](const Key& key) const
17077     {
17078         return at(key);
17079     }
17080
17081     T& at(const Key& key)
17082     {
17083         for (auto it = this->begin(); it != this->end(); ++it)
17084         {
17085             if (it->first == key)
17086             {
17087                 return it->second;
17088             }
17089         }
17090
17091         JSON_THROW(std::out_of_range("key not found"));
17092     }
17093
17094     const T& at(const Key& key) const
17095     {
17096         for (auto it = this->begin(); it != this->end(); ++it)
17097         {
17098             if (it->first == key)
17099             {
17100                 return it->second;
17101             }
17102         }
17103
17104         JSON_THROW(std::out_of_range("key not found"));
17105     }
17106
17107     size_type erase(const Key& key)
17108     {
17109         for (auto it = this->begin(); it != this->end(); ++it)
17110         {
17111             if (it->first == key)
17112             {
17113                 // Since we cannot move const Keys, re-construct them in place
17114                 for (auto next = it; ++next != this->end(); ++it)
17115                 {
17116                     it->~value_type(); // Destroy but keep allocation
17117                     new (&*it) value_type{std::move(*next)};
17118                 }
17119                 Container::pop_back();
17120                 return 1;
17121             }
17122         }
17123         return 0;
17124     }
17125
17126     iterator erase(iterator pos)
17127     {
17128         return erase(pos, std::next(pos));
17129     }
17130
17131     iterator erase(iterator first, iterator last)
17132     {
17133         const auto elements_affected = std::distance(first, last);
17134         const auto offset = std::distance(Container::begin(), first);
17135
17136         // This is the start situation. We need to delete elements_affected
17137         // elements (3 in this example: e, f, g), and need to return an
17138         // iterator past the last deleted element (h in this example).
17139         // Note that offset is the distance from the start of the vector
17140         // to first. We will need this later.
17141
17142         // [ a, b, c, d, e, f, g, h, i, j ]
17143         //               ^        ^
17144         //             first    last
17145
17146         // Since we cannot move const Keys, we re-construct them in place.
17147         // We start at first and re-construct (viz. copy) the elements from
17148         // the back of the vector. Example for first iteration:
17149
17150         //               ,--------.
17151         //               v        |   destroy e and re-construct with h
17152         // [ a, b, c, d, e, f, g, h, i, j ]
17153         //               ^        ^
17154         //               it       it + elements_affected
17155
17156         for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
17157         {
17158             it->~value_type(); // destroy but keep allocation
17159             new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
17160         }
17161
17162         // [ a, b, c, d, h, i, j, h, i, j ]
17163         //               ^        ^
17164         //             first    last
17165
17166         // remove the unneeded elements at the end of the vector
17167         Container::resize(this->size() - static_cast<size_type>(elements_affected));
17168
17169         // [ a, b, c, d, h, i, j ]
17170         //               ^        ^
17171         //             first    last
17172
17173         // first is now pointing past the last deleted element, but we cannot
17174         // use this iterator, because it may have been invalidated by the
17175         // resize call. Instead, we can return begin() + offset.
17176         return Container::begin() + offset;
17177     }
17178
17179     size_type count(const Key& key) const
17180     {
17181         for (auto it = this->begin(); it != this->end(); ++it)
17182         {
17183             if (it->first == key)
17184             {
17185                 return 1;
17186             }
17187         }
17188         return 0;
17189     }
17190
17191     iterator find(const Key& key)
17192     {
17193         for (auto it = this->begin(); it != this->end(); ++it)
17194         {
17195             if (it->first == key)
17196             {
17197                 return it;
17198             }
17199         }
17200         return Container::end();
17201     }
17202
17203     const_iterator find(const Key& key) const
17204     {
17205         for (auto it = this->begin(); it != this->end(); ++it)
17206         {
17207             if (it->first == key)
17208             {
17209                 return it;
17210             }
17211         }
17212         return Container::end();
17213     }
17214
17215     std::pair<iterator, bool> insert( value_type&& value )
17216     {
17217         return emplace(value.first, std::move(value.second));
17218     }
17219
17220     std::pair<iterator, bool> insert( const value_type& value )
17221     {
17222         for (auto it = this->begin(); it != this->end(); ++it)
17223         {
17224             if (it->first == value.first)
17225             {
17226                 return {it, false};
17227             }
17228         }
17229         Container::push_back(value);
17230         return {--this->end(), true};
17231     }
17232
17233     template<typename InputIt>
17234     using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
17235             std::input_iterator_tag>::value>::type;
17236
17237     template<typename InputIt, typename = require_input_iter<InputIt>>
17238     void insert(InputIt first, InputIt last)
17239     {
17240         for (auto it = first; it != last; ++it)
17241         {
17242             insert(*it);
17243         }
17244     }
17245 };
17246
17247 }  // namespace nlohmann
17248
17249
17250 #if defined(JSON_HAS_CPP_17)
17251     #include <string_view>
17252 #endif
17253
17254 /*!
17255 @brief namespace for Niels Lohmann
17256 @see https://github.com/nlohmann
17257 @since version 1.0.0
17258 */
17259 namespace nlohmann
17260 {
17261
17262 /*!
17263 @brief a class to store JSON values
17264
17265 @internal
17266 @invariant The member variables @a m_value and @a m_type have the following
17267 relationship:
17268 - If `m_type == value_t::object`, then `m_value.object != nullptr`.
17269 - If `m_type == value_t::array`, then `m_value.array != nullptr`.
17270 - If `m_type == value_t::string`, then `m_value.string != nullptr`.
17271 The invariants are checked by member function assert_invariant().
17272
17273 @note ObjectType trick from https://stackoverflow.com/a/9860911
17274 @endinternal
17275
17276 @since version 1.0.0
17277
17278 @nosubgrouping
17279 */
17280 NLOHMANN_BASIC_JSON_TPL_DECLARATION
17281 class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
17282 {
17283   private:
17284     template<detail::value_t> friend struct detail::external_constructor;
17285     friend ::nlohmann::json_pointer<basic_json>;
17286
17287     template<typename BasicJsonType, typename InputType>
17288     friend class ::nlohmann::detail::parser;
17289     friend ::nlohmann::detail::serializer<basic_json>;
17290     template<typename BasicJsonType>
17291     friend class ::nlohmann::detail::iter_impl;
17292     template<typename BasicJsonType, typename CharType>
17293     friend class ::nlohmann::detail::binary_writer;
17294     template<typename BasicJsonType, typename InputType, typename SAX>
17295     friend class ::nlohmann::detail::binary_reader;
17296     template<typename BasicJsonType>
17297     friend class ::nlohmann::detail::json_sax_dom_parser;
17298     template<typename BasicJsonType>
17299     friend class ::nlohmann::detail::json_sax_dom_callback_parser;
17300     friend class ::nlohmann::detail::exception;
17301
17302     /// workaround type for MSVC
17303     using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
17304
17305   JSON_PRIVATE_UNLESS_TESTED:
17306     // convenience aliases for types residing in namespace detail;
17307     using lexer = ::nlohmann::detail::lexer_base<basic_json>;
17308
17309     template<typename InputAdapterType>
17310     static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
17311         InputAdapterType adapter,
17312         detail::parser_callback_t<basic_json>cb = nullptr,
17313         const bool allow_exceptions = true,
17314         const bool ignore_comments = false
17315                                  )
17316     {
17317         return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
17318                 std::move(cb), allow_exceptions, ignore_comments);
17319     }
17320
17321   private:
17322     using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
17323     template<typename BasicJsonType>
17324     using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
17325     template<typename BasicJsonType>
17326     using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
17327     template<typename Iterator>
17328     using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
17329     template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
17330
17331     template<typename CharType>
17332     using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
17333
17334     template<typename InputType>
17335     using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
17336     template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
17337
17338   JSON_PRIVATE_UNLESS_TESTED:
17339     using serializer = ::nlohmann::detail::serializer<basic_json>;
17340
17341   public:
17342     using value_t = detail::value_t;
17343     /// JSON Pointer, see @ref nlohmann::json_pointer
17344     using json_pointer = ::nlohmann::json_pointer<basic_json>;
17345     template<typename T, typename SFINAE>
17346     using json_serializer = JSONSerializer<T, SFINAE>;
17347     /// how to treat decoding errors
17348     using error_handler_t = detail::error_handler_t;
17349     /// how to treat CBOR tags
17350     using cbor_tag_handler_t = detail::cbor_tag_handler_t;
17351     /// helper type for initializer lists of basic_json values
17352     using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
17353
17354     using input_format_t = detail::input_format_t;
17355     /// SAX interface type, see @ref nlohmann::json_sax
17356     using json_sax_t = json_sax<basic_json>;
17357
17358     ////////////////
17359     // exceptions //
17360     ////////////////
17361
17362     /// @name exceptions
17363     /// Classes to implement user-defined exceptions.
17364     /// @{
17365
17366     using exception = detail::exception;
17367     using parse_error = detail::parse_error;
17368     using invalid_iterator = detail::invalid_iterator;
17369     using type_error = detail::type_error;
17370     using out_of_range = detail::out_of_range;
17371     using other_error = detail::other_error;
17372
17373     /// @}
17374
17375
17376     /////////////////////
17377     // container types //
17378     /////////////////////
17379
17380     /// @name container types
17381     /// The canonic container types to use @ref basic_json like any other STL
17382     /// container.
17383     /// @{
17384
17385     /// the type of elements in a basic_json container
17386     using value_type = basic_json;
17387
17388     /// the type of an element reference
17389     using reference = value_type&;
17390     /// the type of an element const reference
17391     using const_reference = const value_type&;
17392
17393     /// a type to represent differences between iterators
17394     using difference_type = std::ptrdiff_t;
17395     /// a type to represent container sizes
17396     using size_type = std::size_t;
17397
17398     /// the allocator type
17399     using allocator_type = AllocatorType<basic_json>;
17400
17401     /// the type of an element pointer
17402     using pointer = typename std::allocator_traits<allocator_type>::pointer;
17403     /// the type of an element const pointer
17404     using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
17405
17406     /// an iterator for a basic_json container
17407     using iterator = iter_impl<basic_json>;
17408     /// a const iterator for a basic_json container
17409     using const_iterator = iter_impl<const basic_json>;
17410     /// a reverse iterator for a basic_json container
17411     using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
17412     /// a const reverse iterator for a basic_json container
17413     using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
17414
17415     /// @}
17416
17417
17418     /// @brief returns the allocator associated with the container
17419     /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
17420     static allocator_type get_allocator()
17421     {
17422         return allocator_type();
17423     }
17424
17425     /// @brief returns version information on the library
17426     /// @sa https://json.nlohmann.me/api/basic_json/meta/
17427     JSON_HEDLEY_WARN_UNUSED_RESULT
17428     static basic_json meta()
17429     {
17430         basic_json result;
17431
17432         result["copyright"] = "(C) 2013-2022 Niels Lohmann";
17433         result["name"] = "JSON for Modern C++";
17434         result["url"] = "https://github.com/nlohmann/json";
17435         result["version"]["string"] =
17436             std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
17437             std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
17438             std::to_string(NLOHMANN_JSON_VERSION_PATCH);
17439         result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
17440         result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
17441         result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
17442
17443 #ifdef _WIN32
17444         result["platform"] = "win32";
17445 #elif defined __linux__
17446         result["platform"] = "linux";
17447 #elif defined __APPLE__
17448         result["platform"] = "apple";
17449 #elif defined __unix__
17450         result["platform"] = "unix";
17451 #else
17452         result["platform"] = "unknown";
17453 #endif
17454
17455 #if defined(__ICC) || defined(__INTEL_COMPILER)
17456         result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
17457 #elif defined(__clang__)
17458         result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
17459 #elif defined(__GNUC__) || defined(__GNUG__)
17460         result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
17461 #elif defined(__HP_cc) || defined(__HP_aCC)
17462         result["compiler"] = "hp"
17463 #elif defined(__IBMCPP__)
17464         result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
17465 #elif defined(_MSC_VER)
17466         result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
17467 #elif defined(__PGI)
17468         result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
17469 #elif defined(__SUNPRO_CC)
17470         result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
17471 #else
17472         result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
17473 #endif
17474
17475 #ifdef __cplusplus
17476         result["compiler"]["c++"] = std::to_string(__cplusplus);
17477 #else
17478         result["compiler"]["c++"] = "unknown";
17479 #endif
17480         return result;
17481     }
17482
17483
17484     ///////////////////////////
17485     // JSON value data types //
17486     ///////////////////////////
17487
17488     /// @name JSON value data types
17489     /// The data types to store a JSON value. These types are derived from
17490     /// the template arguments passed to class @ref basic_json.
17491     /// @{
17492
17493     /// @brief object key comparator type
17494     /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
17495 #if defined(JSON_HAS_CPP_14)
17496     // Use transparent comparator if possible, combined with perfect forwarding
17497     // on find() and count() calls prevents unnecessary string construction.
17498     using object_comparator_t = std::less<>;
17499 #else
17500     using object_comparator_t = std::less<StringType>;
17501 #endif
17502
17503     /// @brief a type for an object
17504     /// @sa https://json.nlohmann.me/api/basic_json/object_t/
17505     using object_t = ObjectType<StringType,
17506           basic_json,
17507           object_comparator_t,
17508           AllocatorType<std::pair<const StringType,
17509           basic_json>>>;
17510
17511     /// @brief a type for an array
17512     /// @sa https://json.nlohmann.me/api/basic_json/array_t/
17513     using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
17514
17515     /// @brief a type for a string
17516     /// @sa https://json.nlohmann.me/api/basic_json/string_t/
17517     using string_t = StringType;
17518
17519     /// @brief a type for a boolean
17520     /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
17521     using boolean_t = BooleanType;
17522
17523     /// @brief a type for a number (integer)
17524     /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
17525     using number_integer_t = NumberIntegerType;
17526
17527     /// @brief a type for a number (unsigned)
17528     /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
17529     using number_unsigned_t = NumberUnsignedType;
17530
17531     /// @brief a type for a number (floating-point)
17532     /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
17533     using number_float_t = NumberFloatType;
17534
17535     /// @brief a type for a packed binary type
17536     /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
17537     using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
17538
17539     /// @}
17540
17541   private:
17542
17543     /// helper for exception-safe object creation
17544     template<typename T, typename... Args>
17545     JSON_HEDLEY_RETURNS_NON_NULL
17546     static T* create(Args&& ... args)
17547     {
17548         AllocatorType<T> alloc;
17549         using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
17550
17551         auto deleter = [&](T * obj)
17552         {
17553             AllocatorTraits::deallocate(alloc, obj, 1);
17554         };
17555         std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
17556         AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
17557         JSON_ASSERT(obj != nullptr);
17558         return obj.release();
17559     }
17560
17561     ////////////////////////
17562     // JSON value storage //
17563     ////////////////////////
17564
17565   JSON_PRIVATE_UNLESS_TESTED:
17566     /*!
17567     @brief a JSON value
17568
17569     The actual storage for a JSON value of the @ref basic_json class. This
17570     union combines the different storage types for the JSON value types
17571     defined in @ref value_t.
17572
17573     JSON type | value_t type    | used type
17574     --------- | --------------- | ------------------------
17575     object    | object          | pointer to @ref object_t
17576     array     | array           | pointer to @ref array_t
17577     string    | string          | pointer to @ref string_t
17578     boolean   | boolean         | @ref boolean_t
17579     number    | number_integer  | @ref number_integer_t
17580     number    | number_unsigned | @ref number_unsigned_t
17581     number    | number_float    | @ref number_float_t
17582     binary    | binary          | pointer to @ref binary_t
17583     null      | null            | *no value is stored*
17584
17585     @note Variable-length types (objects, arrays, and strings) are stored as
17586     pointers. The size of the union should not exceed 64 bits if the default
17587     value types are used.
17588
17589     @since version 1.0.0
17590     */
17591     union json_value
17592     {
17593         /// object (stored with pointer to save storage)
17594         object_t* object;
17595         /// array (stored with pointer to save storage)
17596         array_t* array;
17597         /// string (stored with pointer to save storage)
17598         string_t* string;
17599         /// binary (stored with pointer to save storage)
17600         binary_t* binary;
17601         /// boolean
17602         boolean_t boolean;
17603         /// number (integer)
17604         number_integer_t number_integer;
17605         /// number (unsigned integer)
17606         number_unsigned_t number_unsigned;
17607         /// number (floating-point)
17608         number_float_t number_float;
17609
17610         /// default constructor (for null values)
17611         json_value() = default;
17612         /// constructor for booleans
17613         json_value(boolean_t v) noexcept : boolean(v) {}
17614         /// constructor for numbers (integer)
17615         json_value(number_integer_t v) noexcept : number_integer(v) {}
17616         /// constructor for numbers (unsigned)
17617         json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
17618         /// constructor for numbers (floating-point)
17619         json_value(number_float_t v) noexcept : number_float(v) {}
17620         /// constructor for empty values of a given type
17621         json_value(value_t t)
17622         {
17623             switch (t)
17624             {
17625                 case value_t::object:
17626                 {
17627                     object = create<object_t>();
17628                     break;
17629                 }
17630
17631                 case value_t::array:
17632                 {
17633                     array = create<array_t>();
17634                     break;
17635                 }
17636
17637                 case value_t::string:
17638                 {
17639                     string = create<string_t>("");
17640                     break;
17641                 }
17642
17643                 case value_t::binary:
17644                 {
17645                     binary = create<binary_t>();
17646                     break;
17647                 }
17648
17649                 case value_t::boolean:
17650                 {
17651                     boolean = static_cast<boolean_t>(false);
17652                     break;
17653                 }
17654
17655                 case value_t::number_integer:
17656                 {
17657                     number_integer = static_cast<number_integer_t>(0);
17658                     break;
17659                 }
17660
17661                 case value_t::number_unsigned:
17662                 {
17663                     number_unsigned = static_cast<number_unsigned_t>(0);
17664                     break;
17665                 }
17666
17667                 case value_t::number_float:
17668                 {
17669                     number_float = static_cast<number_float_t>(0.0);
17670                     break;
17671                 }
17672
17673                 case value_t::null:
17674                 {
17675                     object = nullptr;  // silence warning, see #821
17676                     break;
17677                 }
17678
17679                 case value_t::discarded:
17680                 default:
17681                 {
17682                     object = nullptr;  // silence warning, see #821
17683                     if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
17684                     {
17685                         JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.10.5", basic_json())); // LCOV_EXCL_LINE
17686                     }
17687                     break;
17688                 }
17689             }
17690         }
17691
17692         /// constructor for strings
17693         json_value(const string_t& value) : string(create<string_t>(value)) {}
17694
17695         /// constructor for rvalue strings
17696         json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
17697
17698         /// constructor for objects
17699         json_value(const object_t& value) : object(create<object_t>(value)) {}
17700
17701         /// constructor for rvalue objects
17702         json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
17703
17704         /// constructor for arrays
17705         json_value(const array_t& value) : array(create<array_t>(value)) {}
17706
17707         /// constructor for rvalue arrays
17708         json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
17709
17710         /// constructor for binary arrays
17711         json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
17712
17713         /// constructor for rvalue binary arrays
17714         json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
17715
17716         /// constructor for binary arrays (internal type)
17717         json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
17718
17719         /// constructor for rvalue binary arrays (internal type)
17720         json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
17721
17722         void destroy(value_t t)
17723         {
17724             if (t == value_t::array || t == value_t::object)
17725             {
17726                 // flatten the current json_value to a heap-allocated stack
17727                 std::vector<basic_json> stack;
17728
17729                 // move the top-level items to stack
17730                 if (t == value_t::array)
17731                 {
17732                     stack.reserve(array->size());
17733                     std::move(array->begin(), array->end(), std::back_inserter(stack));
17734                 }
17735                 else
17736                 {
17737                     stack.reserve(object->size());
17738                     for (auto&& it : *object)
17739                     {
17740                         stack.push_back(std::move(it.second));
17741                     }
17742                 }
17743
17744                 while (!stack.empty())
17745                 {
17746                     // move the last item to local variable to be processed
17747                     basic_json current_item(std::move(stack.back()));
17748                     stack.pop_back();
17749
17750                     // if current_item is array/object, move
17751                     // its children to the stack to be processed later
17752                     if (current_item.is_array())
17753                     {
17754                         std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
17755
17756                         current_item.m_value.array->clear();
17757                     }
17758                     else if (current_item.is_object())
17759                     {
17760                         for (auto&& it : *current_item.m_value.object)
17761                         {
17762                             stack.push_back(std::move(it.second));
17763                         }
17764
17765                         current_item.m_value.object->clear();
17766                     }
17767
17768                     // it's now safe that current_item get destructed
17769                     // since it doesn't have any children
17770                 }
17771             }
17772
17773             switch (t)
17774             {
17775                 case value_t::object:
17776                 {
17777                     AllocatorType<object_t> alloc;
17778                     std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
17779                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
17780                     break;
17781                 }
17782
17783                 case value_t::array:
17784                 {
17785                     AllocatorType<array_t> alloc;
17786                     std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
17787                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
17788                     break;
17789                 }
17790
17791                 case value_t::string:
17792                 {
17793                     AllocatorType<string_t> alloc;
17794                     std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
17795                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
17796                     break;
17797                 }
17798
17799                 case value_t::binary:
17800                 {
17801                     AllocatorType<binary_t> alloc;
17802                     std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
17803                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
17804                     break;
17805                 }
17806
17807                 case value_t::null:
17808                 case value_t::boolean:
17809                 case value_t::number_integer:
17810                 case value_t::number_unsigned:
17811                 case value_t::number_float:
17812                 case value_t::discarded:
17813                 default:
17814                 {
17815                     break;
17816                 }
17817             }
17818         }
17819     };
17820
17821   private:
17822     /*!
17823     @brief checks the class invariants
17824
17825     This function asserts the class invariants. It needs to be called at the
17826     end of every constructor to make sure that created objects respect the
17827     invariant. Furthermore, it has to be called each time the type of a JSON
17828     value is changed, because the invariant expresses a relationship between
17829     @a m_type and @a m_value.
17830
17831     Furthermore, the parent relation is checked for arrays and objects: If
17832     @a check_parents true and the value is an array or object, then the
17833     container's elements must have the current value as parent.
17834
17835     @param[in] check_parents  whether the parent relation should be checked.
17836                The value is true by default and should only be set to false
17837                during destruction of objects when the invariant does not
17838                need to hold.
17839     */
17840     void assert_invariant(bool check_parents = true) const noexcept
17841     {
17842         JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
17843         JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
17844         JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
17845         JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
17846
17847 #if JSON_DIAGNOSTICS
17848         JSON_TRY
17849         {
17850             // cppcheck-suppress assertWithSideEffect
17851             JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
17852             {
17853                 return j.m_parent == this;
17854             }));
17855         }
17856         JSON_CATCH(...) {} // LCOV_EXCL_LINE
17857 #endif
17858         static_cast<void>(check_parents);
17859     }
17860
17861     void set_parents()
17862     {
17863 #if JSON_DIAGNOSTICS
17864         switch (m_type)
17865         {
17866             case value_t::array:
17867             {
17868                 for (auto& element : *m_value.array)
17869                 {
17870                     element.m_parent = this;
17871                 }
17872                 break;
17873             }
17874
17875             case value_t::object:
17876             {
17877                 for (auto& element : *m_value.object)
17878                 {
17879                     element.second.m_parent = this;
17880                 }
17881                 break;
17882             }
17883
17884             case value_t::null:
17885             case value_t::string:
17886             case value_t::boolean:
17887             case value_t::number_integer:
17888             case value_t::number_unsigned:
17889             case value_t::number_float:
17890             case value_t::binary:
17891             case value_t::discarded:
17892             default:
17893                 break;
17894         }
17895 #endif
17896     }
17897
17898     iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
17899     {
17900 #if JSON_DIAGNOSTICS
17901         for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
17902         {
17903             (it + i)->m_parent = this;
17904         }
17905 #else
17906         static_cast<void>(count_set_parents);
17907 #endif
17908         return it;
17909     }
17910
17911     reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
17912     {
17913 #if JSON_DIAGNOSTICS
17914         if (old_capacity != static_cast<std::size_t>(-1))
17915         {
17916             // see https://github.com/nlohmann/json/issues/2838
17917             JSON_ASSERT(type() == value_t::array);
17918             if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
17919             {
17920                 // capacity has changed: update all parents
17921                 set_parents();
17922                 return j;
17923             }
17924         }
17925
17926         // ordered_json uses a vector internally, so pointers could have
17927         // been invalidated; see https://github.com/nlohmann/json/issues/2962
17928 #ifdef JSON_HEDLEY_MSVC_VERSION
17929 #pragma warning(push )
17930 #pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
17931 #endif
17932         if (detail::is_ordered_map<object_t>::value)
17933         {
17934             set_parents();
17935             return j;
17936         }
17937 #ifdef JSON_HEDLEY_MSVC_VERSION
17938 #pragma warning( pop )
17939 #endif
17940
17941         j.m_parent = this;
17942 #else
17943         static_cast<void>(j);
17944         static_cast<void>(old_capacity);
17945 #endif
17946         return j;
17947     }
17948
17949   public:
17950     //////////////////////////
17951     // JSON parser callback //
17952     //////////////////////////
17953
17954     /// @brief parser event types
17955     /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
17956     using parse_event_t = detail::parse_event_t;
17957
17958     /// @brief per-element parser callback type
17959     /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
17960     using parser_callback_t = detail::parser_callback_t<basic_json>;
17961
17962     //////////////////
17963     // constructors //
17964     //////////////////
17965
17966     /// @name constructors and destructors
17967     /// Constructors of class @ref basic_json, copy/move constructor, copy
17968     /// assignment, static functions creating objects, and the destructor.
17969     /// @{
17970
17971     /// @brief create an empty value with a given type
17972     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
17973     basic_json(const value_t v)
17974         : m_type(v), m_value(v)
17975     {
17976         assert_invariant();
17977     }
17978
17979     /// @brief create a null object
17980     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
17981     basic_json(std::nullptr_t = nullptr) noexcept
17982         : basic_json(value_t::null)
17983     {
17984         assert_invariant();
17985     }
17986
17987     /// @brief create a JSON value from compatible types
17988     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
17989     template < typename CompatibleType,
17990                typename U = detail::uncvref_t<CompatibleType>,
17991                detail::enable_if_t <
17992                    !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
17993     basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
17994                 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
17995                                            std::forward<CompatibleType>(val))))
17996     {
17997         JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
17998         set_parents();
17999         assert_invariant();
18000     }
18001
18002     /// @brief create a JSON value from an existing one
18003     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18004     template < typename BasicJsonType,
18005                detail::enable_if_t <
18006                    detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
18007     basic_json(const BasicJsonType& val)
18008     {
18009         using other_boolean_t = typename BasicJsonType::boolean_t;
18010         using other_number_float_t = typename BasicJsonType::number_float_t;
18011         using other_number_integer_t = typename BasicJsonType::number_integer_t;
18012         using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
18013         using other_string_t = typename BasicJsonType::string_t;
18014         using other_object_t = typename BasicJsonType::object_t;
18015         using other_array_t = typename BasicJsonType::array_t;
18016         using other_binary_t = typename BasicJsonType::binary_t;
18017
18018         switch (val.type())
18019         {
18020             case value_t::boolean:
18021                 JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
18022                 break;
18023             case value_t::number_float:
18024                 JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
18025                 break;
18026             case value_t::number_integer:
18027                 JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
18028                 break;
18029             case value_t::number_unsigned:
18030                 JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
18031                 break;
18032             case value_t::string:
18033                 JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
18034                 break;
18035             case value_t::object:
18036                 JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
18037                 break;
18038             case value_t::array:
18039                 JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
18040                 break;
18041             case value_t::binary:
18042                 JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
18043                 break;
18044             case value_t::null:
18045                 *this = nullptr;
18046                 break;
18047             case value_t::discarded:
18048                 m_type = value_t::discarded;
18049                 break;
18050             default:            // LCOV_EXCL_LINE
18051                 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
18052         }
18053         set_parents();
18054         assert_invariant();
18055     }
18056
18057     /// @brief create a container (array or object) from an initializer list
18058     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18059     basic_json(initializer_list_t init,
18060                bool type_deduction = true,
18061                value_t manual_type = value_t::array)
18062     {
18063         // check if each element is an array with two elements whose first
18064         // element is a string
18065         bool is_an_object = std::all_of(init.begin(), init.end(),
18066                                         [](const detail::json_ref<basic_json>& element_ref)
18067         {
18068             return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
18069         });
18070
18071         // adjust type if type deduction is not wanted
18072         if (!type_deduction)
18073         {
18074             // if array is wanted, do not create an object though possible
18075             if (manual_type == value_t::array)
18076             {
18077                 is_an_object = false;
18078             }
18079
18080             // if object is wanted but impossible, throw an exception
18081             if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
18082             {
18083                 JSON_THROW(type_error::create(301, "cannot create object from initializer list", basic_json()));
18084             }
18085         }
18086
18087         if (is_an_object)
18088         {
18089             // the initializer list is a list of pairs -> create object
18090             m_type = value_t::object;
18091             m_value = value_t::object;
18092
18093             for (auto& element_ref : init)
18094             {
18095                 auto element = element_ref.moved_or_copied();
18096                 m_value.object->emplace(
18097                     std::move(*((*element.m_value.array)[0].m_value.string)),
18098                     std::move((*element.m_value.array)[1]));
18099             }
18100         }
18101         else
18102         {
18103             // the initializer list describes an array -> create array
18104             m_type = value_t::array;
18105             m_value.array = create<array_t>(init.begin(), init.end());
18106         }
18107
18108         set_parents();
18109         assert_invariant();
18110     }
18111
18112     /// @brief explicitly create a binary array (without subtype)
18113     /// @sa https://json.nlohmann.me/api/basic_json/binary/
18114     JSON_HEDLEY_WARN_UNUSED_RESULT
18115     static basic_json binary(const typename binary_t::container_type& init)
18116     {
18117         auto res = basic_json();
18118         res.m_type = value_t::binary;
18119         res.m_value = init;
18120         return res;
18121     }
18122
18123     /// @brief explicitly create a binary array (with subtype)
18124     /// @sa https://json.nlohmann.me/api/basic_json/binary/
18125     JSON_HEDLEY_WARN_UNUSED_RESULT
18126     static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
18127     {
18128         auto res = basic_json();
18129         res.m_type = value_t::binary;
18130         res.m_value = binary_t(init, subtype);
18131         return res;
18132     }
18133
18134     /// @brief explicitly create a binary array
18135     /// @sa https://json.nlohmann.me/api/basic_json/binary/
18136     JSON_HEDLEY_WARN_UNUSED_RESULT
18137     static basic_json binary(typename binary_t::container_type&& init)
18138     {
18139         auto res = basic_json();
18140         res.m_type = value_t::binary;
18141         res.m_value = std::move(init);
18142         return res;
18143     }
18144
18145     /// @brief explicitly create a binary array (with subtype)
18146     /// @sa https://json.nlohmann.me/api/basic_json/binary/
18147     JSON_HEDLEY_WARN_UNUSED_RESULT
18148     static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
18149     {
18150         auto res = basic_json();
18151         res.m_type = value_t::binary;
18152         res.m_value = binary_t(std::move(init), subtype);
18153         return res;
18154     }
18155
18156     /// @brief explicitly create an array from an initializer list
18157     /// @sa https://json.nlohmann.me/api/basic_json/array/
18158     JSON_HEDLEY_WARN_UNUSED_RESULT
18159     static basic_json array(initializer_list_t init = {})
18160     {
18161         return basic_json(init, false, value_t::array);
18162     }
18163
18164     /// @brief explicitly create an object from an initializer list
18165     /// @sa https://json.nlohmann.me/api/basic_json/object/
18166     JSON_HEDLEY_WARN_UNUSED_RESULT
18167     static basic_json object(initializer_list_t init = {})
18168     {
18169         return basic_json(init, false, value_t::object);
18170     }
18171
18172     /// @brief construct an array with count copies of given value
18173     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18174     basic_json(size_type cnt, const basic_json& val)
18175         : m_type(value_t::array)
18176     {
18177         m_value.array = create<array_t>(cnt, val);
18178         set_parents();
18179         assert_invariant();
18180     }
18181
18182     /// @brief construct a JSON container given an iterator range
18183     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18184     template < class InputIT, typename std::enable_if <
18185                    std::is_same<InputIT, typename basic_json_t::iterator>::value ||
18186                    std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
18187     basic_json(InputIT first, InputIT last)
18188     {
18189         JSON_ASSERT(first.m_object != nullptr);
18190         JSON_ASSERT(last.m_object != nullptr);
18191
18192         // make sure iterator fits the current value
18193         if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
18194         {
18195             JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", basic_json()));
18196         }
18197
18198         // copy type from first iterator
18199         m_type = first.m_object->m_type;
18200
18201         // check if iterator range is complete for primitive values
18202         switch (m_type)
18203         {
18204             case value_t::boolean:
18205             case value_t::number_float:
18206             case value_t::number_integer:
18207             case value_t::number_unsigned:
18208             case value_t::string:
18209             {
18210                 if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
18211                                          || !last.m_it.primitive_iterator.is_end()))
18212                 {
18213                     JSON_THROW(invalid_iterator::create(204, "iterators out of range", *first.m_object));
18214                 }
18215                 break;
18216             }
18217
18218             case value_t::null:
18219             case value_t::object:
18220             case value_t::array:
18221             case value_t::binary:
18222             case value_t::discarded:
18223             default:
18224                 break;
18225         }
18226
18227         switch (m_type)
18228         {
18229             case value_t::number_integer:
18230             {
18231                 m_value.number_integer = first.m_object->m_value.number_integer;
18232                 break;
18233             }
18234
18235             case value_t::number_unsigned:
18236             {
18237                 m_value.number_unsigned = first.m_object->m_value.number_unsigned;
18238                 break;
18239             }
18240
18241             case value_t::number_float:
18242             {
18243                 m_value.number_float = first.m_object->m_value.number_float;
18244                 break;
18245             }
18246
18247             case value_t::boolean:
18248             {
18249                 m_value.boolean = first.m_object->m_value.boolean;
18250                 break;
18251             }
18252
18253             case value_t::string:
18254             {
18255                 m_value = *first.m_object->m_value.string;
18256                 break;
18257             }
18258
18259             case value_t::object:
18260             {
18261                 m_value.object = create<object_t>(first.m_it.object_iterator,
18262                                                   last.m_it.object_iterator);
18263                 break;
18264             }
18265
18266             case value_t::array:
18267             {
18268                 m_value.array = create<array_t>(first.m_it.array_iterator,
18269                                                 last.m_it.array_iterator);
18270                 break;
18271             }
18272
18273             case value_t::binary:
18274             {
18275                 m_value = *first.m_object->m_value.binary;
18276                 break;
18277             }
18278
18279             case value_t::null:
18280             case value_t::discarded:
18281             default:
18282                 JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
18283         }
18284
18285         set_parents();
18286         assert_invariant();
18287     }
18288
18289
18290     ///////////////////////////////////////
18291     // other constructors and destructor //
18292     ///////////////////////////////////////
18293
18294     template<typename JsonRef,
18295              detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
18296                                  std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
18297     basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
18298
18299     /// @brief copy constructor
18300     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18301     basic_json(const basic_json& other)
18302         : m_type(other.m_type)
18303     {
18304         // check of passed value is valid
18305         other.assert_invariant();
18306
18307         switch (m_type)
18308         {
18309             case value_t::object:
18310             {
18311                 m_value = *other.m_value.object;
18312                 break;
18313             }
18314
18315             case value_t::array:
18316             {
18317                 m_value = *other.m_value.array;
18318                 break;
18319             }
18320
18321             case value_t::string:
18322             {
18323                 m_value = *other.m_value.string;
18324                 break;
18325             }
18326
18327             case value_t::boolean:
18328             {
18329                 m_value = other.m_value.boolean;
18330                 break;
18331             }
18332
18333             case value_t::number_integer:
18334             {
18335                 m_value = other.m_value.number_integer;
18336                 break;
18337             }
18338
18339             case value_t::number_unsigned:
18340             {
18341                 m_value = other.m_value.number_unsigned;
18342                 break;
18343             }
18344
18345             case value_t::number_float:
18346             {
18347                 m_value = other.m_value.number_float;
18348                 break;
18349             }
18350
18351             case value_t::binary:
18352             {
18353                 m_value = *other.m_value.binary;
18354                 break;
18355             }
18356
18357             case value_t::null:
18358             case value_t::discarded:
18359             default:
18360                 break;
18361         }
18362
18363         set_parents();
18364         assert_invariant();
18365     }
18366
18367     /// @brief move constructor
18368     /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
18369     basic_json(basic_json&& other) noexcept
18370         : m_type(std::move(other.m_type)),
18371           m_value(std::move(other.m_value))
18372     {
18373         // check that passed value is valid
18374         other.assert_invariant(false);
18375
18376         // invalidate payload
18377         other.m_type = value_t::null;
18378         other.m_value = {};
18379
18380         set_parents();
18381         assert_invariant();
18382     }
18383
18384     /// @brief copy assignment
18385     /// @sa https://json.nlohmann.me/api/basic_json/operator=/
18386     basic_json& operator=(basic_json other) noexcept (
18387         std::is_nothrow_move_constructible<value_t>::value&&
18388         std::is_nothrow_move_assignable<value_t>::value&&
18389         std::is_nothrow_move_constructible<json_value>::value&&
18390         std::is_nothrow_move_assignable<json_value>::value
18391     )
18392     {
18393         // check that passed value is valid
18394         other.assert_invariant();
18395
18396         using std::swap;
18397         swap(m_type, other.m_type);
18398         swap(m_value, other.m_value);
18399
18400         set_parents();
18401         assert_invariant();
18402         return *this;
18403     }
18404
18405     /// @brief destructor
18406     /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
18407     ~basic_json() noexcept
18408     {
18409         assert_invariant(false);
18410         m_value.destroy(m_type);
18411     }
18412
18413     /// @}
18414
18415   public:
18416     ///////////////////////
18417     // object inspection //
18418     ///////////////////////
18419
18420     /// @name object inspection
18421     /// Functions to inspect the type of a JSON value.
18422     /// @{
18423
18424     /// @brief serialization
18425     /// @sa https://json.nlohmann.me/api/basic_json/dump/
18426     string_t dump(const int indent = -1,
18427                   const char indent_char = ' ',
18428                   const bool ensure_ascii = false,
18429                   const error_handler_t error_handler = error_handler_t::strict) const
18430     {
18431         string_t result;
18432         serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
18433
18434         if (indent >= 0)
18435         {
18436             s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
18437         }
18438         else
18439         {
18440             s.dump(*this, false, ensure_ascii, 0);
18441         }
18442
18443         return result;
18444     }
18445
18446     /// @brief return the type of the JSON value (explicit)
18447     /// @sa https://json.nlohmann.me/api/basic_json/type/
18448     constexpr value_t type() const noexcept
18449     {
18450         return m_type;
18451     }
18452
18453     /// @brief return whether type is primitive
18454     /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
18455     constexpr bool is_primitive() const noexcept
18456     {
18457         return is_null() || is_string() || is_boolean() || is_number() || is_binary();
18458     }
18459
18460     /// @brief return whether type is structured
18461     /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
18462     constexpr bool is_structured() const noexcept
18463     {
18464         return is_array() || is_object();
18465     }
18466
18467     /// @brief return whether value is null
18468     /// @sa https://json.nlohmann.me/api/basic_json/is_null/
18469     constexpr bool is_null() const noexcept
18470     {
18471         return m_type == value_t::null;
18472     }
18473
18474     /// @brief return whether value is a boolean
18475     /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
18476     constexpr bool is_boolean() const noexcept
18477     {
18478         return m_type == value_t::boolean;
18479     }
18480
18481     /// @brief return whether value is a number
18482     /// @sa https://json.nlohmann.me/api/basic_json/is_number/
18483     constexpr bool is_number() const noexcept
18484     {
18485         return is_number_integer() || is_number_float();
18486     }
18487
18488     /// @brief return whether value is an integer number
18489     /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
18490     constexpr bool is_number_integer() const noexcept
18491     {
18492         return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
18493     }
18494
18495     /// @brief return whether value is an unsigned integer number
18496     /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
18497     constexpr bool is_number_unsigned() const noexcept
18498     {
18499         return m_type == value_t::number_unsigned;
18500     }
18501
18502     /// @brief return whether value is a floating-point number
18503     /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
18504     constexpr bool is_number_float() const noexcept
18505     {
18506         return m_type == value_t::number_float;
18507     }
18508
18509     /// @brief return whether value is an object
18510     /// @sa https://json.nlohmann.me/api/basic_json/is_object/
18511     constexpr bool is_object() const noexcept
18512     {
18513         return m_type == value_t::object;
18514     }
18515
18516     /// @brief return whether value is an array
18517     /// @sa https://json.nlohmann.me/api/basic_json/is_array/
18518     constexpr bool is_array() const noexcept
18519     {
18520         return m_type == value_t::array;
18521     }
18522
18523     /// @brief return whether value is a string
18524     /// @sa https://json.nlohmann.me/api/basic_json/is_string/
18525     constexpr bool is_string() const noexcept
18526     {
18527         return m_type == value_t::string;
18528     }
18529
18530     /// @brief return whether value is a binary array
18531     /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
18532     constexpr bool is_binary() const noexcept
18533     {
18534         return m_type == value_t::binary;
18535     }
18536
18537     /// @brief return whether value is discarded
18538     /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
18539     constexpr bool is_discarded() const noexcept
18540     {
18541         return m_type == value_t::discarded;
18542     }
18543
18544     /// @brief return the type of the JSON value (implicit)
18545     /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
18546     constexpr operator value_t() const noexcept
18547     {
18548         return m_type;
18549     }
18550
18551     /// @}
18552
18553   private:
18554     //////////////////
18555     // value access //
18556     //////////////////
18557
18558     /// get a boolean (explicit)
18559     boolean_t get_impl(boolean_t* /*unused*/) const
18560     {
18561         if (JSON_HEDLEY_LIKELY(is_boolean()))
18562         {
18563             return m_value.boolean;
18564         }
18565
18566         JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name()), *this));
18567     }
18568
18569     /// get a pointer to the value (object)
18570     object_t* get_impl_ptr(object_t* /*unused*/) noexcept
18571     {
18572         return is_object() ? m_value.object : nullptr;
18573     }
18574
18575     /// get a pointer to the value (object)
18576     constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
18577     {
18578         return is_object() ? m_value.object : nullptr;
18579     }
18580
18581     /// get a pointer to the value (array)
18582     array_t* get_impl_ptr(array_t* /*unused*/) noexcept
18583     {
18584         return is_array() ? m_value.array : nullptr;
18585     }
18586
18587     /// get a pointer to the value (array)
18588     constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
18589     {
18590         return is_array() ? m_value.array : nullptr;
18591     }
18592
18593     /// get a pointer to the value (string)
18594     string_t* get_impl_ptr(string_t* /*unused*/) noexcept
18595     {
18596         return is_string() ? m_value.string : nullptr;
18597     }
18598
18599     /// get a pointer to the value (string)
18600     constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
18601     {
18602         return is_string() ? m_value.string : nullptr;
18603     }
18604
18605     /// get a pointer to the value (boolean)
18606     boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
18607     {
18608         return is_boolean() ? &m_value.boolean : nullptr;
18609     }
18610
18611     /// get a pointer to the value (boolean)
18612     constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
18613     {
18614         return is_boolean() ? &m_value.boolean : nullptr;
18615     }
18616
18617     /// get a pointer to the value (integer number)
18618     number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
18619     {
18620         return is_number_integer() ? &m_value.number_integer : nullptr;
18621     }
18622
18623     /// get a pointer to the value (integer number)
18624     constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
18625     {
18626         return is_number_integer() ? &m_value.number_integer : nullptr;
18627     }
18628
18629     /// get a pointer to the value (unsigned number)
18630     number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
18631     {
18632         return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
18633     }
18634
18635     /// get a pointer to the value (unsigned number)
18636     constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
18637     {
18638         return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
18639     }
18640
18641     /// get a pointer to the value (floating-point number)
18642     number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
18643     {
18644         return is_number_float() ? &m_value.number_float : nullptr;
18645     }
18646
18647     /// get a pointer to the value (floating-point number)
18648     constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
18649     {
18650         return is_number_float() ? &m_value.number_float : nullptr;
18651     }
18652
18653     /// get a pointer to the value (binary)
18654     binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
18655     {
18656         return is_binary() ? m_value.binary : nullptr;
18657     }
18658
18659     /// get a pointer to the value (binary)
18660     constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
18661     {
18662         return is_binary() ? m_value.binary : nullptr;
18663     }
18664
18665     /*!
18666     @brief helper function to implement get_ref()
18667
18668     This function helps to implement get_ref() without code duplication for
18669     const and non-const overloads
18670
18671     @tparam ThisType will be deduced as `basic_json` or `const basic_json`
18672
18673     @throw type_error.303 if ReferenceType does not match underlying value
18674     type of the current JSON
18675     */
18676     template<typename ReferenceType, typename ThisType>
18677     static ReferenceType get_ref_impl(ThisType& obj)
18678     {
18679         // delegate the call to get_ptr<>()
18680         auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
18681
18682         if (JSON_HEDLEY_LIKELY(ptr != nullptr))
18683         {
18684             return *ptr;
18685         }
18686
18687         JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
18688     }
18689
18690   public:
18691     /// @name value access
18692     /// Direct access to the stored value of a JSON value.
18693     /// @{
18694
18695     /// @brief get a pointer value (implicit)
18696     /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
18697     template<typename PointerType, typename std::enable_if<
18698                  std::is_pointer<PointerType>::value, int>::type = 0>
18699     auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
18700     {
18701         // delegate the call to get_impl_ptr<>()
18702         return get_impl_ptr(static_cast<PointerType>(nullptr));
18703     }
18704
18705     /// @brief get a pointer value (implicit)
18706     /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
18707     template < typename PointerType, typename std::enable_if <
18708                    std::is_pointer<PointerType>::value&&
18709                    std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
18710     constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
18711     {
18712         // delegate the call to get_impl_ptr<>() const
18713         return get_impl_ptr(static_cast<PointerType>(nullptr));
18714     }
18715
18716   private:
18717     /*!
18718     @brief get a value (explicit)
18719
18720     Explicit type conversion between the JSON value and a compatible value
18721     which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
18722     and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
18723     The value is converted by calling the @ref json_serializer<ValueType>
18724     `from_json()` method.
18725
18726     The function is equivalent to executing
18727     @code {.cpp}
18728     ValueType ret;
18729     JSONSerializer<ValueType>::from_json(*this, ret);
18730     return ret;
18731     @endcode
18732
18733     This overloads is chosen if:
18734     - @a ValueType is not @ref basic_json,
18735     - @ref json_serializer<ValueType> has a `from_json()` method of the form
18736       `void from_json(const basic_json&, ValueType&)`, and
18737     - @ref json_serializer<ValueType> does not have a `from_json()` method of
18738       the form `ValueType from_json(const basic_json&)`
18739
18740     @tparam ValueType the returned value type
18741
18742     @return copy of the JSON value, converted to @a ValueType
18743
18744     @throw what @ref json_serializer<ValueType> `from_json()` method throws
18745
18746     @liveexample{The example below shows several conversions from JSON values
18747     to other types. There a few things to note: (1) Floating-point numbers can
18748     be converted to integers\, (2) A JSON array can be converted to a standard
18749     `std::vector<short>`\, (3) A JSON object can be converted to C++
18750     associative containers such as `std::unordered_map<std::string\,
18751     json>`.,get__ValueType_const}
18752
18753     @since version 2.1.0
18754     */
18755     template < typename ValueType,
18756                detail::enable_if_t <
18757                    detail::is_default_constructible<ValueType>::value&&
18758                    detail::has_from_json<basic_json_t, ValueType>::value,
18759                    int > = 0 >
18760     ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
18761                 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
18762     {
18763         auto ret = ValueType();
18764         JSONSerializer<ValueType>::from_json(*this, ret);
18765         return ret;
18766     }
18767
18768     /*!
18769     @brief get a value (explicit); special case
18770
18771     Explicit type conversion between the JSON value and a compatible value
18772     which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
18773     and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
18774     The value is converted by calling the @ref json_serializer<ValueType>
18775     `from_json()` method.
18776
18777     The function is equivalent to executing
18778     @code {.cpp}
18779     return JSONSerializer<ValueType>::from_json(*this);
18780     @endcode
18781
18782     This overloads is chosen if:
18783     - @a ValueType is not @ref basic_json and
18784     - @ref json_serializer<ValueType> has a `from_json()` method of the form
18785       `ValueType from_json(const basic_json&)`
18786
18787     @note If @ref json_serializer<ValueType> has both overloads of
18788     `from_json()`, this one is chosen.
18789
18790     @tparam ValueType the returned value type
18791
18792     @return copy of the JSON value, converted to @a ValueType
18793
18794     @throw what @ref json_serializer<ValueType> `from_json()` method throws
18795
18796     @since version 2.1.0
18797     */
18798     template < typename ValueType,
18799                detail::enable_if_t <
18800                    detail::has_non_default_from_json<basic_json_t, ValueType>::value,
18801                    int > = 0 >
18802     ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
18803                 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
18804     {
18805         return JSONSerializer<ValueType>::from_json(*this);
18806     }
18807
18808     /*!
18809     @brief get special-case overload
18810
18811     This overloads converts the current @ref basic_json in a different
18812     @ref basic_json type
18813
18814     @tparam BasicJsonType == @ref basic_json
18815
18816     @return a copy of *this, converted into @a BasicJsonType
18817
18818     @complexity Depending on the implementation of the called `from_json()`
18819                 method.
18820
18821     @since version 3.2.0
18822     */
18823     template < typename BasicJsonType,
18824                detail::enable_if_t <
18825                    detail::is_basic_json<BasicJsonType>::value,
18826                    int > = 0 >
18827     BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
18828     {
18829         return *this;
18830     }
18831
18832     /*!
18833     @brief get special-case overload
18834
18835     This overloads avoids a lot of template boilerplate, it can be seen as the
18836     identity method
18837
18838     @tparam BasicJsonType == @ref basic_json
18839
18840     @return a copy of *this
18841
18842     @complexity Constant.
18843
18844     @since version 2.1.0
18845     */
18846     template<typename BasicJsonType,
18847              detail::enable_if_t<
18848                  std::is_same<BasicJsonType, basic_json_t>::value,
18849                  int> = 0>
18850     basic_json get_impl(detail::priority_tag<3> /*unused*/) const
18851     {
18852         return *this;
18853     }
18854
18855     /*!
18856     @brief get a pointer value (explicit)
18857     @copydoc get()
18858     */
18859     template<typename PointerType,
18860              detail::enable_if_t<
18861                  std::is_pointer<PointerType>::value,
18862                  int> = 0>
18863     constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
18864     -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
18865     {
18866         // delegate the call to get_ptr
18867         return get_ptr<PointerType>();
18868     }
18869
18870   public:
18871     /*!
18872     @brief get a (pointer) value (explicit)
18873
18874     Performs explicit type conversion between the JSON value and a compatible value if required.
18875
18876     - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
18877     No copies are made.
18878
18879     - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
18880     from the current @ref basic_json.
18881
18882     - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
18883     method.
18884
18885     @tparam ValueTypeCV the provided value type
18886     @tparam ValueType the returned value type
18887
18888     @return copy of the JSON value, converted to @tparam ValueType if necessary
18889
18890     @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
18891
18892     @since version 2.1.0
18893     */
18894     template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
18895 #if defined(JSON_HAS_CPP_14)
18896     constexpr
18897 #endif
18898     auto get() const noexcept(
18899     noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
18900     -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
18901     {
18902         // we cannot static_assert on ValueTypeCV being non-const, because
18903         // there is support for get<const basic_json_t>(), which is why we
18904         // still need the uncvref
18905         static_assert(!std::is_reference<ValueTypeCV>::value,
18906                       "get() cannot be used with reference types, you might want to use get_ref()");
18907         return get_impl<ValueType>(detail::priority_tag<4> {});
18908     }
18909
18910     /*!
18911     @brief get a pointer value (explicit)
18912
18913     Explicit pointer access to the internally stored JSON value. No copies are
18914     made.
18915
18916     @warning The pointer becomes invalid if the underlying JSON object
18917     changes.
18918
18919     @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
18920     object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
18921     @ref number_unsigned_t, or @ref number_float_t.
18922
18923     @return pointer to the internally stored JSON value if the requested
18924     pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
18925
18926     @complexity Constant.
18927
18928     @liveexample{The example below shows how pointers to internal values of a
18929     JSON value can be requested. Note that no type conversions are made and a
18930     `nullptr` is returned if the value and the requested pointer type does not
18931     match.,get__PointerType}
18932
18933     @sa see @ref get_ptr() for explicit pointer-member access
18934
18935     @since version 1.0.0
18936     */
18937     template<typename PointerType, typename std::enable_if<
18938                  std::is_pointer<PointerType>::value, int>::type = 0>
18939     auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
18940     {
18941         // delegate the call to get_ptr
18942         return get_ptr<PointerType>();
18943     }
18944
18945     /// @brief get a value (explicit)
18946     /// @sa https://json.nlohmann.me/api/basic_json/get_to/
18947     template < typename ValueType,
18948                detail::enable_if_t <
18949                    !detail::is_basic_json<ValueType>::value&&
18950                    detail::has_from_json<basic_json_t, ValueType>::value,
18951                    int > = 0 >
18952     ValueType & get_to(ValueType& v) const noexcept(noexcept(
18953                 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
18954     {
18955         JSONSerializer<ValueType>::from_json(*this, v);
18956         return v;
18957     }
18958
18959     // specialization to allow calling get_to with a basic_json value
18960     // see https://github.com/nlohmann/json/issues/2175
18961     template<typename ValueType,
18962              detail::enable_if_t <
18963                  detail::is_basic_json<ValueType>::value,
18964                  int> = 0>
18965     ValueType & get_to(ValueType& v) const
18966     {
18967         v = *this;
18968         return v;
18969     }
18970
18971     template <
18972         typename T, std::size_t N,
18973         typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
18974         detail::enable_if_t <
18975             detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
18976     Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
18977     noexcept(noexcept(JSONSerializer<Array>::from_json(
18978                           std::declval<const basic_json_t&>(), v)))
18979     {
18980         JSONSerializer<Array>::from_json(*this, v);
18981         return v;
18982     }
18983
18984     /// @brief get a reference value (implicit)
18985     /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
18986     template<typename ReferenceType, typename std::enable_if<
18987                  std::is_reference<ReferenceType>::value, int>::type = 0>
18988     ReferenceType get_ref()
18989     {
18990         // delegate call to get_ref_impl
18991         return get_ref_impl<ReferenceType>(*this);
18992     }
18993
18994     /// @brief get a reference value (implicit)
18995     /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
18996     template < typename ReferenceType, typename std::enable_if <
18997                    std::is_reference<ReferenceType>::value&&
18998                    std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
18999     ReferenceType get_ref() const
19000     {
19001         // delegate call to get_ref_impl
19002         return get_ref_impl<ReferenceType>(*this);
19003     }
19004
19005     /*!
19006     @brief get a value (implicit)
19007
19008     Implicit type conversion between the JSON value and a compatible value.
19009     The call is realized by calling @ref get() const.
19010
19011     @tparam ValueType non-pointer type compatible to the JSON value, for
19012     instance `int` for JSON integer numbers, `bool` for JSON booleans, or
19013     `std::vector` types for JSON arrays. The character type of @ref string_t
19014     as well as an initializer list of this type is excluded to avoid
19015     ambiguities as these types implicitly convert to `std::string`.
19016
19017     @return copy of the JSON value, converted to type @a ValueType
19018
19019     @throw type_error.302 in case passed type @a ValueType is incompatible
19020     to the JSON value type (e.g., the JSON value is of type boolean, but a
19021     string is requested); see example below
19022
19023     @complexity Linear in the size of the JSON value.
19024
19025     @liveexample{The example below shows several conversions from JSON values
19026     to other types. There a few things to note: (1) Floating-point numbers can
19027     be converted to integers\, (2) A JSON array can be converted to a standard
19028     `std::vector<short>`\, (3) A JSON object can be converted to C++
19029     associative containers such as `std::unordered_map<std::string\,
19030     json>`.,operator__ValueType}
19031
19032     @since version 1.0.0
19033     */
19034     template < typename ValueType, typename std::enable_if <
19035                    detail::conjunction <
19036                        detail::negation<std::is_pointer<ValueType>>,
19037                        detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
19038                                         detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
19039                                         detail::negation<detail::is_basic_json<ValueType>>,
19040                                         detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
19041
19042 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
19043                                                 detail::negation<std::is_same<ValueType, std::string_view>>,
19044 #endif
19045                                                 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
19046                                                 >::value, int >::type = 0 >
19047                                         JSON_EXPLICIT operator ValueType() const
19048     {
19049         // delegate the call to get<>() const
19050         return get<ValueType>();
19051     }
19052
19053     /// @brief get a binary value
19054     /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
19055     binary_t& get_binary()
19056     {
19057         if (!is_binary())
19058         {
19059             JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
19060         }
19061
19062         return *get_ptr<binary_t*>();
19063     }
19064
19065     /// @brief get a binary value
19066     /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
19067     const binary_t& get_binary() const
19068     {
19069         if (!is_binary())
19070         {
19071             JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
19072         }
19073
19074         return *get_ptr<const binary_t*>();
19075     }
19076
19077     /// @}
19078
19079
19080     ////////////////////
19081     // element access //
19082     ////////////////////
19083
19084     /// @name element access
19085     /// Access to the JSON value.
19086     /// @{
19087
19088     /// @brief access specified array element with bounds checking
19089     /// @sa https://json.nlohmann.me/api/basic_json/at/
19090     reference at(size_type idx)
19091     {
19092         // at only works for arrays
19093         if (JSON_HEDLEY_LIKELY(is_array()))
19094         {
19095             JSON_TRY
19096             {
19097                 return set_parent(m_value.array->at(idx));
19098             }
19099             JSON_CATCH (std::out_of_range&)
19100             {
19101                 // create better exception explanation
19102                 JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
19103             }
19104         }
19105         else
19106         {
19107             JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19108         }
19109     }
19110
19111     /// @brief access specified array element with bounds checking
19112     /// @sa https://json.nlohmann.me/api/basic_json/at/
19113     const_reference at(size_type idx) const
19114     {
19115         // at only works for arrays
19116         if (JSON_HEDLEY_LIKELY(is_array()))
19117         {
19118             JSON_TRY
19119             {
19120                 return m_value.array->at(idx);
19121             }
19122             JSON_CATCH (std::out_of_range&)
19123             {
19124                 // create better exception explanation
19125                 JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
19126             }
19127         }
19128         else
19129         {
19130             JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19131         }
19132     }
19133
19134     /// @brief access specified object element with bounds checking
19135     /// @sa https://json.nlohmann.me/api/basic_json/at/
19136     reference at(const typename object_t::key_type& key)
19137     {
19138         // at only works for objects
19139         if (JSON_HEDLEY_LIKELY(is_object()))
19140         {
19141             JSON_TRY
19142             {
19143                 return set_parent(m_value.object->at(key));
19144             }
19145             JSON_CATCH (std::out_of_range&)
19146             {
19147                 // create better exception explanation
19148                 JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
19149             }
19150         }
19151         else
19152         {
19153             JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19154         }
19155     }
19156
19157     /// @brief access specified object element with bounds checking
19158     /// @sa https://json.nlohmann.me/api/basic_json/at/
19159     const_reference at(const typename object_t::key_type& key) const
19160     {
19161         // at only works for objects
19162         if (JSON_HEDLEY_LIKELY(is_object()))
19163         {
19164             JSON_TRY
19165             {
19166                 return m_value.object->at(key);
19167             }
19168             JSON_CATCH (std::out_of_range&)
19169             {
19170                 // create better exception explanation
19171                 JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
19172             }
19173         }
19174         else
19175         {
19176             JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
19177         }
19178     }
19179
19180     /// @brief access specified array element
19181     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19182     reference operator[](size_type idx)
19183     {
19184         // implicitly convert null value to an empty array
19185         if (is_null())
19186         {
19187             m_type = value_t::array;
19188             m_value.array = create<array_t>();
19189             assert_invariant();
19190         }
19191
19192         // operator[] only works for arrays
19193         if (JSON_HEDLEY_LIKELY(is_array()))
19194         {
19195             // fill up array with null values if given idx is outside range
19196             if (idx >= m_value.array->size())
19197             {
19198 #if JSON_DIAGNOSTICS
19199                 // remember array size & capacity before resizing
19200                 const auto old_size = m_value.array->size();
19201                 const auto old_capacity = m_value.array->capacity();
19202 #endif
19203                 m_value.array->resize(idx + 1);
19204
19205 #if JSON_DIAGNOSTICS
19206                 if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
19207                 {
19208                     // capacity has changed: update all parents
19209                     set_parents();
19210                 }
19211                 else
19212                 {
19213                     // set parent for values added above
19214                     set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
19215                 }
19216 #endif
19217                 assert_invariant();
19218             }
19219
19220             return m_value.array->operator[](idx);
19221         }
19222
19223         JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
19224     }
19225
19226     /// @brief access specified array element
19227     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19228     const_reference operator[](size_type idx) const
19229     {
19230         // const operator[] only works for arrays
19231         if (JSON_HEDLEY_LIKELY(is_array()))
19232         {
19233             return m_value.array->operator[](idx);
19234         }
19235
19236         JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
19237     }
19238
19239     /// @brief access specified object element
19240     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19241     reference operator[](const typename object_t::key_type& key)
19242     {
19243         // implicitly convert null value to an empty object
19244         if (is_null())
19245         {
19246             m_type = value_t::object;
19247             m_value.object = create<object_t>();
19248             assert_invariant();
19249         }
19250
19251         // operator[] only works for objects
19252         if (JSON_HEDLEY_LIKELY(is_object()))
19253         {
19254             return set_parent(m_value.object->operator[](key));
19255         }
19256
19257         JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19258     }
19259
19260     /// @brief access specified object element
19261     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19262     const_reference operator[](const typename object_t::key_type& key) const
19263     {
19264         // const operator[] only works for objects
19265         if (JSON_HEDLEY_LIKELY(is_object()))
19266         {
19267             JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
19268             return m_value.object->find(key)->second;
19269         }
19270
19271         JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19272     }
19273
19274     /// @brief access specified object element
19275     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19276     template<typename T>
19277     JSON_HEDLEY_NON_NULL(2)
19278     reference operator[](T* key)
19279     {
19280         // implicitly convert null to object
19281         if (is_null())
19282         {
19283             m_type = value_t::object;
19284             m_value = value_t::object;
19285             assert_invariant();
19286         }
19287
19288         // at only works for objects
19289         if (JSON_HEDLEY_LIKELY(is_object()))
19290         {
19291             return set_parent(m_value.object->operator[](key));
19292         }
19293
19294         JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19295     }
19296
19297     /// @brief access specified object element
19298     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
19299     template<typename T>
19300     JSON_HEDLEY_NON_NULL(2)
19301     const_reference operator[](T* key) const
19302     {
19303         // at only works for objects
19304         if (JSON_HEDLEY_LIKELY(is_object()))
19305         {
19306             JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
19307             return m_value.object->find(key)->second;
19308         }
19309
19310         JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
19311     }
19312
19313     /// @brief access specified object element with default value
19314     /// @sa https://json.nlohmann.me/api/basic_json/value/
19315     /// using std::is_convertible in a std::enable_if will fail when using explicit conversions
19316     template < class ValueType, typename std::enable_if <
19317                    detail::is_getable<basic_json_t, ValueType>::value
19318                    && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
19319     ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
19320     {
19321         // at only works for objects
19322         if (JSON_HEDLEY_LIKELY(is_object()))
19323         {
19324             // if key is found, return value and given default value otherwise
19325             const auto it = find(key);
19326             if (it != end())
19327             {
19328                 return it->template get<ValueType>();
19329             }
19330
19331             return default_value;
19332         }
19333
19334         JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
19335     }
19336
19337     /// @brief access specified object element with default value
19338     /// @sa https://json.nlohmann.me/api/basic_json/value/
19339     /// overload for a default value of type const char*
19340     string_t value(const typename object_t::key_type& key, const char* default_value) const
19341     {
19342         return value(key, string_t(default_value));
19343     }
19344
19345     /// @brief access specified object element via JSON Pointer with default value
19346     /// @sa https://json.nlohmann.me/api/basic_json/value/
19347     template<class ValueType, typename std::enable_if<
19348                  detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
19349     ValueType value(const json_pointer& ptr, const ValueType& default_value) const
19350     {
19351         // at only works for objects
19352         if (JSON_HEDLEY_LIKELY(is_object()))
19353         {
19354             // if pointer resolves a value, return it or use default value
19355             JSON_TRY
19356             {
19357                 return ptr.get_checked(this).template get<ValueType>();
19358             }
19359             JSON_INTERNAL_CATCH (out_of_range&)
19360             {
19361                 return default_value;
19362             }
19363         }
19364
19365         JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
19366     }
19367
19368     /// @brief access specified object element via JSON Pointer with default value
19369     /// @sa https://json.nlohmann.me/api/basic_json/value/
19370     /// overload for a default value of type const char*
19371     JSON_HEDLEY_NON_NULL(3)
19372     string_t value(const json_pointer& ptr, const char* default_value) const
19373     {
19374         return value(ptr, string_t(default_value));
19375     }
19376
19377     /// @brief access the first element
19378     /// @sa https://json.nlohmann.me/api/basic_json/front/
19379     reference front()
19380     {
19381         return *begin();
19382     }
19383
19384     /// @brief access the first element
19385     /// @sa https://json.nlohmann.me/api/basic_json/front/
19386     const_reference front() const
19387     {
19388         return *cbegin();
19389     }
19390
19391     /// @brief access the last element
19392     /// @sa https://json.nlohmann.me/api/basic_json/back/
19393     reference back()
19394     {
19395         auto tmp = end();
19396         --tmp;
19397         return *tmp;
19398     }
19399
19400     /// @brief access the last element
19401     /// @sa https://json.nlohmann.me/api/basic_json/back/
19402     const_reference back() const
19403     {
19404         auto tmp = cend();
19405         --tmp;
19406         return *tmp;
19407     }
19408
19409     /// @brief remove element given an iterator
19410     /// @sa https://json.nlohmann.me/api/basic_json/erase/
19411     template < class IteratorType, typename std::enable_if <
19412                    std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
19413                    std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
19414                = 0 >
19415     IteratorType erase(IteratorType pos)
19416     {
19417         // make sure iterator fits the current value
19418         if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
19419         {
19420             JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
19421         }
19422
19423         IteratorType result = end();
19424
19425         switch (m_type)
19426         {
19427             case value_t::boolean:
19428             case value_t::number_float:
19429             case value_t::number_integer:
19430             case value_t::number_unsigned:
19431             case value_t::string:
19432             case value_t::binary:
19433             {
19434                 if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
19435                 {
19436                     JSON_THROW(invalid_iterator::create(205, "iterator out of range", *this));
19437                 }
19438
19439                 if (is_string())
19440                 {
19441                     AllocatorType<string_t> alloc;
19442                     std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
19443                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
19444                     m_value.string = nullptr;
19445                 }
19446                 else if (is_binary())
19447                 {
19448                     AllocatorType<binary_t> alloc;
19449                     std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
19450                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
19451                     m_value.binary = nullptr;
19452                 }
19453
19454                 m_type = value_t::null;
19455                 assert_invariant();
19456                 break;
19457             }
19458
19459             case value_t::object:
19460             {
19461                 result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
19462                 break;
19463             }
19464
19465             case value_t::array:
19466             {
19467                 result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
19468                 break;
19469             }
19470
19471             case value_t::null:
19472             case value_t::discarded:
19473             default:
19474                 JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19475         }
19476
19477         return result;
19478     }
19479
19480     /// @brief remove elements given an iterator range
19481     /// @sa https://json.nlohmann.me/api/basic_json/erase/
19482     template < class IteratorType, typename std::enable_if <
19483                    std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
19484                    std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
19485                = 0 >
19486     IteratorType erase(IteratorType first, IteratorType last)
19487     {
19488         // make sure iterator fits the current value
19489         if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
19490         {
19491             JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", *this));
19492         }
19493
19494         IteratorType result = end();
19495
19496         switch (m_type)
19497         {
19498             case value_t::boolean:
19499             case value_t::number_float:
19500             case value_t::number_integer:
19501             case value_t::number_unsigned:
19502             case value_t::string:
19503             case value_t::binary:
19504             {
19505                 if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
19506                                        || !last.m_it.primitive_iterator.is_end()))
19507                 {
19508                     JSON_THROW(invalid_iterator::create(204, "iterators out of range", *this));
19509                 }
19510
19511                 if (is_string())
19512                 {
19513                     AllocatorType<string_t> alloc;
19514                     std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
19515                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
19516                     m_value.string = nullptr;
19517                 }
19518                 else if (is_binary())
19519                 {
19520                     AllocatorType<binary_t> alloc;
19521                     std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
19522                     std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
19523                     m_value.binary = nullptr;
19524                 }
19525
19526                 m_type = value_t::null;
19527                 assert_invariant();
19528                 break;
19529             }
19530
19531             case value_t::object:
19532             {
19533                 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
19534                                               last.m_it.object_iterator);
19535                 break;
19536             }
19537
19538             case value_t::array:
19539             {
19540                 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
19541                                              last.m_it.array_iterator);
19542                 break;
19543             }
19544
19545             case value_t::null:
19546             case value_t::discarded:
19547             default:
19548                 JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19549         }
19550
19551         return result;
19552     }
19553
19554     /// @brief remove element from a JSON object given a key
19555     /// @sa https://json.nlohmann.me/api/basic_json/erase/
19556     size_type erase(const typename object_t::key_type& key)
19557     {
19558         // this erase only works for objects
19559         if (JSON_HEDLEY_LIKELY(is_object()))
19560         {
19561             return m_value.object->erase(key);
19562         }
19563
19564         JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19565     }
19566
19567     /// @brief remove element from a JSON array given an index
19568     /// @sa https://json.nlohmann.me/api/basic_json/erase/
19569     void erase(const size_type idx)
19570     {
19571         // this erase only works for arrays
19572         if (JSON_HEDLEY_LIKELY(is_array()))
19573         {
19574             if (JSON_HEDLEY_UNLIKELY(idx >= size()))
19575             {
19576                 JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
19577             }
19578
19579             m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
19580         }
19581         else
19582         {
19583             JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
19584         }
19585     }
19586
19587     /// @}
19588
19589
19590     ////////////
19591     // lookup //
19592     ////////////
19593
19594     /// @name lookup
19595     /// @{
19596
19597     /// @brief find an element in a JSON object
19598     /// @sa https://json.nlohmann.me/api/basic_json/find/
19599     template<typename KeyT>
19600     iterator find(KeyT&& key)
19601     {
19602         auto result = end();
19603
19604         if (is_object())
19605         {
19606             result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
19607         }
19608
19609         return result;
19610     }
19611
19612     /// @brief find an element in a JSON object
19613     /// @sa https://json.nlohmann.me/api/basic_json/find/
19614     template<typename KeyT>
19615     const_iterator find(KeyT&& key) const
19616     {
19617         auto result = cend();
19618
19619         if (is_object())
19620         {
19621             result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
19622         }
19623
19624         return result;
19625     }
19626
19627     /// @brief returns the number of occurrences of a key in a JSON object
19628     /// @sa https://json.nlohmann.me/api/basic_json/count/
19629     template<typename KeyT>
19630     size_type count(KeyT&& key) const
19631     {
19632         // return 0 for all nonobject types
19633         return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
19634     }
19635
19636     /// @brief check the existence of an element in a JSON object
19637     /// @sa https://json.nlohmann.me/api/basic_json/contains/
19638     template < typename KeyT, typename std::enable_if <
19639                    !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
19640     bool contains(KeyT && key) const
19641     {
19642         return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
19643     }
19644
19645     /// @brief check the existence of an element in a JSON object given a JSON pointer
19646     /// @sa https://json.nlohmann.me/api/basic_json/contains/
19647     bool contains(const json_pointer& ptr) const
19648     {
19649         return ptr.contains(this);
19650     }
19651
19652     /// @}
19653
19654
19655     ///////////////
19656     // iterators //
19657     ///////////////
19658
19659     /// @name iterators
19660     /// @{
19661
19662     /// @brief returns an iterator to the first element
19663     /// @sa https://json.nlohmann.me/api/basic_json/begin/
19664     iterator begin() noexcept
19665     {
19666         iterator result(this);
19667         result.set_begin();
19668         return result;
19669     }
19670
19671     /// @brief returns an iterator to the first element
19672     /// @sa https://json.nlohmann.me/api/basic_json/begin/
19673     const_iterator begin() const noexcept
19674     {
19675         return cbegin();
19676     }
19677
19678     /// @brief returns a const iterator to the first element
19679     /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
19680     const_iterator cbegin() const noexcept
19681     {
19682         const_iterator result(this);
19683         result.set_begin();
19684         return result;
19685     }
19686
19687     /// @brief returns an iterator to one past the last element
19688     /// @sa https://json.nlohmann.me/api/basic_json/end/
19689     iterator end() noexcept
19690     {
19691         iterator result(this);
19692         result.set_end();
19693         return result;
19694     }
19695
19696     /// @brief returns an iterator to one past the last element
19697     /// @sa https://json.nlohmann.me/api/basic_json/end/
19698     const_iterator end() const noexcept
19699     {
19700         return cend();
19701     }
19702
19703     /// @brief returns an iterator to one past the last element
19704     /// @sa https://json.nlohmann.me/api/basic_json/cend/
19705     const_iterator cend() const noexcept
19706     {
19707         const_iterator result(this);
19708         result.set_end();
19709         return result;
19710     }
19711
19712     /// @brief returns an iterator to the reverse-beginning
19713     /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
19714     reverse_iterator rbegin() noexcept
19715     {
19716         return reverse_iterator(end());
19717     }
19718
19719     /// @brief returns an iterator to the reverse-beginning
19720     /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
19721     const_reverse_iterator rbegin() const noexcept
19722     {
19723         return crbegin();
19724     }
19725
19726     /// @brief returns an iterator to the reverse-end
19727     /// @sa https://json.nlohmann.me/api/basic_json/rend/
19728     reverse_iterator rend() noexcept
19729     {
19730         return reverse_iterator(begin());
19731     }
19732
19733     /// @brief returns an iterator to the reverse-end
19734     /// @sa https://json.nlohmann.me/api/basic_json/rend/
19735     const_reverse_iterator rend() const noexcept
19736     {
19737         return crend();
19738     }
19739
19740     /// @brief returns a const reverse iterator to the last element
19741     /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
19742     const_reverse_iterator crbegin() const noexcept
19743     {
19744         return const_reverse_iterator(cend());
19745     }
19746
19747     /// @brief returns a const reverse iterator to one before the first
19748     /// @sa https://json.nlohmann.me/api/basic_json/crend/
19749     const_reverse_iterator crend() const noexcept
19750     {
19751         return const_reverse_iterator(cbegin());
19752     }
19753
19754   public:
19755     /// @brief wrapper to access iterator member functions in range-based for
19756     /// @sa https://json.nlohmann.me/api/basic_json/items/
19757     /// @deprecated This function is deprecated since 3.1.0 and will be removed in
19758     ///             version 4.0.0 of the library. Please use @ref items() instead;
19759     ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
19760     JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
19761     static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
19762     {
19763         return ref.items();
19764     }
19765
19766     /// @brief wrapper to access iterator member functions in range-based for
19767     /// @sa https://json.nlohmann.me/api/basic_json/items/
19768     /// @deprecated This function is deprecated since 3.1.0 and will be removed in
19769     ///         version 4.0.0 of the library. Please use @ref items() instead;
19770     ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
19771     JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
19772     static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
19773     {
19774         return ref.items();
19775     }
19776
19777     /// @brief helper to access iterator member functions in range-based for
19778     /// @sa https://json.nlohmann.me/api/basic_json/items/
19779     iteration_proxy<iterator> items() noexcept
19780     {
19781         return iteration_proxy<iterator>(*this);
19782     }
19783
19784     /// @brief helper to access iterator member functions in range-based for
19785     /// @sa https://json.nlohmann.me/api/basic_json/items/
19786     iteration_proxy<const_iterator> items() const noexcept
19787     {
19788         return iteration_proxy<const_iterator>(*this);
19789     }
19790
19791     /// @}
19792
19793
19794     //////////////
19795     // capacity //
19796     //////////////
19797
19798     /// @name capacity
19799     /// @{
19800
19801     /// @brief checks whether the container is empty.
19802     /// @sa https://json.nlohmann.me/api/basic_json/empty/
19803     bool empty() const noexcept
19804     {
19805         switch (m_type)
19806         {
19807             case value_t::null:
19808             {
19809                 // null values are empty
19810                 return true;
19811             }
19812
19813             case value_t::array:
19814             {
19815                 // delegate call to array_t::empty()
19816                 return m_value.array->empty();
19817             }
19818
19819             case value_t::object:
19820             {
19821                 // delegate call to object_t::empty()
19822                 return m_value.object->empty();
19823             }
19824
19825             case value_t::string:
19826             case value_t::boolean:
19827             case value_t::number_integer:
19828             case value_t::number_unsigned:
19829             case value_t::number_float:
19830             case value_t::binary:
19831             case value_t::discarded:
19832             default:
19833             {
19834                 // all other types are nonempty
19835                 return false;
19836             }
19837         }
19838     }
19839
19840     /// @brief returns the number of elements
19841     /// @sa https://json.nlohmann.me/api/basic_json/size/
19842     size_type size() const noexcept
19843     {
19844         switch (m_type)
19845         {
19846             case value_t::null:
19847             {
19848                 // null values are empty
19849                 return 0;
19850             }
19851
19852             case value_t::array:
19853             {
19854                 // delegate call to array_t::size()
19855                 return m_value.array->size();
19856             }
19857
19858             case value_t::object:
19859             {
19860                 // delegate call to object_t::size()
19861                 return m_value.object->size();
19862             }
19863
19864             case value_t::string:
19865             case value_t::boolean:
19866             case value_t::number_integer:
19867             case value_t::number_unsigned:
19868             case value_t::number_float:
19869             case value_t::binary:
19870             case value_t::discarded:
19871             default:
19872             {
19873                 // all other types have size 1
19874                 return 1;
19875             }
19876         }
19877     }
19878
19879     /// @brief returns the maximum possible number of elements
19880     /// @sa https://json.nlohmann.me/api/basic_json/max_size/
19881     size_type max_size() const noexcept
19882     {
19883         switch (m_type)
19884         {
19885             case value_t::array:
19886             {
19887                 // delegate call to array_t::max_size()
19888                 return m_value.array->max_size();
19889             }
19890
19891             case value_t::object:
19892             {
19893                 // delegate call to object_t::max_size()
19894                 return m_value.object->max_size();
19895             }
19896
19897             case value_t::null:
19898             case value_t::string:
19899             case value_t::boolean:
19900             case value_t::number_integer:
19901             case value_t::number_unsigned:
19902             case value_t::number_float:
19903             case value_t::binary:
19904             case value_t::discarded:
19905             default:
19906             {
19907                 // all other types have max_size() == size()
19908                 return size();
19909             }
19910         }
19911     }
19912
19913     /// @}
19914
19915
19916     ///////////////
19917     // modifiers //
19918     ///////////////
19919
19920     /// @name modifiers
19921     /// @{
19922
19923     /// @brief clears the contents
19924     /// @sa https://json.nlohmann.me/api/basic_json/clear/
19925     void clear() noexcept
19926     {
19927         switch (m_type)
19928         {
19929             case value_t::number_integer:
19930             {
19931                 m_value.number_integer = 0;
19932                 break;
19933             }
19934
19935             case value_t::number_unsigned:
19936             {
19937                 m_value.number_unsigned = 0;
19938                 break;
19939             }
19940
19941             case value_t::number_float:
19942             {
19943                 m_value.number_float = 0.0;
19944                 break;
19945             }
19946
19947             case value_t::boolean:
19948             {
19949                 m_value.boolean = false;
19950                 break;
19951             }
19952
19953             case value_t::string:
19954             {
19955                 m_value.string->clear();
19956                 break;
19957             }
19958
19959             case value_t::binary:
19960             {
19961                 m_value.binary->clear();
19962                 break;
19963             }
19964
19965             case value_t::array:
19966             {
19967                 m_value.array->clear();
19968                 break;
19969             }
19970
19971             case value_t::object:
19972             {
19973                 m_value.object->clear();
19974                 break;
19975             }
19976
19977             case value_t::null:
19978             case value_t::discarded:
19979             default:
19980                 break;
19981         }
19982     }
19983
19984     /// @brief add an object to an array
19985     /// @sa https://json.nlohmann.me/api/basic_json/push_back/
19986     void push_back(basic_json&& val)
19987     {
19988         // push_back only works for null objects or arrays
19989         if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
19990         {
19991             JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
19992         }
19993
19994         // transform null object into an array
19995         if (is_null())
19996         {
19997             m_type = value_t::array;
19998             m_value = value_t::array;
19999             assert_invariant();
20000         }
20001
20002         // add element to array (move semantics)
20003         const auto old_capacity = m_value.array->capacity();
20004         m_value.array->push_back(std::move(val));
20005         set_parent(m_value.array->back(), old_capacity);
20006         // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
20007     }
20008
20009     /// @brief add an object to an array
20010     /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20011     reference operator+=(basic_json&& val)
20012     {
20013         push_back(std::move(val));
20014         return *this;
20015     }
20016
20017     /// @brief add an object to an array
20018     /// @sa https://json.nlohmann.me/api/basic_json/push_back/
20019     void push_back(const basic_json& val)
20020     {
20021         // push_back only works for null objects or arrays
20022         if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
20023         {
20024             JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
20025         }
20026
20027         // transform null object into an array
20028         if (is_null())
20029         {
20030             m_type = value_t::array;
20031             m_value = value_t::array;
20032             assert_invariant();
20033         }
20034
20035         // add element to array
20036         const auto old_capacity = m_value.array->capacity();
20037         m_value.array->push_back(val);
20038         set_parent(m_value.array->back(), old_capacity);
20039     }
20040
20041     /// @brief add an object to an array
20042     /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20043     reference operator+=(const basic_json& val)
20044     {
20045         push_back(val);
20046         return *this;
20047     }
20048
20049     /// @brief add an object to an object
20050     /// @sa https://json.nlohmann.me/api/basic_json/push_back/
20051     void push_back(const typename object_t::value_type& val)
20052     {
20053         // push_back only works for null objects or objects
20054         if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
20055         {
20056             JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
20057         }
20058
20059         // transform null object into an object
20060         if (is_null())
20061         {
20062             m_type = value_t::object;
20063             m_value = value_t::object;
20064             assert_invariant();
20065         }
20066
20067         // add element to object
20068         auto res = m_value.object->insert(val);
20069         set_parent(res.first->second);
20070     }
20071
20072     /// @brief add an object to an object
20073     /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20074     reference operator+=(const typename object_t::value_type& val)
20075     {
20076         push_back(val);
20077         return *this;
20078     }
20079
20080     /// @brief add an object to an object
20081     /// @sa https://json.nlohmann.me/api/basic_json/push_back/
20082     void push_back(initializer_list_t init)
20083     {
20084         if (is_object() && init.size() == 2 && (*init.begin())->is_string())
20085         {
20086             basic_json&& key = init.begin()->moved_or_copied();
20087             push_back(typename object_t::value_type(
20088                           std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
20089         }
20090         else
20091         {
20092             push_back(basic_json(init));
20093         }
20094     }
20095
20096     /// @brief add an object to an object
20097     /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
20098     reference operator+=(initializer_list_t init)
20099     {
20100         push_back(init);
20101         return *this;
20102     }
20103
20104     /// @brief add an object to an array
20105     /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
20106     template<class... Args>
20107     reference emplace_back(Args&& ... args)
20108     {
20109         // emplace_back only works for null objects or arrays
20110         if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
20111         {
20112             JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name()), *this));
20113         }
20114
20115         // transform null object into an array
20116         if (is_null())
20117         {
20118             m_type = value_t::array;
20119             m_value = value_t::array;
20120             assert_invariant();
20121         }
20122
20123         // add element to array (perfect forwarding)
20124         const auto old_capacity = m_value.array->capacity();
20125         m_value.array->emplace_back(std::forward<Args>(args)...);
20126         return set_parent(m_value.array->back(), old_capacity);
20127     }
20128
20129     /// @brief add an object to an object if key does not exist
20130     /// @sa https://json.nlohmann.me/api/basic_json/emplace/
20131     template<class... Args>
20132     std::pair<iterator, bool> emplace(Args&& ... args)
20133     {
20134         // emplace only works for null objects or arrays
20135         if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
20136         {
20137             JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name()), *this));
20138         }
20139
20140         // transform null object into an object
20141         if (is_null())
20142         {
20143             m_type = value_t::object;
20144             m_value = value_t::object;
20145             assert_invariant();
20146         }
20147
20148         // add element to array (perfect forwarding)
20149         auto res = m_value.object->emplace(std::forward<Args>(args)...);
20150         set_parent(res.first->second);
20151
20152         // create result iterator and set iterator to the result of emplace
20153         auto it = begin();
20154         it.m_it.object_iterator = res.first;
20155
20156         // return pair of iterator and boolean
20157         return {it, res.second};
20158     }
20159
20160     /// Helper for insertion of an iterator
20161     /// @note: This uses std::distance to support GCC 4.8,
20162     ///        see https://github.com/nlohmann/json/pull/1257
20163     template<typename... Args>
20164     iterator insert_iterator(const_iterator pos, Args&& ... args)
20165     {
20166         iterator result(this);
20167         JSON_ASSERT(m_value.array != nullptr);
20168
20169         auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
20170         m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
20171         result.m_it.array_iterator = m_value.array->begin() + insert_pos;
20172
20173         // This could have been written as:
20174         // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
20175         // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
20176
20177         set_parents();
20178         return result;
20179     }
20180
20181     /// @brief inserts element into array
20182     /// @sa https://json.nlohmann.me/api/basic_json/insert/
20183     iterator insert(const_iterator pos, const basic_json& val)
20184     {
20185         // insert only works for arrays
20186         if (JSON_HEDLEY_LIKELY(is_array()))
20187         {
20188             // check if iterator pos fits to this JSON value
20189             if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20190             {
20191                 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20192             }
20193
20194             // insert to array and return iterator
20195             return insert_iterator(pos, val);
20196         }
20197
20198         JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20199     }
20200
20201     /// @brief inserts element into array
20202     /// @sa https://json.nlohmann.me/api/basic_json/insert/
20203     iterator insert(const_iterator pos, basic_json&& val)
20204     {
20205         return insert(pos, val);
20206     }
20207
20208     /// @brief inserts copies of element into array
20209     /// @sa https://json.nlohmann.me/api/basic_json/insert/
20210     iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
20211     {
20212         // insert only works for arrays
20213         if (JSON_HEDLEY_LIKELY(is_array()))
20214         {
20215             // check if iterator pos fits to this JSON value
20216             if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20217             {
20218                 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20219             }
20220
20221             // insert to array and return iterator
20222             return insert_iterator(pos, cnt, val);
20223         }
20224
20225         JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20226     }
20227
20228     /// @brief inserts range of elements into array
20229     /// @sa https://json.nlohmann.me/api/basic_json/insert/
20230     iterator insert(const_iterator pos, const_iterator first, const_iterator last)
20231     {
20232         // insert only works for arrays
20233         if (JSON_HEDLEY_UNLIKELY(!is_array()))
20234         {
20235             JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20236         }
20237
20238         // check if iterator pos fits to this JSON value
20239         if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20240         {
20241             JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20242         }
20243
20244         // check if range iterators belong to the same JSON object
20245         if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20246         {
20247             JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
20248         }
20249
20250         if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
20251         {
20252             JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", *this));
20253         }
20254
20255         // insert to array and return iterator
20256         return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
20257     }
20258
20259     /// @brief inserts elements from initializer list into array
20260     /// @sa https://json.nlohmann.me/api/basic_json/insert/
20261     iterator insert(const_iterator pos, initializer_list_t ilist)
20262     {
20263         // insert only works for arrays
20264         if (JSON_HEDLEY_UNLIKELY(!is_array()))
20265         {
20266             JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20267         }
20268
20269         // check if iterator pos fits to this JSON value
20270         if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
20271         {
20272             JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
20273         }
20274
20275         // insert to array and return iterator
20276         return insert_iterator(pos, ilist.begin(), ilist.end());
20277     }
20278
20279     /// @brief inserts range of elements into object
20280     /// @sa https://json.nlohmann.me/api/basic_json/insert/
20281     void insert(const_iterator first, const_iterator last)
20282     {
20283         // insert only works for objects
20284         if (JSON_HEDLEY_UNLIKELY(!is_object()))
20285         {
20286             JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
20287         }
20288
20289         // check if range iterators belong to the same JSON object
20290         if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20291         {
20292             JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
20293         }
20294
20295         // passed iterators must belong to objects
20296         if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
20297         {
20298             JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", *this));
20299         }
20300
20301         m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
20302     }
20303
20304     /// @brief updates a JSON object from another object, overwriting existing keys
20305     /// @sa https://json.nlohmann.me/api/basic_json/update/
20306     void update(const_reference j, bool merge_objects = false)
20307     {
20308         update(j.begin(), j.end(), merge_objects);
20309     }
20310
20311     /// @brief updates a JSON object from another object, overwriting existing keys
20312     /// @sa https://json.nlohmann.me/api/basic_json/update/
20313     void update(const_iterator first, const_iterator last, bool merge_objects = false)
20314     {
20315         // implicitly convert null value to an empty object
20316         if (is_null())
20317         {
20318             m_type = value_t::object;
20319             m_value.object = create<object_t>();
20320             assert_invariant();
20321         }
20322
20323         if (JSON_HEDLEY_UNLIKELY(!is_object()))
20324         {
20325             JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), *this));
20326         }
20327
20328         // check if range iterators belong to the same JSON object
20329         if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
20330         {
20331             JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
20332         }
20333
20334         // passed iterators must belong to objects
20335         if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
20336         {
20337             JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(first.m_object->type_name()), *first.m_object));
20338         }
20339
20340         for (auto it = first; it != last; ++it)
20341         {
20342             if (merge_objects && it.value().is_object())
20343             {
20344                 auto it2 = m_value.object->find(it.key());
20345                 if (it2 != m_value.object->end())
20346                 {
20347                     it2->second.update(it.value(), true);
20348                     continue;
20349                 }
20350             }
20351             m_value.object->operator[](it.key()) = it.value();
20352 #if JSON_DIAGNOSTICS
20353             m_value.object->operator[](it.key()).m_parent = this;
20354 #endif
20355         }
20356     }
20357
20358     /// @brief exchanges the values
20359     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20360     void swap(reference other) noexcept (
20361         std::is_nothrow_move_constructible<value_t>::value&&
20362         std::is_nothrow_move_assignable<value_t>::value&&
20363         std::is_nothrow_move_constructible<json_value>::value&&
20364         std::is_nothrow_move_assignable<json_value>::value
20365     )
20366     {
20367         std::swap(m_type, other.m_type);
20368         std::swap(m_value, other.m_value);
20369
20370         set_parents();
20371         other.set_parents();
20372         assert_invariant();
20373     }
20374
20375     /// @brief exchanges the values
20376     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20377     friend void swap(reference left, reference right) noexcept (
20378         std::is_nothrow_move_constructible<value_t>::value&&
20379         std::is_nothrow_move_assignable<value_t>::value&&
20380         std::is_nothrow_move_constructible<json_value>::value&&
20381         std::is_nothrow_move_assignable<json_value>::value
20382     )
20383     {
20384         left.swap(right);
20385     }
20386
20387     /// @brief exchanges the values
20388     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20389     void swap(array_t& other) // NOLINT(bugprone-exception-escape)
20390     {
20391         // swap only works for arrays
20392         if (JSON_HEDLEY_LIKELY(is_array()))
20393         {
20394             std::swap(*(m_value.array), other);
20395         }
20396         else
20397         {
20398             JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20399         }
20400     }
20401
20402     /// @brief exchanges the values
20403     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20404     void swap(object_t& other) // NOLINT(bugprone-exception-escape)
20405     {
20406         // swap only works for objects
20407         if (JSON_HEDLEY_LIKELY(is_object()))
20408         {
20409             std::swap(*(m_value.object), other);
20410         }
20411         else
20412         {
20413             JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20414         }
20415     }
20416
20417     /// @brief exchanges the values
20418     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20419     void swap(string_t& other) // NOLINT(bugprone-exception-escape)
20420     {
20421         // swap only works for strings
20422         if (JSON_HEDLEY_LIKELY(is_string()))
20423         {
20424             std::swap(*(m_value.string), other);
20425         }
20426         else
20427         {
20428             JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20429         }
20430     }
20431
20432     /// @brief exchanges the values
20433     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20434     void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
20435     {
20436         // swap only works for strings
20437         if (JSON_HEDLEY_LIKELY(is_binary()))
20438         {
20439             std::swap(*(m_value.binary), other);
20440         }
20441         else
20442         {
20443             JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20444         }
20445     }
20446
20447     /// @brief exchanges the values
20448     /// @sa https://json.nlohmann.me/api/basic_json/swap/
20449     void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
20450     {
20451         // swap only works for strings
20452         if (JSON_HEDLEY_LIKELY(is_binary()))
20453         {
20454             std::swap(*(m_value.binary), other);
20455         }
20456         else
20457         {
20458             JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
20459         }
20460     }
20461
20462     /// @}
20463
20464   public:
20465     //////////////////////////////////////////
20466     // lexicographical comparison operators //
20467     //////////////////////////////////////////
20468
20469     /// @name lexicographical comparison operators
20470     /// @{
20471
20472     /// @brief comparison: equal
20473     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
20474     friend bool operator==(const_reference lhs, const_reference rhs) noexcept
20475     {
20476 #ifdef __GNUC__
20477 #pragma GCC diagnostic push
20478 #pragma GCC diagnostic ignored "-Wfloat-equal"
20479 #endif
20480         const auto lhs_type = lhs.type();
20481         const auto rhs_type = rhs.type();
20482
20483         if (lhs_type == rhs_type)
20484         {
20485             switch (lhs_type)
20486             {
20487                 case value_t::array:
20488                     return *lhs.m_value.array == *rhs.m_value.array;
20489
20490                 case value_t::object:
20491                     return *lhs.m_value.object == *rhs.m_value.object;
20492
20493                 case value_t::null:
20494                     return true;
20495
20496                 case value_t::string:
20497                     return *lhs.m_value.string == *rhs.m_value.string;
20498
20499                 case value_t::boolean:
20500                     return lhs.m_value.boolean == rhs.m_value.boolean;
20501
20502                 case value_t::number_integer:
20503                     return lhs.m_value.number_integer == rhs.m_value.number_integer;
20504
20505                 case value_t::number_unsigned:
20506                     return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
20507
20508                 case value_t::number_float:
20509                     return lhs.m_value.number_float == rhs.m_value.number_float;
20510
20511                 case value_t::binary:
20512                     return *lhs.m_value.binary == *rhs.m_value.binary;
20513
20514                 case value_t::discarded:
20515                 default:
20516                     return false;
20517             }
20518         }
20519         else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
20520         {
20521             return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
20522         }
20523         else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
20524         {
20525             return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
20526         }
20527         else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
20528         {
20529             return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
20530         }
20531         else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
20532         {
20533             return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
20534         }
20535         else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
20536         {
20537             return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
20538         }
20539         else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
20540         {
20541             return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
20542         }
20543
20544         return false;
20545 #ifdef __GNUC__
20546 #pragma GCC diagnostic pop
20547 #endif
20548     }
20549
20550     /// @brief comparison: equal
20551     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
20552     template<typename ScalarType, typename std::enable_if<
20553                  std::is_scalar<ScalarType>::value, int>::type = 0>
20554     friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
20555     {
20556         return lhs == basic_json(rhs);
20557     }
20558
20559     /// @brief comparison: equal
20560     /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
20561     template<typename ScalarType, typename std::enable_if<
20562                  std::is_scalar<ScalarType>::value, int>::type = 0>
20563     friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
20564     {
20565         return basic_json(lhs) == rhs;
20566     }
20567
20568     /// @brief comparison: not equal
20569     /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
20570     friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
20571     {
20572         return !(lhs == rhs);
20573     }
20574
20575     /// @brief comparison: not equal
20576     /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
20577     template<typename ScalarType, typename std::enable_if<
20578                  std::is_scalar<ScalarType>::value, int>::type = 0>
20579     friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
20580     {
20581         return lhs != basic_json(rhs);
20582     }
20583
20584     /// @brief comparison: not equal
20585     /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
20586     template<typename ScalarType, typename std::enable_if<
20587                  std::is_scalar<ScalarType>::value, int>::type = 0>
20588     friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
20589     {
20590         return basic_json(lhs) != rhs;
20591     }
20592
20593     /// @brief comparison: less than
20594     /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
20595     friend bool operator<(const_reference lhs, const_reference rhs) noexcept
20596     {
20597         const auto lhs_type = lhs.type();
20598         const auto rhs_type = rhs.type();
20599
20600         if (lhs_type == rhs_type)
20601         {
20602             switch (lhs_type)
20603             {
20604                 case value_t::array:
20605                     // note parentheses are necessary, see
20606                     // https://github.com/nlohmann/json/issues/1530
20607                     return (*lhs.m_value.array) < (*rhs.m_value.array);
20608
20609                 case value_t::object:
20610                     return (*lhs.m_value.object) < (*rhs.m_value.object);
20611
20612                 case value_t::null:
20613                     return false;
20614
20615                 case value_t::string:
20616                     return (*lhs.m_value.string) < (*rhs.m_value.string);
20617
20618                 case value_t::boolean:
20619                     return (lhs.m_value.boolean) < (rhs.m_value.boolean);
20620
20621                 case value_t::number_integer:
20622                     return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
20623
20624                 case value_t::number_unsigned:
20625                     return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
20626
20627                 case value_t::number_float:
20628                     return (lhs.m_value.number_float) < (rhs.m_value.number_float);
20629
20630                 case value_t::binary:
20631                     return (*lhs.m_value.binary) < (*rhs.m_value.binary);
20632
20633                 case value_t::discarded:
20634                 default:
20635                     return false;
20636             }
20637         }
20638         else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
20639         {
20640             return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
20641         }
20642         else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
20643         {
20644             return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
20645         }
20646         else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
20647         {
20648             return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
20649         }
20650         else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
20651         {
20652             return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
20653         }
20654         else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
20655         {
20656             return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
20657         }
20658         else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
20659         {
20660             return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
20661         }
20662
20663         // We only reach this line if we cannot compare values. In that case,
20664         // we compare types. Note we have to call the operator explicitly,
20665         // because MSVC has problems otherwise.
20666         return operator<(lhs_type, rhs_type);
20667     }
20668
20669     /// @brief comparison: less than
20670     /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
20671     template<typename ScalarType, typename std::enable_if<
20672                  std::is_scalar<ScalarType>::value, int>::type = 0>
20673     friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
20674     {
20675         return lhs < basic_json(rhs);
20676     }
20677
20678     /// @brief comparison: less than
20679     /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
20680     template<typename ScalarType, typename std::enable_if<
20681                  std::is_scalar<ScalarType>::value, int>::type = 0>
20682     friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
20683     {
20684         return basic_json(lhs) < rhs;
20685     }
20686
20687     /// @brief comparison: less than or equal
20688     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
20689     friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
20690     {
20691         return !(rhs < lhs);
20692     }
20693
20694     /// @brief comparison: less than or equal
20695     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
20696     template<typename ScalarType, typename std::enable_if<
20697                  std::is_scalar<ScalarType>::value, int>::type = 0>
20698     friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
20699     {
20700         return lhs <= basic_json(rhs);
20701     }
20702
20703     /// @brief comparison: less than or equal
20704     /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
20705     template<typename ScalarType, typename std::enable_if<
20706                  std::is_scalar<ScalarType>::value, int>::type = 0>
20707     friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
20708     {
20709         return basic_json(lhs) <= rhs;
20710     }
20711
20712     /// @brief comparison: greater than
20713     /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
20714     friend bool operator>(const_reference lhs, const_reference rhs) noexcept
20715     {
20716         return !(lhs <= rhs);
20717     }
20718
20719     /// @brief comparison: greater than
20720     /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
20721     template<typename ScalarType, typename std::enable_if<
20722                  std::is_scalar<ScalarType>::value, int>::type = 0>
20723     friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
20724     {
20725         return lhs > basic_json(rhs);
20726     }
20727
20728     /// @brief comparison: greater than
20729     /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
20730     template<typename ScalarType, typename std::enable_if<
20731                  std::is_scalar<ScalarType>::value, int>::type = 0>
20732     friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
20733     {
20734         return basic_json(lhs) > rhs;
20735     }
20736
20737     /// @brief comparison: greater than or equal
20738     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
20739     friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
20740     {
20741         return !(lhs < rhs);
20742     }
20743
20744     /// @brief comparison: greater than or equal
20745     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
20746     template<typename ScalarType, typename std::enable_if<
20747                  std::is_scalar<ScalarType>::value, int>::type = 0>
20748     friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
20749     {
20750         return lhs >= basic_json(rhs);
20751     }
20752
20753     /// @brief comparison: greater than or equal
20754     /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
20755     template<typename ScalarType, typename std::enable_if<
20756                  std::is_scalar<ScalarType>::value, int>::type = 0>
20757     friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
20758     {
20759         return basic_json(lhs) >= rhs;
20760     }
20761
20762     /// @}
20763
20764     ///////////////////
20765     // serialization //
20766     ///////////////////
20767
20768     /// @name serialization
20769     /// @{
20770 #ifndef JSON_NO_IO
20771     /// @brief serialize to stream
20772     /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
20773     friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
20774     {
20775         // read width member and use it as indentation parameter if nonzero
20776         const bool pretty_print = o.width() > 0;
20777         const auto indentation = pretty_print ? o.width() : 0;
20778
20779         // reset width to 0 for subsequent calls to this stream
20780         o.width(0);
20781
20782         // do the actual serialization
20783         serializer s(detail::output_adapter<char>(o), o.fill());
20784         s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
20785         return o;
20786     }
20787
20788     /// @brief serialize to stream
20789     /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
20790     /// @deprecated This function is deprecated since 3.0.0 and will be removed in
20791     ///             version 4.0.0 of the library. Please use
20792     ///             operator<<(std::ostream&, const basic_json&) instead; that is,
20793     ///             replace calls like `j >> o;` with `o << j;`.
20794     JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
20795     friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
20796     {
20797         return o << j;
20798     }
20799 #endif  // JSON_NO_IO
20800     /// @}
20801
20802
20803     /////////////////////
20804     // deserialization //
20805     /////////////////////
20806
20807     /// @name deserialization
20808     /// @{
20809
20810     /// @brief deserialize from a compatible input
20811     /// @sa https://json.nlohmann.me/api/basic_json/parse/
20812     template<typename InputType>
20813     JSON_HEDLEY_WARN_UNUSED_RESULT
20814     static basic_json parse(InputType&& i,
20815                             const parser_callback_t cb = nullptr,
20816                             const bool allow_exceptions = true,
20817                             const bool ignore_comments = false)
20818     {
20819         basic_json result;
20820         parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
20821         return result;
20822     }
20823
20824     /// @brief deserialize from a pair of character iterators
20825     /// @sa https://json.nlohmann.me/api/basic_json/parse/
20826     template<typename IteratorType>
20827     JSON_HEDLEY_WARN_UNUSED_RESULT
20828     static basic_json parse(IteratorType first,
20829                             IteratorType last,
20830                             const parser_callback_t cb = nullptr,
20831                             const bool allow_exceptions = true,
20832                             const bool ignore_comments = false)
20833     {
20834         basic_json result;
20835         parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
20836         return result;
20837     }
20838
20839     JSON_HEDLEY_WARN_UNUSED_RESULT
20840     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
20841     static basic_json parse(detail::span_input_adapter&& i,
20842                             const parser_callback_t cb = nullptr,
20843                             const bool allow_exceptions = true,
20844                             const bool ignore_comments = false)
20845     {
20846         basic_json result;
20847         parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
20848         return result;
20849     }
20850
20851     /// @brief check if the input is valid JSON
20852     /// @sa https://json.nlohmann.me/api/basic_json/accept/
20853     template<typename InputType>
20854     static bool accept(InputType&& i,
20855                        const bool ignore_comments = false)
20856     {
20857         return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
20858     }
20859
20860     /// @brief check if the input is valid JSON
20861     /// @sa https://json.nlohmann.me/api/basic_json/accept/
20862     template<typename IteratorType>
20863     static bool accept(IteratorType first, IteratorType last,
20864                        const bool ignore_comments = false)
20865     {
20866         return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
20867     }
20868
20869     JSON_HEDLEY_WARN_UNUSED_RESULT
20870     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
20871     static bool accept(detail::span_input_adapter&& i,
20872                        const bool ignore_comments = false)
20873     {
20874         return parser(i.get(), nullptr, false, ignore_comments).accept(true);
20875     }
20876
20877     /// @brief generate SAX events
20878     /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
20879     template <typename InputType, typename SAX>
20880     JSON_HEDLEY_NON_NULL(2)
20881     static bool sax_parse(InputType&& i, SAX* sax,
20882                           input_format_t format = input_format_t::json,
20883                           const bool strict = true,
20884                           const bool ignore_comments = false)
20885     {
20886         auto ia = detail::input_adapter(std::forward<InputType>(i));
20887         return format == input_format_t::json
20888                ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
20889                : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
20890     }
20891
20892     /// @brief generate SAX events
20893     /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
20894     template<class IteratorType, class SAX>
20895     JSON_HEDLEY_NON_NULL(3)
20896     static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
20897                           input_format_t format = input_format_t::json,
20898                           const bool strict = true,
20899                           const bool ignore_comments = false)
20900     {
20901         auto ia = detail::input_adapter(std::move(first), std::move(last));
20902         return format == input_format_t::json
20903                ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
20904                : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
20905     }
20906
20907     /// @brief generate SAX events
20908     /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
20909     /// @deprecated This function is deprecated since 3.8.0 and will be removed in
20910     ///             version 4.0.0 of the library. Please use
20911     ///             sax_parse(ptr, ptr + len) instead.
20912     template <typename SAX>
20913     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
20914     JSON_HEDLEY_NON_NULL(2)
20915     static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
20916                           input_format_t format = input_format_t::json,
20917                           const bool strict = true,
20918                           const bool ignore_comments = false)
20919     {
20920         auto ia = i.get();
20921         return format == input_format_t::json
20922                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
20923                ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
20924                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
20925                : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
20926     }
20927 #ifndef JSON_NO_IO
20928     /// @brief deserialize from stream
20929     /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
20930     /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
20931     ///             version 4.0.0 of the library. Please use
20932     ///             operator>>(std::istream&, basic_json&) instead; that is,
20933     ///             replace calls like `j << i;` with `i >> j;`.
20934     JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
20935     friend std::istream& operator<<(basic_json& j, std::istream& i)
20936     {
20937         return operator>>(i, j);
20938     }
20939
20940     /// @brief deserialize from stream
20941     /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
20942     friend std::istream& operator>>(std::istream& i, basic_json& j)
20943     {
20944         parser(detail::input_adapter(i)).parse(false, j);
20945         return i;
20946     }
20947 #endif  // JSON_NO_IO
20948     /// @}
20949
20950     ///////////////////////////
20951     // convenience functions //
20952     ///////////////////////////
20953
20954     /// @brief return the type as string
20955     /// @sa https://json.nlohmann.me/api/basic_json/type_name/
20956     JSON_HEDLEY_RETURNS_NON_NULL
20957     const char* type_name() const noexcept
20958     {
20959         switch (m_type)
20960         {
20961             case value_t::null:
20962                 return "null";
20963             case value_t::object:
20964                 return "object";
20965             case value_t::array:
20966                 return "array";
20967             case value_t::string:
20968                 return "string";
20969             case value_t::boolean:
20970                 return "boolean";
20971             case value_t::binary:
20972                 return "binary";
20973             case value_t::discarded:
20974                 return "discarded";
20975             case value_t::number_integer:
20976             case value_t::number_unsigned:
20977             case value_t::number_float:
20978             default:
20979                 return "number";
20980         }
20981     }
20982
20983
20984   JSON_PRIVATE_UNLESS_TESTED:
20985     //////////////////////
20986     // member variables //
20987     //////////////////////
20988
20989     /// the type of the current element
20990     value_t m_type = value_t::null;
20991
20992     /// the value of the current element
20993     json_value m_value = {};
20994
20995 #if JSON_DIAGNOSTICS
20996     /// a pointer to a parent value (for debugging purposes)
20997     basic_json* m_parent = nullptr;
20998 #endif
20999
21000     //////////////////////////////////////////
21001     // binary serialization/deserialization //
21002     //////////////////////////////////////////
21003
21004     /// @name binary serialization/deserialization support
21005     /// @{
21006
21007   public:
21008     /// @brief create a CBOR serialization of a given JSON value
21009     /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
21010     static std::vector<std::uint8_t> to_cbor(const basic_json& j)
21011     {
21012         std::vector<std::uint8_t> result;
21013         to_cbor(j, result);
21014         return result;
21015     }
21016
21017     /// @brief create a CBOR serialization of a given JSON value
21018     /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
21019     static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
21020     {
21021         binary_writer<std::uint8_t>(o).write_cbor(j);
21022     }
21023
21024     /// @brief create a CBOR serialization of a given JSON value
21025     /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
21026     static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
21027     {
21028         binary_writer<char>(o).write_cbor(j);
21029     }
21030
21031     /// @brief create a MessagePack serialization of a given JSON value
21032     /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
21033     static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
21034     {
21035         std::vector<std::uint8_t> result;
21036         to_msgpack(j, result);
21037         return result;
21038     }
21039
21040     /// @brief create a MessagePack serialization of a given JSON value
21041     /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
21042     static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
21043     {
21044         binary_writer<std::uint8_t>(o).write_msgpack(j);
21045     }
21046
21047     /// @brief create a MessagePack serialization of a given JSON value
21048     /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
21049     static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
21050     {
21051         binary_writer<char>(o).write_msgpack(j);
21052     }
21053
21054     /// @brief create a UBJSON serialization of a given JSON value
21055     /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
21056     static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
21057             const bool use_size = false,
21058             const bool use_type = false)
21059     {
21060         std::vector<std::uint8_t> result;
21061         to_ubjson(j, result, use_size, use_type);
21062         return result;
21063     }
21064
21065     /// @brief create a UBJSON serialization of a given JSON value
21066     /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
21067     static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
21068                           const bool use_size = false, const bool use_type = false)
21069     {
21070         binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
21071     }
21072
21073     /// @brief create a UBJSON serialization of a given JSON value
21074     /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
21075     static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
21076                           const bool use_size = false, const bool use_type = false)
21077     {
21078         binary_writer<char>(o).write_ubjson(j, use_size, use_type);
21079     }
21080
21081     /// @brief create a BSON serialization of a given JSON value
21082     /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
21083     static std::vector<std::uint8_t> to_bson(const basic_json& j)
21084     {
21085         std::vector<std::uint8_t> result;
21086         to_bson(j, result);
21087         return result;
21088     }
21089
21090     /// @brief create a BSON serialization of a given JSON value
21091     /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
21092     static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
21093     {
21094         binary_writer<std::uint8_t>(o).write_bson(j);
21095     }
21096
21097     /// @brief create a BSON serialization of a given JSON value
21098     /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
21099     static void to_bson(const basic_json& j, detail::output_adapter<char> o)
21100     {
21101         binary_writer<char>(o).write_bson(j);
21102     }
21103
21104     /// @brief create a JSON value from an input in CBOR format
21105     /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
21106     template<typename InputType>
21107     JSON_HEDLEY_WARN_UNUSED_RESULT
21108     static basic_json from_cbor(InputType&& i,
21109                                 const bool strict = true,
21110                                 const bool allow_exceptions = true,
21111                                 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21112     {
21113         basic_json result;
21114         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21115         auto ia = detail::input_adapter(std::forward<InputType>(i));
21116         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
21117         return res ? result : basic_json(value_t::discarded);
21118     }
21119
21120     /// @brief create a JSON value from an input in CBOR format
21121     /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
21122     template<typename IteratorType>
21123     JSON_HEDLEY_WARN_UNUSED_RESULT
21124     static basic_json from_cbor(IteratorType first, IteratorType last,
21125                                 const bool strict = true,
21126                                 const bool allow_exceptions = true,
21127                                 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21128     {
21129         basic_json result;
21130         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21131         auto ia = detail::input_adapter(std::move(first), std::move(last));
21132         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
21133         return res ? result : basic_json(value_t::discarded);
21134     }
21135
21136     template<typename T>
21137     JSON_HEDLEY_WARN_UNUSED_RESULT
21138     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
21139     static basic_json from_cbor(const T* ptr, std::size_t len,
21140                                 const bool strict = true,
21141                                 const bool allow_exceptions = true,
21142                                 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21143     {
21144         return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
21145     }
21146
21147
21148     JSON_HEDLEY_WARN_UNUSED_RESULT
21149     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
21150     static basic_json from_cbor(detail::span_input_adapter&& i,
21151                                 const bool strict = true,
21152                                 const bool allow_exceptions = true,
21153                                 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
21154     {
21155         basic_json result;
21156         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21157         auto ia = i.get();
21158         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21159         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
21160         return res ? result : basic_json(value_t::discarded);
21161     }
21162
21163     /// @brief create a JSON value from an input in MessagePack format
21164     /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
21165     template<typename InputType>
21166     JSON_HEDLEY_WARN_UNUSED_RESULT
21167     static basic_json from_msgpack(InputType&& i,
21168                                    const bool strict = true,
21169                                    const bool allow_exceptions = true)
21170     {
21171         basic_json result;
21172         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21173         auto ia = detail::input_adapter(std::forward<InputType>(i));
21174         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
21175         return res ? result : basic_json(value_t::discarded);
21176     }
21177
21178     /// @brief create a JSON value from an input in MessagePack format
21179     /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
21180     template<typename IteratorType>
21181     JSON_HEDLEY_WARN_UNUSED_RESULT
21182     static basic_json from_msgpack(IteratorType first, IteratorType last,
21183                                    const bool strict = true,
21184                                    const bool allow_exceptions = true)
21185     {
21186         basic_json result;
21187         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21188         auto ia = detail::input_adapter(std::move(first), std::move(last));
21189         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
21190         return res ? result : basic_json(value_t::discarded);
21191     }
21192
21193     template<typename T>
21194     JSON_HEDLEY_WARN_UNUSED_RESULT
21195     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
21196     static basic_json from_msgpack(const T* ptr, std::size_t len,
21197                                    const bool strict = true,
21198                                    const bool allow_exceptions = true)
21199     {
21200         return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
21201     }
21202
21203     JSON_HEDLEY_WARN_UNUSED_RESULT
21204     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
21205     static basic_json from_msgpack(detail::span_input_adapter&& i,
21206                                    const bool strict = true,
21207                                    const bool allow_exceptions = true)
21208     {
21209         basic_json result;
21210         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21211         auto ia = i.get();
21212         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21213         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
21214         return res ? result : basic_json(value_t::discarded);
21215     }
21216
21217     /// @brief create a JSON value from an input in UBJSON format
21218     /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
21219     template<typename InputType>
21220     JSON_HEDLEY_WARN_UNUSED_RESULT
21221     static basic_json from_ubjson(InputType&& i,
21222                                   const bool strict = true,
21223                                   const bool allow_exceptions = true)
21224     {
21225         basic_json result;
21226         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21227         auto ia = detail::input_adapter(std::forward<InputType>(i));
21228         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
21229         return res ? result : basic_json(value_t::discarded);
21230     }
21231
21232     /// @brief create a JSON value from an input in UBJSON format
21233     /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
21234     template<typename IteratorType>
21235     JSON_HEDLEY_WARN_UNUSED_RESULT
21236     static basic_json from_ubjson(IteratorType first, IteratorType last,
21237                                   const bool strict = true,
21238                                   const bool allow_exceptions = true)
21239     {
21240         basic_json result;
21241         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21242         auto ia = detail::input_adapter(std::move(first), std::move(last));
21243         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
21244         return res ? result : basic_json(value_t::discarded);
21245     }
21246
21247     template<typename T>
21248     JSON_HEDLEY_WARN_UNUSED_RESULT
21249     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
21250     static basic_json from_ubjson(const T* ptr, std::size_t len,
21251                                   const bool strict = true,
21252                                   const bool allow_exceptions = true)
21253     {
21254         return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
21255     }
21256
21257     JSON_HEDLEY_WARN_UNUSED_RESULT
21258     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
21259     static basic_json from_ubjson(detail::span_input_adapter&& i,
21260                                   const bool strict = true,
21261                                   const bool allow_exceptions = true)
21262     {
21263         basic_json result;
21264         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21265         auto ia = i.get();
21266         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21267         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
21268         return res ? result : basic_json(value_t::discarded);
21269     }
21270
21271     /// @brief create a JSON value from an input in BSON format
21272     /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
21273     template<typename InputType>
21274     JSON_HEDLEY_WARN_UNUSED_RESULT
21275     static basic_json from_bson(InputType&& i,
21276                                 const bool strict = true,
21277                                 const bool allow_exceptions = true)
21278     {
21279         basic_json result;
21280         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21281         auto ia = detail::input_adapter(std::forward<InputType>(i));
21282         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
21283         return res ? result : basic_json(value_t::discarded);
21284     }
21285
21286     /// @brief create a JSON value from an input in BSON format
21287     /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
21288     template<typename IteratorType>
21289     JSON_HEDLEY_WARN_UNUSED_RESULT
21290     static basic_json from_bson(IteratorType first, IteratorType last,
21291                                 const bool strict = true,
21292                                 const bool allow_exceptions = true)
21293     {
21294         basic_json result;
21295         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21296         auto ia = detail::input_adapter(std::move(first), std::move(last));
21297         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
21298         return res ? result : basic_json(value_t::discarded);
21299     }
21300
21301     template<typename T>
21302     JSON_HEDLEY_WARN_UNUSED_RESULT
21303     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
21304     static basic_json from_bson(const T* ptr, std::size_t len,
21305                                 const bool strict = true,
21306                                 const bool allow_exceptions = true)
21307     {
21308         return from_bson(ptr, ptr + len, strict, allow_exceptions);
21309     }
21310
21311     JSON_HEDLEY_WARN_UNUSED_RESULT
21312     JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
21313     static basic_json from_bson(detail::span_input_adapter&& i,
21314                                 const bool strict = true,
21315                                 const bool allow_exceptions = true)
21316     {
21317         basic_json result;
21318         detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
21319         auto ia = i.get();
21320         // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
21321         const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
21322         return res ? result : basic_json(value_t::discarded);
21323     }
21324     /// @}
21325
21326     //////////////////////////
21327     // JSON Pointer support //
21328     //////////////////////////
21329
21330     /// @name JSON Pointer functions
21331     /// @{
21332
21333     /// @brief access specified element via JSON Pointer
21334     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
21335     reference operator[](const json_pointer& ptr)
21336     {
21337         return ptr.get_unchecked(this);
21338     }
21339
21340     /// @brief access specified element via JSON Pointer
21341     /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
21342     const_reference operator[](const json_pointer& ptr) const
21343     {
21344         return ptr.get_unchecked(this);
21345     }
21346
21347     /// @brief access specified element via JSON Pointer
21348     /// @sa https://json.nlohmann.me/api/basic_json/at/
21349     reference at(const json_pointer& ptr)
21350     {
21351         return ptr.get_checked(this);
21352     }
21353
21354     /// @brief access specified element via JSON Pointer
21355     /// @sa https://json.nlohmann.me/api/basic_json/at/
21356     const_reference at(const json_pointer& ptr) const
21357     {
21358         return ptr.get_checked(this);
21359     }
21360
21361     /// @brief return flattened JSON value
21362     /// @sa https://json.nlohmann.me/api/basic_json/flatten/
21363     basic_json flatten() const
21364     {
21365         basic_json result(value_t::object);
21366         json_pointer::flatten("", *this, result);
21367         return result;
21368     }
21369
21370     /// @brief unflatten a previously flattened JSON value
21371     /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
21372     basic_json unflatten() const
21373     {
21374         return json_pointer::unflatten(*this);
21375     }
21376
21377     /// @}
21378
21379     //////////////////////////
21380     // JSON Patch functions //
21381     //////////////////////////
21382
21383     /// @name JSON Patch functions
21384     /// @{
21385
21386     /// @brief applies a JSON patch
21387     /// @sa https://json.nlohmann.me/api/basic_json/patch/
21388     basic_json patch(const basic_json& json_patch) const
21389     {
21390         // make a working copy to apply the patch to
21391         basic_json result = *this;
21392
21393         // the valid JSON Patch operations
21394         enum class patch_operations {add, remove, replace, move, copy, test, invalid};
21395
21396         const auto get_op = [](const std::string & op)
21397         {
21398             if (op == "add")
21399             {
21400                 return patch_operations::add;
21401             }
21402             if (op == "remove")
21403             {
21404                 return patch_operations::remove;
21405             }
21406             if (op == "replace")
21407             {
21408                 return patch_operations::replace;
21409             }
21410             if (op == "move")
21411             {
21412                 return patch_operations::move;
21413             }
21414             if (op == "copy")
21415             {
21416                 return patch_operations::copy;
21417             }
21418             if (op == "test")
21419             {
21420                 return patch_operations::test;
21421             }
21422
21423             return patch_operations::invalid;
21424         };
21425
21426         // wrapper for "add" operation; add value at ptr
21427         const auto operation_add = [&result](json_pointer & ptr, basic_json val)
21428         {
21429             // adding to the root of the target document means replacing it
21430             if (ptr.empty())
21431             {
21432                 result = val;
21433                 return;
21434             }
21435
21436             // make sure the top element of the pointer exists
21437             json_pointer top_pointer = ptr.top();
21438             if (top_pointer != ptr)
21439             {
21440                 result.at(top_pointer);
21441             }
21442
21443             // get reference to parent of JSON pointer ptr
21444             const auto last_path = ptr.back();
21445             ptr.pop_back();
21446             basic_json& parent = result[ptr];
21447
21448             switch (parent.m_type)
21449             {
21450                 case value_t::null:
21451                 case value_t::object:
21452                 {
21453                     // use operator[] to add value
21454                     parent[last_path] = val;
21455                     break;
21456                 }
21457
21458                 case value_t::array:
21459                 {
21460                     if (last_path == "-")
21461                     {
21462                         // special case: append to back
21463                         parent.push_back(val);
21464                     }
21465                     else
21466                     {
21467                         const auto idx = json_pointer::array_index(last_path);
21468                         if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
21469                         {
21470                             // avoid undefined behavior
21471                             JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", parent));
21472                         }
21473
21474                         // default case: insert add offset
21475                         parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
21476                     }
21477                     break;
21478                 }
21479
21480                 // if there exists a parent it cannot be primitive
21481                 case value_t::string: // LCOV_EXCL_LINE
21482                 case value_t::boolean: // LCOV_EXCL_LINE
21483                 case value_t::number_integer: // LCOV_EXCL_LINE
21484                 case value_t::number_unsigned: // LCOV_EXCL_LINE
21485                 case value_t::number_float: // LCOV_EXCL_LINE
21486                 case value_t::binary: // LCOV_EXCL_LINE
21487                 case value_t::discarded: // LCOV_EXCL_LINE
21488                 default:            // LCOV_EXCL_LINE
21489                     JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
21490             }
21491         };
21492
21493         // wrapper for "remove" operation; remove value at ptr
21494         const auto operation_remove = [this, &result](json_pointer & ptr)
21495         {
21496             // get reference to parent of JSON pointer ptr
21497             const auto last_path = ptr.back();
21498             ptr.pop_back();
21499             basic_json& parent = result.at(ptr);
21500
21501             // remove child
21502             if (parent.is_object())
21503             {
21504                 // perform range check
21505                 auto it = parent.find(last_path);
21506                 if (JSON_HEDLEY_LIKELY(it != parent.end()))
21507                 {
21508                     parent.erase(it);
21509                 }
21510                 else
21511                 {
21512                     JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found", *this));
21513                 }
21514             }
21515             else if (parent.is_array())
21516             {
21517                 // note erase performs range check
21518                 parent.erase(json_pointer::array_index(last_path));
21519             }
21520         };
21521
21522         // type check: top level value must be an array
21523         if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
21524         {
21525             JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", json_patch));
21526         }
21527
21528         // iterate and apply the operations
21529         for (const auto& val : json_patch)
21530         {
21531             // wrapper to get a value for an operation
21532             const auto get_value = [&val](const std::string & op,
21533                                           const std::string & member,
21534                                           bool string_type) -> basic_json &
21535             {
21536                 // find value
21537                 auto it = val.m_value.object->find(member);
21538
21539                 // context-sensitive error message
21540                 const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
21541
21542                 // check if desired value is present
21543                 if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
21544                 {
21545                     // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
21546                     JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'", val));
21547                 }
21548
21549                 // check if result is of type string
21550                 if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
21551                 {
21552                     // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
21553                     JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'", val));
21554                 }
21555
21556                 // no error: return value
21557                 return it->second;
21558             };
21559
21560             // type check: every element of the array must be an object
21561             if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
21562             {
21563                 JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", val));
21564             }
21565
21566             // collect mandatory members
21567             const auto op = get_value("op", "op", true).template get<std::string>();
21568             const auto path = get_value(op, "path", true).template get<std::string>();
21569             json_pointer ptr(path);
21570
21571             switch (get_op(op))
21572             {
21573                 case patch_operations::add:
21574                 {
21575                     operation_add(ptr, get_value("add", "value", false));
21576                     break;
21577                 }
21578
21579                 case patch_operations::remove:
21580                 {
21581                     operation_remove(ptr);
21582                     break;
21583                 }
21584
21585                 case patch_operations::replace:
21586                 {
21587                     // the "path" location must exist - use at()
21588                     result.at(ptr) = get_value("replace", "value", false);
21589                     break;
21590                 }
21591
21592                 case patch_operations::move:
21593                 {
21594                     const auto from_path = get_value("move", "from", true).template get<std::string>();
21595                     json_pointer from_ptr(from_path);
21596
21597                     // the "from" location must exist - use at()
21598                     basic_json v = result.at(from_ptr);
21599
21600                     // The move operation is functionally identical to a
21601                     // "remove" operation on the "from" location, followed
21602                     // immediately by an "add" operation at the target
21603                     // location with the value that was just removed.
21604                     operation_remove(from_ptr);
21605                     operation_add(ptr, v);
21606                     break;
21607                 }
21608
21609                 case patch_operations::copy:
21610                 {
21611                     const auto from_path = get_value("copy", "from", true).template get<std::string>();
21612                     const json_pointer from_ptr(from_path);
21613
21614                     // the "from" location must exist - use at()
21615                     basic_json v = result.at(from_ptr);
21616
21617                     // The copy is functionally identical to an "add"
21618                     // operation at the target location using the value
21619                     // specified in the "from" member.
21620                     operation_add(ptr, v);
21621                     break;
21622                 }
21623
21624                 case patch_operations::test:
21625                 {
21626                     bool success = false;
21627                     JSON_TRY
21628                     {
21629                         // check if "value" matches the one at "path"
21630                         // the "path" location must exist - use at()
21631                         success = (result.at(ptr) == get_value("test", "value", false));
21632                     }
21633                     JSON_INTERNAL_CATCH (out_of_range&)
21634                     {
21635                         // ignore out of range errors: success remains false
21636                     }
21637
21638                     // throw an exception if test fails
21639                     if (JSON_HEDLEY_UNLIKELY(!success))
21640                     {
21641                         JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump(), val));
21642                     }
21643
21644                     break;
21645                 }
21646
21647                 case patch_operations::invalid:
21648                 default:
21649                 {
21650                     // op must be "add", "remove", "replace", "move", "copy", or
21651                     // "test"
21652                     JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid", val));
21653                 }
21654             }
21655         }
21656
21657         return result;
21658     }
21659
21660     /// @brief creates a diff as a JSON patch
21661     /// @sa https://json.nlohmann.me/api/basic_json/diff/
21662     JSON_HEDLEY_WARN_UNUSED_RESULT
21663     static basic_json diff(const basic_json& source, const basic_json& target,
21664                            const std::string& path = "")
21665     {
21666         // the patch
21667         basic_json result(value_t::array);
21668
21669         // if the values are the same, return empty patch
21670         if (source == target)
21671         {
21672             return result;
21673         }
21674
21675         if (source.type() != target.type())
21676         {
21677             // different types: replace value
21678             result.push_back(
21679             {
21680                 {"op", "replace"}, {"path", path}, {"value", target}
21681             });
21682             return result;
21683         }
21684
21685         switch (source.type())
21686         {
21687             case value_t::array:
21688             {
21689                 // first pass: traverse common elements
21690                 std::size_t i = 0;
21691                 while (i < source.size() && i < target.size())
21692                 {
21693                     // recursive call to compare array values at index i
21694                     auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
21695                     result.insert(result.end(), temp_diff.begin(), temp_diff.end());
21696                     ++i;
21697                 }
21698
21699                 // We now reached the end of at least one array
21700                 // in a second pass, traverse the remaining elements
21701
21702                 // remove my remaining elements
21703                 const auto end_index = static_cast<difference_type>(result.size());
21704                 while (i < source.size())
21705                 {
21706                     // add operations in reverse order to avoid invalid
21707                     // indices
21708                     result.insert(result.begin() + end_index, object(
21709                     {
21710                         {"op", "remove"},
21711                         {"path", path + "/" + std::to_string(i)}
21712                     }));
21713                     ++i;
21714                 }
21715
21716                 // add other remaining elements
21717                 while (i < target.size())
21718                 {
21719                     result.push_back(
21720                     {
21721                         {"op", "add"},
21722                         {"path", path + "/-"},
21723                         {"value", target[i]}
21724                     });
21725                     ++i;
21726                 }
21727
21728                 break;
21729             }
21730
21731             case value_t::object:
21732             {
21733                 // first pass: traverse this object's elements
21734                 for (auto it = source.cbegin(); it != source.cend(); ++it)
21735                 {
21736                     // escape the key name to be used in a JSON patch
21737                     const auto path_key = path + "/" + detail::escape(it.key());
21738
21739                     if (target.find(it.key()) != target.end())
21740                     {
21741                         // recursive call to compare object values at key it
21742                         auto temp_diff = diff(it.value(), target[it.key()], path_key);
21743                         result.insert(result.end(), temp_diff.begin(), temp_diff.end());
21744                     }
21745                     else
21746                     {
21747                         // found a key that is not in o -> remove it
21748                         result.push_back(object(
21749                         {
21750                             {"op", "remove"}, {"path", path_key}
21751                         }));
21752                     }
21753                 }
21754
21755                 // second pass: traverse other object's elements
21756                 for (auto it = target.cbegin(); it != target.cend(); ++it)
21757                 {
21758                     if (source.find(it.key()) == source.end())
21759                     {
21760                         // found a key that is not in this -> add it
21761                         const auto path_key = path + "/" + detail::escape(it.key());
21762                         result.push_back(
21763                         {
21764                             {"op", "add"}, {"path", path_key},
21765                             {"value", it.value()}
21766                         });
21767                     }
21768                 }
21769
21770                 break;
21771             }
21772
21773             case value_t::null:
21774             case value_t::string:
21775             case value_t::boolean:
21776             case value_t::number_integer:
21777             case value_t::number_unsigned:
21778             case value_t::number_float:
21779             case value_t::binary:
21780             case value_t::discarded:
21781             default:
21782             {
21783                 // both primitive type: replace value
21784                 result.push_back(
21785                 {
21786                     {"op", "replace"}, {"path", path}, {"value", target}
21787                 });
21788                 break;
21789             }
21790         }
21791
21792         return result;
21793     }
21794
21795     /// @}
21796
21797     ////////////////////////////////
21798     // JSON Merge Patch functions //
21799     ////////////////////////////////
21800
21801     /// @name JSON Merge Patch functions
21802     /// @{
21803
21804     /// @brief applies a JSON Merge Patch
21805     /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
21806     void merge_patch(const basic_json& apply_patch)
21807     {
21808         if (apply_patch.is_object())
21809         {
21810             if (!is_object())
21811             {
21812                 *this = object();
21813             }
21814             for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
21815             {
21816                 if (it.value().is_null())
21817                 {
21818                     erase(it.key());
21819                 }
21820                 else
21821                 {
21822                     operator[](it.key()).merge_patch(it.value());
21823                 }
21824             }
21825         }
21826         else
21827         {
21828             *this = apply_patch;
21829         }
21830     }
21831
21832     /// @}
21833 };
21834
21835 /// @brief user-defined to_string function for JSON values
21836 /// @sa https://json.nlohmann.me/api/basic_json/to_string/
21837 NLOHMANN_BASIC_JSON_TPL_DECLARATION
21838 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
21839 {
21840     return j.dump();
21841 }
21842
21843 } // namespace nlohmann
21844
21845 ///////////////////////
21846 // nonmember support //
21847 ///////////////////////
21848
21849 namespace std // NOLINT(cert-dcl58-cpp)
21850 {
21851
21852 /// @brief hash value for JSON objects
21853 /// @sa https://json.nlohmann.me/api/basic_json/std_hash/
21854 NLOHMANN_BASIC_JSON_TPL_DECLARATION
21855 struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL>
21856 {
21857     std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
21858     {
21859         return nlohmann::detail::hash(j);
21860     }
21861 };
21862
21863 // specialization for std::less<value_t>
21864 template<>
21865 struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
21866 {
21867     /*!
21868     @brief compare two value_t enum values
21869     @since version 3.0.0
21870     */
21871     bool operator()(nlohmann::detail::value_t lhs,
21872                     nlohmann::detail::value_t rhs) const noexcept
21873     {
21874         return nlohmann::detail::operator<(lhs, rhs);
21875     }
21876 };
21877
21878 // C++20 prohibit function specialization in the std namespace.
21879 #ifndef JSON_HAS_CPP_20
21880
21881 /// @brief exchanges the values of two JSON objects
21882 /// @sa https://json.nlohmann.me/api/basic_json/std_swap/
21883 NLOHMANN_BASIC_JSON_TPL_DECLARATION
21884 inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name)
21885     is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression)
21886     is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
21887 {
21888     j1.swap(j2);
21889 }
21890
21891 #endif
21892
21893 } // namespace std
21894
21895 /// @brief user-defined string literal for JSON values
21896 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
21897 JSON_HEDLEY_NON_NULL(1)
21898 inline nlohmann::json operator "" _json(const char* s, std::size_t n)
21899 {
21900     return nlohmann::json::parse(s, s + n);
21901 }
21902
21903 /// @brief user-defined string literal for JSON pointer
21904 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
21905 JSON_HEDLEY_NON_NULL(1)
21906 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
21907 {
21908     return nlohmann::json::json_pointer(std::string(s, n));
21909 }
21910
21911 // #include <nlohmann/detail/macro_unscope.hpp>
21912
21913
21914 // restore clang diagnostic settings
21915 #if defined(__clang__)
21916     #pragma clang diagnostic pop
21917 #endif
21918
21919 // clean up
21920 #undef JSON_ASSERT
21921 #undef JSON_INTERNAL_CATCH
21922 #undef JSON_CATCH
21923 #undef JSON_THROW
21924 #undef JSON_TRY
21925 #undef JSON_PRIVATE_UNLESS_TESTED
21926 #undef JSON_HAS_CPP_11
21927 #undef JSON_HAS_CPP_14
21928 #undef JSON_HAS_CPP_17
21929 #undef JSON_HAS_CPP_20
21930 #undef JSON_HAS_FILESYSTEM
21931 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
21932 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
21933 #undef NLOHMANN_BASIC_JSON_TPL
21934 #undef JSON_EXPLICIT
21935 #undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
21936
21937 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
21938
21939
21940 #undef JSON_HEDLEY_ALWAYS_INLINE
21941 #undef JSON_HEDLEY_ARM_VERSION
21942 #undef JSON_HEDLEY_ARM_VERSION_CHECK
21943 #undef JSON_HEDLEY_ARRAY_PARAM
21944 #undef JSON_HEDLEY_ASSUME
21945 #undef JSON_HEDLEY_BEGIN_C_DECLS
21946 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
21947 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
21948 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
21949 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
21950 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
21951 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
21952 #undef JSON_HEDLEY_CLANG_HAS_WARNING
21953 #undef JSON_HEDLEY_COMPCERT_VERSION
21954 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
21955 #undef JSON_HEDLEY_CONCAT
21956 #undef JSON_HEDLEY_CONCAT3
21957 #undef JSON_HEDLEY_CONCAT3_EX
21958 #undef JSON_HEDLEY_CONCAT_EX
21959 #undef JSON_HEDLEY_CONST
21960 #undef JSON_HEDLEY_CONSTEXPR
21961 #undef JSON_HEDLEY_CONST_CAST
21962 #undef JSON_HEDLEY_CPP_CAST
21963 #undef JSON_HEDLEY_CRAY_VERSION
21964 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
21965 #undef JSON_HEDLEY_C_DECL
21966 #undef JSON_HEDLEY_DEPRECATED
21967 #undef JSON_HEDLEY_DEPRECATED_FOR
21968 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
21969 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
21970 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
21971 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
21972 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
21973 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
21974 #undef JSON_HEDLEY_DIAGNOSTIC_POP
21975 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
21976 #undef JSON_HEDLEY_DMC_VERSION
21977 #undef JSON_HEDLEY_DMC_VERSION_CHECK
21978 #undef JSON_HEDLEY_EMPTY_BASES
21979 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
21980 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
21981 #undef JSON_HEDLEY_END_C_DECLS
21982 #undef JSON_HEDLEY_FLAGS
21983 #undef JSON_HEDLEY_FLAGS_CAST
21984 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
21985 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
21986 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
21987 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
21988 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
21989 #undef JSON_HEDLEY_GCC_HAS_FEATURE
21990 #undef JSON_HEDLEY_GCC_HAS_WARNING
21991 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
21992 #undef JSON_HEDLEY_GCC_VERSION
21993 #undef JSON_HEDLEY_GCC_VERSION_CHECK
21994 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
21995 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
21996 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
21997 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
21998 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
21999 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
22000 #undef JSON_HEDLEY_GNUC_HAS_WARNING
22001 #undef JSON_HEDLEY_GNUC_VERSION
22002 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
22003 #undef JSON_HEDLEY_HAS_ATTRIBUTE
22004 #undef JSON_HEDLEY_HAS_BUILTIN
22005 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
22006 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
22007 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
22008 #undef JSON_HEDLEY_HAS_EXTENSION
22009 #undef JSON_HEDLEY_HAS_FEATURE
22010 #undef JSON_HEDLEY_HAS_WARNING
22011 #undef JSON_HEDLEY_IAR_VERSION
22012 #undef JSON_HEDLEY_IAR_VERSION_CHECK
22013 #undef JSON_HEDLEY_IBM_VERSION
22014 #undef JSON_HEDLEY_IBM_VERSION_CHECK
22015 #undef JSON_HEDLEY_IMPORT
22016 #undef JSON_HEDLEY_INLINE
22017 #undef JSON_HEDLEY_INTEL_CL_VERSION
22018 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
22019 #undef JSON_HEDLEY_INTEL_VERSION
22020 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
22021 #undef JSON_HEDLEY_IS_CONSTANT
22022 #undef JSON_HEDLEY_IS_CONSTEXPR_
22023 #undef JSON_HEDLEY_LIKELY
22024 #undef JSON_HEDLEY_MALLOC
22025 #undef JSON_HEDLEY_MCST_LCC_VERSION
22026 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
22027 #undef JSON_HEDLEY_MESSAGE
22028 #undef JSON_HEDLEY_MSVC_VERSION
22029 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
22030 #undef JSON_HEDLEY_NEVER_INLINE
22031 #undef JSON_HEDLEY_NON_NULL
22032 #undef JSON_HEDLEY_NO_ESCAPE
22033 #undef JSON_HEDLEY_NO_RETURN
22034 #undef JSON_HEDLEY_NO_THROW
22035 #undef JSON_HEDLEY_NULL
22036 #undef JSON_HEDLEY_PELLES_VERSION
22037 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
22038 #undef JSON_HEDLEY_PGI_VERSION
22039 #undef JSON_HEDLEY_PGI_VERSION_CHECK
22040 #undef JSON_HEDLEY_PREDICT
22041 #undef JSON_HEDLEY_PRINTF_FORMAT
22042 #undef JSON_HEDLEY_PRIVATE
22043 #undef JSON_HEDLEY_PUBLIC
22044 #undef JSON_HEDLEY_PURE
22045 #undef JSON_HEDLEY_REINTERPRET_CAST
22046 #undef JSON_HEDLEY_REQUIRE
22047 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
22048 #undef JSON_HEDLEY_REQUIRE_MSG
22049 #undef JSON_HEDLEY_RESTRICT
22050 #undef JSON_HEDLEY_RETURNS_NON_NULL
22051 #undef JSON_HEDLEY_SENTINEL
22052 #undef JSON_HEDLEY_STATIC_ASSERT
22053 #undef JSON_HEDLEY_STATIC_CAST
22054 #undef JSON_HEDLEY_STRINGIFY
22055 #undef JSON_HEDLEY_STRINGIFY_EX
22056 #undef JSON_HEDLEY_SUNPRO_VERSION
22057 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
22058 #undef JSON_HEDLEY_TINYC_VERSION
22059 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
22060 #undef JSON_HEDLEY_TI_ARMCL_VERSION
22061 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
22062 #undef JSON_HEDLEY_TI_CL2000_VERSION
22063 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
22064 #undef JSON_HEDLEY_TI_CL430_VERSION
22065 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
22066 #undef JSON_HEDLEY_TI_CL6X_VERSION
22067 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
22068 #undef JSON_HEDLEY_TI_CL7X_VERSION
22069 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
22070 #undef JSON_HEDLEY_TI_CLPRU_VERSION
22071 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
22072 #undef JSON_HEDLEY_TI_VERSION
22073 #undef JSON_HEDLEY_TI_VERSION_CHECK
22074 #undef JSON_HEDLEY_UNAVAILABLE
22075 #undef JSON_HEDLEY_UNLIKELY
22076 #undef JSON_HEDLEY_UNPREDICTABLE
22077 #undef JSON_HEDLEY_UNREACHABLE
22078 #undef JSON_HEDLEY_UNREACHABLE_RETURN
22079 #undef JSON_HEDLEY_VERSION
22080 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
22081 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
22082 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
22083 #undef JSON_HEDLEY_VERSION_ENCODE
22084 #undef JSON_HEDLEY_WARNING
22085 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
22086 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
22087 #undef JSON_HEDLEY_FALL_THROUGH
22088
22089
22090
22091 #endif  // INCLUDE_NLOHMANN_JSON_HPP_