Mercurial > minori
comparison dep/json/json.hpp @ 175:9b10175be389
dep/json: update to v3.11.3
anime/db: save anime list to database, very much untested and likely won't work as intended
| author | Paper <mrpapersonic@gmail.com> |
|---|---|
| date | Thu, 30 Nov 2023 13:52:26 -0500 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 174:f88eda79c60a | 175:9b10175be389 |
|---|---|
| 1 // __ _____ _____ _____ | |
| 2 // __| | __| | | | JSON for Modern C++ | |
| 3 // | | |__ | | | | | | version 3.11.3 | |
| 4 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 5 // | |
| 6 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 7 // SPDX-License-Identifier: MIT | |
| 8 | |
| 9 /****************************************************************************\ | |
| 10 * Note on documentation: The source files contain links to the online * | |
| 11 * documentation of the public API at https://json.nlohmann.me. This URL * | |
| 12 * contains the most recent documentation and should also be applicable to * | |
| 13 * previous versions; documentation for deprecated functions is not * | |
| 14 * removed, but marked deprecated. See "Generate documentation" section in * | |
| 15 * file docs/README.md. * | |
| 16 \****************************************************************************/ | |
| 17 | |
| 18 #ifndef INCLUDE_NLOHMANN_JSON_HPP_ | |
| 19 #define INCLUDE_NLOHMANN_JSON_HPP_ | |
| 20 | |
| 21 #include <algorithm> // all_of, find, for_each | |
| 22 #include <cstddef> // nullptr_t, ptrdiff_t, size_t | |
| 23 #include <functional> // hash, less | |
| 24 #include <initializer_list> // initializer_list | |
| 25 #ifndef JSON_NO_IO | |
| 26 #include <iosfwd> // istream, ostream | |
| 27 #endif // JSON_NO_IO | |
| 28 #include <iterator> // random_access_iterator_tag | |
| 29 #include <memory> // unique_ptr | |
| 30 #include <string> // string, stoi, to_string | |
| 31 #include <utility> // declval, forward, move, pair, swap | |
| 32 #include <vector> // vector | |
| 33 | |
| 34 // #include <nlohmann/adl_serializer.hpp> | |
| 35 // __ _____ _____ _____ | |
| 36 // __| | __| | | | JSON for Modern C++ | |
| 37 // | | |__ | | | | | | version 3.11.3 | |
| 38 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 39 // | |
| 40 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 41 // SPDX-License-Identifier: MIT | |
| 42 | |
| 43 | |
| 44 | |
| 45 #include <utility> | |
| 46 | |
| 47 // #include <nlohmann/detail/abi_macros.hpp> | |
| 48 // __ _____ _____ _____ | |
| 49 // __| | __| | | | JSON for Modern C++ | |
| 50 // | | |__ | | | | | | version 3.11.3 | |
| 51 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 52 // | |
| 53 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 54 // SPDX-License-Identifier: MIT | |
| 55 | |
| 56 | |
| 57 | |
| 58 // This file contains all macro definitions affecting or depending on the ABI | |
| 59 | |
| 60 #ifndef JSON_SKIP_LIBRARY_VERSION_CHECK | |
| 61 #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) | |
| 62 #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3 | |
| 63 #warning "Already included a different version of the library!" | |
| 64 #endif | |
| 65 #endif | |
| 66 #endif | |
| 67 | |
| 68 #define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) | |
| 69 #define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum) | |
| 70 #define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum) | |
| 71 | |
| 72 #ifndef JSON_DIAGNOSTICS | |
| 73 #define JSON_DIAGNOSTICS 0 | |
| 74 #endif | |
| 75 | |
| 76 #ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON | |
| 77 #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 | |
| 78 #endif | |
| 79 | |
| 80 #if JSON_DIAGNOSTICS | |
| 81 #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag | |
| 82 #else | |
| 83 #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS | |
| 84 #endif | |
| 85 | |
| 86 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON | |
| 87 #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp | |
| 88 #else | |
| 89 #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON | |
| 90 #endif | |
| 91 | |
| 92 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION | |
| 93 #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 | |
| 94 #endif | |
| 95 | |
| 96 // Construct the namespace ABI tags component | |
| 97 #define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b | |
| 98 #define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \ | |
| 99 NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) | |
| 100 | |
| 101 #define NLOHMANN_JSON_ABI_TAGS \ | |
| 102 NLOHMANN_JSON_ABI_TAGS_CONCAT( \ | |
| 103 NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ | |
| 104 NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON) | |
| 105 | |
| 106 // Construct the namespace version component | |
| 107 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ | |
| 108 _v ## major ## _ ## minor ## _ ## patch | |
| 109 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ | |
| 110 NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) | |
| 111 | |
| 112 #if NLOHMANN_JSON_NAMESPACE_NO_VERSION | |
| 113 #define NLOHMANN_JSON_NAMESPACE_VERSION | |
| 114 #else | |
| 115 #define NLOHMANN_JSON_NAMESPACE_VERSION \ | |
| 116 NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ | |
| 117 NLOHMANN_JSON_VERSION_MINOR, \ | |
| 118 NLOHMANN_JSON_VERSION_PATCH) | |
| 119 #endif | |
| 120 | |
| 121 // Combine namespace components | |
| 122 #define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b | |
| 123 #define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ | |
| 124 NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) | |
| 125 | |
| 126 #ifndef NLOHMANN_JSON_NAMESPACE | |
| 127 #define NLOHMANN_JSON_NAMESPACE \ | |
| 128 nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ | |
| 129 NLOHMANN_JSON_ABI_TAGS, \ | |
| 130 NLOHMANN_JSON_NAMESPACE_VERSION) | |
| 131 #endif | |
| 132 | |
| 133 #ifndef NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 134 #define NLOHMANN_JSON_NAMESPACE_BEGIN \ | |
| 135 namespace nlohmann \ | |
| 136 { \ | |
| 137 inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ | |
| 138 NLOHMANN_JSON_ABI_TAGS, \ | |
| 139 NLOHMANN_JSON_NAMESPACE_VERSION) \ | |
| 140 { | |
| 141 #endif | |
| 142 | |
| 143 #ifndef NLOHMANN_JSON_NAMESPACE_END | |
| 144 #define NLOHMANN_JSON_NAMESPACE_END \ | |
| 145 } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ | |
| 146 } // namespace nlohmann | |
| 147 #endif | |
| 148 | |
| 149 // #include <nlohmann/detail/conversions/from_json.hpp> | |
| 150 // __ _____ _____ _____ | |
| 151 // __| | __| | | | JSON for Modern C++ | |
| 152 // | | |__ | | | | | | version 3.11.3 | |
| 153 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 154 // | |
| 155 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 156 // SPDX-License-Identifier: MIT | |
| 157 | |
| 158 | |
| 159 | |
| 160 #include <algorithm> // transform | |
| 161 #include <array> // array | |
| 162 #include <forward_list> // forward_list | |
| 163 #include <iterator> // inserter, front_inserter, end | |
| 164 #include <map> // map | |
| 165 #include <string> // string | |
| 166 #include <tuple> // tuple, make_tuple | |
| 167 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible | |
| 168 #include <unordered_map> // unordered_map | |
| 169 #include <utility> // pair, declval | |
| 170 #include <valarray> // valarray | |
| 171 | |
| 172 // #include <nlohmann/detail/exceptions.hpp> | |
| 173 // __ _____ _____ _____ | |
| 174 // __| | __| | | | JSON for Modern C++ | |
| 175 // | | |__ | | | | | | version 3.11.3 | |
| 176 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 177 // | |
| 178 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 179 // SPDX-License-Identifier: MIT | |
| 180 | |
| 181 | |
| 182 | |
| 183 #include <cstddef> // nullptr_t | |
| 184 #include <exception> // exception | |
| 185 #if JSON_DIAGNOSTICS | |
| 186 #include <numeric> // accumulate | |
| 187 #endif | |
| 188 #include <stdexcept> // runtime_error | |
| 189 #include <string> // to_string | |
| 190 #include <vector> // vector | |
| 191 | |
| 192 // #include <nlohmann/detail/value_t.hpp> | |
| 193 // __ _____ _____ _____ | |
| 194 // __| | __| | | | JSON for Modern C++ | |
| 195 // | | |__ | | | | | | version 3.11.3 | |
| 196 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 197 // | |
| 198 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 199 // SPDX-License-Identifier: MIT | |
| 200 | |
| 201 | |
| 202 | |
| 203 #include <array> // array | |
| 204 #include <cstddef> // size_t | |
| 205 #include <cstdint> // uint8_t | |
| 206 #include <string> // string | |
| 207 | |
| 208 // #include <nlohmann/detail/macro_scope.hpp> | |
| 209 // __ _____ _____ _____ | |
| 210 // __| | __| | | | JSON for Modern C++ | |
| 211 // | | |__ | | | | | | version 3.11.3 | |
| 212 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 213 // | |
| 214 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 215 // SPDX-License-Identifier: MIT | |
| 216 | |
| 217 | |
| 218 | |
| 219 #include <utility> // declval, pair | |
| 220 // #include <nlohmann/detail/meta/detected.hpp> | |
| 221 // __ _____ _____ _____ | |
| 222 // __| | __| | | | JSON for Modern C++ | |
| 223 // | | |__ | | | | | | version 3.11.3 | |
| 224 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 225 // | |
| 226 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 227 // SPDX-License-Identifier: MIT | |
| 228 | |
| 229 | |
| 230 | |
| 231 #include <type_traits> | |
| 232 | |
| 233 // #include <nlohmann/detail/meta/void_t.hpp> | |
| 234 // __ _____ _____ _____ | |
| 235 // __| | __| | | | JSON for Modern C++ | |
| 236 // | | |__ | | | | | | version 3.11.3 | |
| 237 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 238 // | |
| 239 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 240 // SPDX-License-Identifier: MIT | |
| 241 | |
| 242 | |
| 243 | |
| 244 // #include <nlohmann/detail/abi_macros.hpp> | |
| 245 | |
| 246 | |
| 247 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 248 namespace detail | |
| 249 { | |
| 250 | |
| 251 template<typename ...Ts> struct make_void | |
| 252 { | |
| 253 using type = void; | |
| 254 }; | |
| 255 template<typename ...Ts> using void_t = typename make_void<Ts...>::type; | |
| 256 | |
| 257 } // namespace detail | |
| 258 NLOHMANN_JSON_NAMESPACE_END | |
| 259 | |
| 260 | |
| 261 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 262 namespace detail | |
| 263 { | |
| 264 | |
| 265 // https://en.cppreference.com/w/cpp/experimental/is_detected | |
| 266 struct nonesuch | |
| 267 { | |
| 268 nonesuch() = delete; | |
| 269 ~nonesuch() = delete; | |
| 270 nonesuch(nonesuch const&) = delete; | |
| 271 nonesuch(nonesuch const&&) = delete; | |
| 272 void operator=(nonesuch const&) = delete; | |
| 273 void operator=(nonesuch&&) = delete; | |
| 274 }; | |
| 275 | |
| 276 template<class Default, | |
| 277 class AlwaysVoid, | |
| 278 template<class...> class Op, | |
| 279 class... Args> | |
| 280 struct detector | |
| 281 { | |
| 282 using value_t = std::false_type; | |
| 283 using type = Default; | |
| 284 }; | |
| 285 | |
| 286 template<class Default, template<class...> class Op, class... Args> | |
| 287 struct detector<Default, void_t<Op<Args...>>, Op, Args...> | |
| 288 { | |
| 289 using value_t = std::true_type; | |
| 290 using type = Op<Args...>; | |
| 291 }; | |
| 292 | |
| 293 template<template<class...> class Op, class... Args> | |
| 294 using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t; | |
| 295 | |
| 296 template<template<class...> class Op, class... Args> | |
| 297 struct is_detected_lazy : is_detected<Op, Args...> { }; | |
| 298 | |
| 299 template<template<class...> class Op, class... Args> | |
| 300 using detected_t = typename detector<nonesuch, void, Op, Args...>::type; | |
| 301 | |
| 302 template<class Default, template<class...> class Op, class... Args> | |
| 303 using detected_or = detector<Default, void, Op, Args...>; | |
| 304 | |
| 305 template<class Default, template<class...> class Op, class... Args> | |
| 306 using detected_or_t = typename detected_or<Default, Op, Args...>::type; | |
| 307 | |
| 308 template<class Expected, template<class...> class Op, class... Args> | |
| 309 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>; | |
| 310 | |
| 311 template<class To, template<class...> class Op, class... Args> | |
| 312 using is_detected_convertible = | |
| 313 std::is_convertible<detected_t<Op, Args...>, To>; | |
| 314 | |
| 315 } // namespace detail | |
| 316 NLOHMANN_JSON_NAMESPACE_END | |
| 317 | |
| 318 // #include <nlohmann/thirdparty/hedley/hedley.hpp> | |
| 319 | |
| 320 | |
| 321 // __ _____ _____ _____ | |
| 322 // __| | __| | | | JSON for Modern C++ | |
| 323 // | | |__ | | | | | | version 3.11.3 | |
| 324 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 325 // | |
| 326 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 327 // SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com> | |
| 328 // SPDX-License-Identifier: MIT | |
| 329 | |
| 330 /* Hedley - https://nemequ.github.io/hedley | |
| 331 * Created by Evan Nemerson <evan@nemerson.com> | |
| 332 */ | |
| 333 | |
| 334 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) | |
| 335 #if defined(JSON_HEDLEY_VERSION) | |
| 336 #undef JSON_HEDLEY_VERSION | |
| 337 #endif | |
| 338 #define JSON_HEDLEY_VERSION 15 | |
| 339 | |
| 340 #if defined(JSON_HEDLEY_STRINGIFY_EX) | |
| 341 #undef JSON_HEDLEY_STRINGIFY_EX | |
| 342 #endif | |
| 343 #define JSON_HEDLEY_STRINGIFY_EX(x) #x | |
| 344 | |
| 345 #if defined(JSON_HEDLEY_STRINGIFY) | |
| 346 #undef JSON_HEDLEY_STRINGIFY | |
| 347 #endif | |
| 348 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) | |
| 349 | |
| 350 #if defined(JSON_HEDLEY_CONCAT_EX) | |
| 351 #undef JSON_HEDLEY_CONCAT_EX | |
| 352 #endif | |
| 353 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b | |
| 354 | |
| 355 #if defined(JSON_HEDLEY_CONCAT) | |
| 356 #undef JSON_HEDLEY_CONCAT | |
| 357 #endif | |
| 358 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) | |
| 359 | |
| 360 #if defined(JSON_HEDLEY_CONCAT3_EX) | |
| 361 #undef JSON_HEDLEY_CONCAT3_EX | |
| 362 #endif | |
| 363 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c | |
| 364 | |
| 365 #if defined(JSON_HEDLEY_CONCAT3) | |
| 366 #undef JSON_HEDLEY_CONCAT3 | |
| 367 #endif | |
| 368 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) | |
| 369 | |
| 370 #if defined(JSON_HEDLEY_VERSION_ENCODE) | |
| 371 #undef JSON_HEDLEY_VERSION_ENCODE | |
| 372 #endif | |
| 373 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) | |
| 374 | |
| 375 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) | |
| 376 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR | |
| 377 #endif | |
| 378 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) | |
| 379 | |
| 380 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) | |
| 381 #undef JSON_HEDLEY_VERSION_DECODE_MINOR | |
| 382 #endif | |
| 383 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) | |
| 384 | |
| 385 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) | |
| 386 #undef JSON_HEDLEY_VERSION_DECODE_REVISION | |
| 387 #endif | |
| 388 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) | |
| 389 | |
| 390 #if defined(JSON_HEDLEY_GNUC_VERSION) | |
| 391 #undef JSON_HEDLEY_GNUC_VERSION | |
| 392 #endif | |
| 393 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) | |
| 394 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) | |
| 395 #elif defined(__GNUC__) | |
| 396 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) | |
| 397 #endif | |
| 398 | |
| 399 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) | |
| 400 #undef JSON_HEDLEY_GNUC_VERSION_CHECK | |
| 401 #endif | |
| 402 #if defined(JSON_HEDLEY_GNUC_VERSION) | |
| 403 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 404 #else | |
| 405 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) | |
| 406 #endif | |
| 407 | |
| 408 #if defined(JSON_HEDLEY_MSVC_VERSION) | |
| 409 #undef JSON_HEDLEY_MSVC_VERSION | |
| 410 #endif | |
| 411 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) | |
| 412 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) | |
| 413 #elif defined(_MSC_FULL_VER) && !defined(__ICL) | |
| 414 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) | |
| 415 #elif defined(_MSC_VER) && !defined(__ICL) | |
| 416 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) | |
| 417 #endif | |
| 418 | |
| 419 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) | |
| 420 #undef JSON_HEDLEY_MSVC_VERSION_CHECK | |
| 421 #endif | |
| 422 #if !defined(JSON_HEDLEY_MSVC_VERSION) | |
| 423 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) | |
| 424 #elif defined(_MSC_VER) && (_MSC_VER >= 1400) | |
| 425 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) | |
| 426 #elif defined(_MSC_VER) && (_MSC_VER >= 1200) | |
| 427 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) | |
| 428 #else | |
| 429 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) | |
| 430 #endif | |
| 431 | |
| 432 #if defined(JSON_HEDLEY_INTEL_VERSION) | |
| 433 #undef JSON_HEDLEY_INTEL_VERSION | |
| 434 #endif | |
| 435 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) | |
| 436 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) | |
| 437 #elif defined(__INTEL_COMPILER) && !defined(__ICL) | |
| 438 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) | |
| 439 #endif | |
| 440 | |
| 441 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) | |
| 442 #undef JSON_HEDLEY_INTEL_VERSION_CHECK | |
| 443 #endif | |
| 444 #if defined(JSON_HEDLEY_INTEL_VERSION) | |
| 445 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 446 #else | |
| 447 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) | |
| 448 #endif | |
| 449 | |
| 450 #if defined(JSON_HEDLEY_INTEL_CL_VERSION) | |
| 451 #undef JSON_HEDLEY_INTEL_CL_VERSION | |
| 452 #endif | |
| 453 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) | |
| 454 #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) | |
| 455 #endif | |
| 456 | |
| 457 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) | |
| 458 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK | |
| 459 #endif | |
| 460 #if defined(JSON_HEDLEY_INTEL_CL_VERSION) | |
| 461 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 462 #else | |
| 463 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) | |
| 464 #endif | |
| 465 | |
| 466 #if defined(JSON_HEDLEY_PGI_VERSION) | |
| 467 #undef JSON_HEDLEY_PGI_VERSION | |
| 468 #endif | |
| 469 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) | |
| 470 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) | |
| 471 #endif | |
| 472 | |
| 473 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK) | |
| 474 #undef JSON_HEDLEY_PGI_VERSION_CHECK | |
| 475 #endif | |
| 476 #if defined(JSON_HEDLEY_PGI_VERSION) | |
| 477 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 478 #else | |
| 479 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) | |
| 480 #endif | |
| 481 | |
| 482 #if defined(JSON_HEDLEY_SUNPRO_VERSION) | |
| 483 #undef JSON_HEDLEY_SUNPRO_VERSION | |
| 484 #endif | |
| 485 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) | |
| 486 #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) | |
| 487 #elif defined(__SUNPRO_C) | |
| 488 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) | |
| 489 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) | |
| 490 #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) | |
| 491 #elif defined(__SUNPRO_CC) | |
| 492 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) | |
| 493 #endif | |
| 494 | |
| 495 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) | |
| 496 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK | |
| 497 #endif | |
| 498 #if defined(JSON_HEDLEY_SUNPRO_VERSION) | |
| 499 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 500 #else | |
| 501 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) | |
| 502 #endif | |
| 503 | |
| 504 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) | |
| 505 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION | |
| 506 #endif | |
| 507 #if defined(__EMSCRIPTEN__) | |
| 508 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) | |
| 509 #endif | |
| 510 | |
| 511 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) | |
| 512 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK | |
| 513 #endif | |
| 514 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) | |
| 515 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 516 #else | |
| 517 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) | |
| 518 #endif | |
| 519 | |
| 520 #if defined(JSON_HEDLEY_ARM_VERSION) | |
| 521 #undef JSON_HEDLEY_ARM_VERSION | |
| 522 #endif | |
| 523 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) | |
| 524 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) | |
| 525 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION) | |
| 526 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) | |
| 527 #endif | |
| 528 | |
| 529 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK) | |
| 530 #undef JSON_HEDLEY_ARM_VERSION_CHECK | |
| 531 #endif | |
| 532 #if defined(JSON_HEDLEY_ARM_VERSION) | |
| 533 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 534 #else | |
| 535 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) | |
| 536 #endif | |
| 537 | |
| 538 #if defined(JSON_HEDLEY_IBM_VERSION) | |
| 539 #undef JSON_HEDLEY_IBM_VERSION | |
| 540 #endif | |
| 541 #if defined(__ibmxl__) | |
| 542 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) | |
| 543 #elif defined(__xlC__) && defined(__xlC_ver__) | |
| 544 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) | |
| 545 #elif defined(__xlC__) | |
| 546 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) | |
| 547 #endif | |
| 548 | |
| 549 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK) | |
| 550 #undef JSON_HEDLEY_IBM_VERSION_CHECK | |
| 551 #endif | |
| 552 #if defined(JSON_HEDLEY_IBM_VERSION) | |
| 553 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 554 #else | |
| 555 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) | |
| 556 #endif | |
| 557 | |
| 558 #if defined(JSON_HEDLEY_TI_VERSION) | |
| 559 #undef JSON_HEDLEY_TI_VERSION | |
| 560 #endif | |
| 561 #if \ | |
| 562 defined(__TI_COMPILER_VERSION__) && \ | |
| 563 ( \ | |
| 564 defined(__TMS470__) || defined(__TI_ARM__) || \ | |
| 565 defined(__MSP430__) || \ | |
| 566 defined(__TMS320C2000__) \ | |
| 567 ) | |
| 568 #if (__TI_COMPILER_VERSION__ >= 16000000) | |
| 569 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 570 #endif | |
| 571 #endif | |
| 572 | |
| 573 #if defined(JSON_HEDLEY_TI_VERSION_CHECK) | |
| 574 #undef JSON_HEDLEY_TI_VERSION_CHECK | |
| 575 #endif | |
| 576 #if defined(JSON_HEDLEY_TI_VERSION) | |
| 577 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 578 #else | |
| 579 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) | |
| 580 #endif | |
| 581 | |
| 582 #if defined(JSON_HEDLEY_TI_CL2000_VERSION) | |
| 583 #undef JSON_HEDLEY_TI_CL2000_VERSION | |
| 584 #endif | |
| 585 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) | |
| 586 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 587 #endif | |
| 588 | |
| 589 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) | |
| 590 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK | |
| 591 #endif | |
| 592 #if defined(JSON_HEDLEY_TI_CL2000_VERSION) | |
| 593 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 594 #else | |
| 595 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) | |
| 596 #endif | |
| 597 | |
| 598 #if defined(JSON_HEDLEY_TI_CL430_VERSION) | |
| 599 #undef JSON_HEDLEY_TI_CL430_VERSION | |
| 600 #endif | |
| 601 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) | |
| 602 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 603 #endif | |
| 604 | |
| 605 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) | |
| 606 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK | |
| 607 #endif | |
| 608 #if defined(JSON_HEDLEY_TI_CL430_VERSION) | |
| 609 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 610 #else | |
| 611 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) | |
| 612 #endif | |
| 613 | |
| 614 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION) | |
| 615 #undef JSON_HEDLEY_TI_ARMCL_VERSION | |
| 616 #endif | |
| 617 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) | |
| 618 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 619 #endif | |
| 620 | |
| 621 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) | |
| 622 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK | |
| 623 #endif | |
| 624 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION) | |
| 625 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 626 #else | |
| 627 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) | |
| 628 #endif | |
| 629 | |
| 630 #if defined(JSON_HEDLEY_TI_CL6X_VERSION) | |
| 631 #undef JSON_HEDLEY_TI_CL6X_VERSION | |
| 632 #endif | |
| 633 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) | |
| 634 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 635 #endif | |
| 636 | |
| 637 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) | |
| 638 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK | |
| 639 #endif | |
| 640 #if defined(JSON_HEDLEY_TI_CL6X_VERSION) | |
| 641 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 642 #else | |
| 643 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) | |
| 644 #endif | |
| 645 | |
| 646 #if defined(JSON_HEDLEY_TI_CL7X_VERSION) | |
| 647 #undef JSON_HEDLEY_TI_CL7X_VERSION | |
| 648 #endif | |
| 649 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) | |
| 650 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 651 #endif | |
| 652 | |
| 653 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) | |
| 654 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK | |
| 655 #endif | |
| 656 #if defined(JSON_HEDLEY_TI_CL7X_VERSION) | |
| 657 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 658 #else | |
| 659 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) | |
| 660 #endif | |
| 661 | |
| 662 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION) | |
| 663 #undef JSON_HEDLEY_TI_CLPRU_VERSION | |
| 664 #endif | |
| 665 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) | |
| 666 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) | |
| 667 #endif | |
| 668 | |
| 669 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) | |
| 670 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK | |
| 671 #endif | |
| 672 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION) | |
| 673 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 674 #else | |
| 675 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) | |
| 676 #endif | |
| 677 | |
| 678 #if defined(JSON_HEDLEY_CRAY_VERSION) | |
| 679 #undef JSON_HEDLEY_CRAY_VERSION | |
| 680 #endif | |
| 681 #if defined(_CRAYC) | |
| 682 #if defined(_RELEASE_PATCHLEVEL) | |
| 683 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) | |
| 684 #else | |
| 685 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) | |
| 686 #endif | |
| 687 #endif | |
| 688 | |
| 689 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) | |
| 690 #undef JSON_HEDLEY_CRAY_VERSION_CHECK | |
| 691 #endif | |
| 692 #if defined(JSON_HEDLEY_CRAY_VERSION) | |
| 693 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 694 #else | |
| 695 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) | |
| 696 #endif | |
| 697 | |
| 698 #if defined(JSON_HEDLEY_IAR_VERSION) | |
| 699 #undef JSON_HEDLEY_IAR_VERSION | |
| 700 #endif | |
| 701 #if defined(__IAR_SYSTEMS_ICC__) | |
| 702 #if __VER__ > 1000 | |
| 703 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) | |
| 704 #else | |
| 705 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) | |
| 706 #endif | |
| 707 #endif | |
| 708 | |
| 709 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK) | |
| 710 #undef JSON_HEDLEY_IAR_VERSION_CHECK | |
| 711 #endif | |
| 712 #if defined(JSON_HEDLEY_IAR_VERSION) | |
| 713 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 714 #else | |
| 715 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) | |
| 716 #endif | |
| 717 | |
| 718 #if defined(JSON_HEDLEY_TINYC_VERSION) | |
| 719 #undef JSON_HEDLEY_TINYC_VERSION | |
| 720 #endif | |
| 721 #if defined(__TINYC__) | |
| 722 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) | |
| 723 #endif | |
| 724 | |
| 725 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) | |
| 726 #undef JSON_HEDLEY_TINYC_VERSION_CHECK | |
| 727 #endif | |
| 728 #if defined(JSON_HEDLEY_TINYC_VERSION) | |
| 729 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 730 #else | |
| 731 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) | |
| 732 #endif | |
| 733 | |
| 734 #if defined(JSON_HEDLEY_DMC_VERSION) | |
| 735 #undef JSON_HEDLEY_DMC_VERSION | |
| 736 #endif | |
| 737 #if defined(__DMC__) | |
| 738 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) | |
| 739 #endif | |
| 740 | |
| 741 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK) | |
| 742 #undef JSON_HEDLEY_DMC_VERSION_CHECK | |
| 743 #endif | |
| 744 #if defined(JSON_HEDLEY_DMC_VERSION) | |
| 745 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 746 #else | |
| 747 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) | |
| 748 #endif | |
| 749 | |
| 750 #if defined(JSON_HEDLEY_COMPCERT_VERSION) | |
| 751 #undef JSON_HEDLEY_COMPCERT_VERSION | |
| 752 #endif | |
| 753 #if defined(__COMPCERT_VERSION__) | |
| 754 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) | |
| 755 #endif | |
| 756 | |
| 757 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) | |
| 758 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK | |
| 759 #endif | |
| 760 #if defined(JSON_HEDLEY_COMPCERT_VERSION) | |
| 761 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 762 #else | |
| 763 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) | |
| 764 #endif | |
| 765 | |
| 766 #if defined(JSON_HEDLEY_PELLES_VERSION) | |
| 767 #undef JSON_HEDLEY_PELLES_VERSION | |
| 768 #endif | |
| 769 #if defined(__POCC__) | |
| 770 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) | |
| 771 #endif | |
| 772 | |
| 773 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) | |
| 774 #undef JSON_HEDLEY_PELLES_VERSION_CHECK | |
| 775 #endif | |
| 776 #if defined(JSON_HEDLEY_PELLES_VERSION) | |
| 777 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 778 #else | |
| 779 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) | |
| 780 #endif | |
| 781 | |
| 782 #if defined(JSON_HEDLEY_MCST_LCC_VERSION) | |
| 783 #undef JSON_HEDLEY_MCST_LCC_VERSION | |
| 784 #endif | |
| 785 #if defined(__LCC__) && defined(__LCC_MINOR__) | |
| 786 #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) | |
| 787 #endif | |
| 788 | |
| 789 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) | |
| 790 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK | |
| 791 #endif | |
| 792 #if defined(JSON_HEDLEY_MCST_LCC_VERSION) | |
| 793 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 794 #else | |
| 795 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) | |
| 796 #endif | |
| 797 | |
| 798 #if defined(JSON_HEDLEY_GCC_VERSION) | |
| 799 #undef JSON_HEDLEY_GCC_VERSION | |
| 800 #endif | |
| 801 #if \ | |
| 802 defined(JSON_HEDLEY_GNUC_VERSION) && \ | |
| 803 !defined(__clang__) && \ | |
| 804 !defined(JSON_HEDLEY_INTEL_VERSION) && \ | |
| 805 !defined(JSON_HEDLEY_PGI_VERSION) && \ | |
| 806 !defined(JSON_HEDLEY_ARM_VERSION) && \ | |
| 807 !defined(JSON_HEDLEY_CRAY_VERSION) && \ | |
| 808 !defined(JSON_HEDLEY_TI_VERSION) && \ | |
| 809 !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ | |
| 810 !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ | |
| 811 !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ | |
| 812 !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ | |
| 813 !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ | |
| 814 !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ | |
| 815 !defined(__COMPCERT__) && \ | |
| 816 !defined(JSON_HEDLEY_MCST_LCC_VERSION) | |
| 817 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION | |
| 818 #endif | |
| 819 | |
| 820 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK) | |
| 821 #undef JSON_HEDLEY_GCC_VERSION_CHECK | |
| 822 #endif | |
| 823 #if defined(JSON_HEDLEY_GCC_VERSION) | |
| 824 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) | |
| 825 #else | |
| 826 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) | |
| 827 #endif | |
| 828 | |
| 829 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE) | |
| 830 #undef JSON_HEDLEY_HAS_ATTRIBUTE | |
| 831 #endif | |
| 832 #if \ | |
| 833 defined(__has_attribute) && \ | |
| 834 ( \ | |
| 835 (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ | |
| 836 ) | |
| 837 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) | |
| 838 #else | |
| 839 # define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) | |
| 840 #endif | |
| 841 | |
| 842 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) | |
| 843 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE | |
| 844 #endif | |
| 845 #if defined(__has_attribute) | |
| 846 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) | |
| 847 #else | |
| 848 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 849 #endif | |
| 850 | |
| 851 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) | |
| 852 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE | |
| 853 #endif | |
| 854 #if defined(__has_attribute) | |
| 855 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) | |
| 856 #else | |
| 857 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 858 #endif | |
| 859 | |
| 860 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) | |
| 861 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE | |
| 862 #endif | |
| 863 #if \ | |
| 864 defined(__has_cpp_attribute) && \ | |
| 865 defined(__cplusplus) && \ | |
| 866 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) | |
| 867 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) | |
| 868 #else | |
| 869 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) | |
| 870 #endif | |
| 871 | |
| 872 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) | |
| 873 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS | |
| 874 #endif | |
| 875 #if !defined(__cplusplus) || !defined(__has_cpp_attribute) | |
| 876 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) | |
| 877 #elif \ | |
| 878 !defined(JSON_HEDLEY_PGI_VERSION) && \ | |
| 879 !defined(JSON_HEDLEY_IAR_VERSION) && \ | |
| 880 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ | |
| 881 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) | |
| 882 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) | |
| 883 #else | |
| 884 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) | |
| 885 #endif | |
| 886 | |
| 887 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) | |
| 888 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE | |
| 889 #endif | |
| 890 #if defined(__has_cpp_attribute) && defined(__cplusplus) | |
| 891 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) | |
| 892 #else | |
| 893 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 894 #endif | |
| 895 | |
| 896 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) | |
| 897 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE | |
| 898 #endif | |
| 899 #if defined(__has_cpp_attribute) && defined(__cplusplus) | |
| 900 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) | |
| 901 #else | |
| 902 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 903 #endif | |
| 904 | |
| 905 #if defined(JSON_HEDLEY_HAS_BUILTIN) | |
| 906 #undef JSON_HEDLEY_HAS_BUILTIN | |
| 907 #endif | |
| 908 #if defined(__has_builtin) | |
| 909 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) | |
| 910 #else | |
| 911 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) | |
| 912 #endif | |
| 913 | |
| 914 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) | |
| 915 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN | |
| 916 #endif | |
| 917 #if defined(__has_builtin) | |
| 918 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) | |
| 919 #else | |
| 920 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 921 #endif | |
| 922 | |
| 923 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) | |
| 924 #undef JSON_HEDLEY_GCC_HAS_BUILTIN | |
| 925 #endif | |
| 926 #if defined(__has_builtin) | |
| 927 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) | |
| 928 #else | |
| 929 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 930 #endif | |
| 931 | |
| 932 #if defined(JSON_HEDLEY_HAS_FEATURE) | |
| 933 #undef JSON_HEDLEY_HAS_FEATURE | |
| 934 #endif | |
| 935 #if defined(__has_feature) | |
| 936 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) | |
| 937 #else | |
| 938 #define JSON_HEDLEY_HAS_FEATURE(feature) (0) | |
| 939 #endif | |
| 940 | |
| 941 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) | |
| 942 #undef JSON_HEDLEY_GNUC_HAS_FEATURE | |
| 943 #endif | |
| 944 #if defined(__has_feature) | |
| 945 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) | |
| 946 #else | |
| 947 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 948 #endif | |
| 949 | |
| 950 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE) | |
| 951 #undef JSON_HEDLEY_GCC_HAS_FEATURE | |
| 952 #endif | |
| 953 #if defined(__has_feature) | |
| 954 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) | |
| 955 #else | |
| 956 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 957 #endif | |
| 958 | |
| 959 #if defined(JSON_HEDLEY_HAS_EXTENSION) | |
| 960 #undef JSON_HEDLEY_HAS_EXTENSION | |
| 961 #endif | |
| 962 #if defined(__has_extension) | |
| 963 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) | |
| 964 #else | |
| 965 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) | |
| 966 #endif | |
| 967 | |
| 968 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) | |
| 969 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION | |
| 970 #endif | |
| 971 #if defined(__has_extension) | |
| 972 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) | |
| 973 #else | |
| 974 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 975 #endif | |
| 976 | |
| 977 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) | |
| 978 #undef JSON_HEDLEY_GCC_HAS_EXTENSION | |
| 979 #endif | |
| 980 #if defined(__has_extension) | |
| 981 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) | |
| 982 #else | |
| 983 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 984 #endif | |
| 985 | |
| 986 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) | |
| 987 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE | |
| 988 #endif | |
| 989 #if defined(__has_declspec_attribute) | |
| 990 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) | |
| 991 #else | |
| 992 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) | |
| 993 #endif | |
| 994 | |
| 995 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) | |
| 996 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE | |
| 997 #endif | |
| 998 #if defined(__has_declspec_attribute) | |
| 999 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) | |
| 1000 #else | |
| 1001 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 1002 #endif | |
| 1003 | |
| 1004 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) | |
| 1005 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE | |
| 1006 #endif | |
| 1007 #if defined(__has_declspec_attribute) | |
| 1008 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) | |
| 1009 #else | |
| 1010 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 1011 #endif | |
| 1012 | |
| 1013 #if defined(JSON_HEDLEY_HAS_WARNING) | |
| 1014 #undef JSON_HEDLEY_HAS_WARNING | |
| 1015 #endif | |
| 1016 #if defined(__has_warning) | |
| 1017 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) | |
| 1018 #else | |
| 1019 #define JSON_HEDLEY_HAS_WARNING(warning) (0) | |
| 1020 #endif | |
| 1021 | |
| 1022 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING) | |
| 1023 #undef JSON_HEDLEY_GNUC_HAS_WARNING | |
| 1024 #endif | |
| 1025 #if defined(__has_warning) | |
| 1026 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) | |
| 1027 #else | |
| 1028 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) | |
| 1029 #endif | |
| 1030 | |
| 1031 #if defined(JSON_HEDLEY_GCC_HAS_WARNING) | |
| 1032 #undef JSON_HEDLEY_GCC_HAS_WARNING | |
| 1033 #endif | |
| 1034 #if defined(__has_warning) | |
| 1035 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) | |
| 1036 #else | |
| 1037 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 1038 #endif | |
| 1039 | |
| 1040 #if \ | |
| 1041 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ | |
| 1042 defined(__clang__) || \ | |
| 1043 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ | |
| 1044 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1045 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ | |
| 1046 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ | |
| 1047 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1048 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1049 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ | |
| 1050 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ | |
| 1051 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ | |
| 1052 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ | |
| 1053 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1054 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1055 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ | |
| 1056 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ | |
| 1057 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ | |
| 1058 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) | |
| 1059 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) | |
| 1060 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) | |
| 1061 #define JSON_HEDLEY_PRAGMA(value) __pragma(value) | |
| 1062 #else | |
| 1063 #define JSON_HEDLEY_PRAGMA(value) | |
| 1064 #endif | |
| 1065 | |
| 1066 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) | |
| 1067 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH | |
| 1068 #endif | |
| 1069 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP) | |
| 1070 #undef JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1071 #endif | |
| 1072 #if defined(__clang__) | |
| 1073 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") | |
| 1074 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") | |
| 1075 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 1076 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") | |
| 1077 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") | |
| 1078 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) | |
| 1079 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") | |
| 1080 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") | |
| 1081 #elif \ | |
| 1082 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ | |
| 1083 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1084 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) | |
| 1085 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) | |
| 1086 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) | |
| 1087 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") | |
| 1088 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") | |
| 1089 #elif \ | |
| 1090 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1091 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1092 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ | |
| 1093 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ | |
| 1094 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1095 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) | |
| 1096 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") | |
| 1097 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") | |
| 1098 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) | |
| 1099 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") | |
| 1100 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") | |
| 1101 #else | |
| 1102 #define JSON_HEDLEY_DIAGNOSTIC_PUSH | |
| 1103 #define JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1104 #endif | |
| 1105 | |
| 1106 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for | |
| 1107 HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ | |
| 1108 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) | |
| 1109 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ | |
| 1110 #endif | |
| 1111 #if defined(__cplusplus) | |
| 1112 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") | |
| 1113 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") | |
| 1114 # if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") | |
| 1115 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ | |
| 1116 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 1117 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ | |
| 1118 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ | |
| 1119 _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ | |
| 1120 xpr \ | |
| 1121 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1122 # else | |
| 1123 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ | |
| 1124 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 1125 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ | |
| 1126 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ | |
| 1127 xpr \ | |
| 1128 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1129 # endif | |
| 1130 # else | |
| 1131 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ | |
| 1132 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 1133 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ | |
| 1134 xpr \ | |
| 1135 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1136 # endif | |
| 1137 # endif | |
| 1138 #endif | |
| 1139 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) | |
| 1140 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x | |
| 1141 #endif | |
| 1142 | |
| 1143 #if defined(JSON_HEDLEY_CONST_CAST) | |
| 1144 #undef JSON_HEDLEY_CONST_CAST | |
| 1145 #endif | |
| 1146 #if defined(__cplusplus) | |
| 1147 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr)) | |
| 1148 #elif \ | |
| 1149 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ | |
| 1150 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ | |
| 1151 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 1152 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ | |
| 1153 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 1154 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ | |
| 1155 ((T) (expr)); \ | |
| 1156 JSON_HEDLEY_DIAGNOSTIC_POP \ | |
| 1157 })) | |
| 1158 #else | |
| 1159 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) | |
| 1160 #endif | |
| 1161 | |
| 1162 #if defined(JSON_HEDLEY_REINTERPRET_CAST) | |
| 1163 #undef JSON_HEDLEY_REINTERPRET_CAST | |
| 1164 #endif | |
| 1165 #if defined(__cplusplus) | |
| 1166 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr)) | |
| 1167 #else | |
| 1168 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) | |
| 1169 #endif | |
| 1170 | |
| 1171 #if defined(JSON_HEDLEY_STATIC_CAST) | |
| 1172 #undef JSON_HEDLEY_STATIC_CAST | |
| 1173 #endif | |
| 1174 #if defined(__cplusplus) | |
| 1175 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr)) | |
| 1176 #else | |
| 1177 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) | |
| 1178 #endif | |
| 1179 | |
| 1180 #if defined(JSON_HEDLEY_CPP_CAST) | |
| 1181 #undef JSON_HEDLEY_CPP_CAST | |
| 1182 #endif | |
| 1183 #if defined(__cplusplus) | |
| 1184 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") | |
| 1185 # define JSON_HEDLEY_CPP_CAST(T, expr) \ | |
| 1186 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 1187 _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ | |
| 1188 ((T) (expr)) \ | |
| 1189 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1190 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) | |
| 1191 # define JSON_HEDLEY_CPP_CAST(T, expr) \ | |
| 1192 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 1193 _Pragma("diag_suppress=Pe137") \ | |
| 1194 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1195 # else | |
| 1196 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) | |
| 1197 # endif | |
| 1198 #else | |
| 1199 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr) | |
| 1200 #endif | |
| 1201 | |
| 1202 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) | |
| 1203 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED | |
| 1204 #endif | |
| 1205 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") | |
| 1206 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") | |
| 1207 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 1208 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") | |
| 1209 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1210 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) | |
| 1211 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) | |
| 1212 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") | |
| 1213 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) | |
| 1214 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") | |
| 1215 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) | |
| 1216 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") | |
| 1217 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) | |
| 1218 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) | |
| 1219 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1220 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") | |
| 1221 #elif \ | |
| 1222 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1223 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1224 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1225 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1226 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1227 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1228 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1229 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1230 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1231 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1232 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) | |
| 1233 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") | |
| 1234 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) | |
| 1235 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") | |
| 1236 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) | |
| 1237 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") | |
| 1238 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1239 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") | |
| 1240 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) | |
| 1241 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") | |
| 1242 #else | |
| 1243 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED | |
| 1244 #endif | |
| 1245 | |
| 1246 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) | |
| 1247 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS | |
| 1248 #endif | |
| 1249 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") | |
| 1250 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") | |
| 1251 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 1252 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") | |
| 1253 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1254 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) | |
| 1255 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) | |
| 1256 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") | |
| 1257 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) | |
| 1258 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") | |
| 1259 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) | |
| 1260 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) | |
| 1261 #elif \ | |
| 1262 JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ | |
| 1263 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ | |
| 1264 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1265 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) | |
| 1266 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") | |
| 1267 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) | |
| 1268 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") | |
| 1269 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1270 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") | |
| 1271 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1272 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") | |
| 1273 #else | |
| 1274 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS | |
| 1275 #endif | |
| 1276 | |
| 1277 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) | |
| 1278 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES | |
| 1279 #endif | |
| 1280 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") | |
| 1281 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") | |
| 1282 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) | |
| 1283 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") | |
| 1284 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) | |
| 1285 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") | |
| 1286 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1287 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) | |
| 1288 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) | |
| 1289 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) | |
| 1290 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) | |
| 1291 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") | |
| 1292 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) | |
| 1293 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") | |
| 1294 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) | |
| 1295 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") | |
| 1296 #elif \ | |
| 1297 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ | |
| 1298 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ | |
| 1299 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) | |
| 1300 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") | |
| 1301 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1302 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") | |
| 1303 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1304 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") | |
| 1305 #else | |
| 1306 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES | |
| 1307 #endif | |
| 1308 | |
| 1309 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) | |
| 1310 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL | |
| 1311 #endif | |
| 1312 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") | |
| 1313 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") | |
| 1314 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 1315 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") | |
| 1316 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) | |
| 1317 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") | |
| 1318 #else | |
| 1319 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL | |
| 1320 #endif | |
| 1321 | |
| 1322 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) | |
| 1323 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION | |
| 1324 #endif | |
| 1325 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function") | |
| 1326 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") | |
| 1327 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) | |
| 1328 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") | |
| 1329 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) | |
| 1330 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) | |
| 1331 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1332 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") | |
| 1333 #else | |
| 1334 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION | |
| 1335 #endif | |
| 1336 | |
| 1337 #if defined(JSON_HEDLEY_DEPRECATED) | |
| 1338 #undef JSON_HEDLEY_DEPRECATED | |
| 1339 #endif | |
| 1340 #if defined(JSON_HEDLEY_DEPRECATED_FOR) | |
| 1341 #undef JSON_HEDLEY_DEPRECATED_FOR | |
| 1342 #endif | |
| 1343 #if \ | |
| 1344 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ | |
| 1345 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1346 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) | |
| 1347 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) | |
| 1348 #elif \ | |
| 1349 (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ | |
| 1350 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ | |
| 1351 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1352 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ | |
| 1353 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ | |
| 1354 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ | |
| 1355 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ | |
| 1356 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ | |
| 1357 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ | |
| 1358 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1359 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ | |
| 1360 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1361 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) | |
| 1362 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) | |
| 1363 #elif defined(__cplusplus) && (__cplusplus >= 201402L) | |
| 1364 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) | |
| 1365 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) | |
| 1366 #elif \ | |
| 1367 JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ | |
| 1368 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ | |
| 1369 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1370 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1371 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1372 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1373 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1374 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1375 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1376 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1377 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1378 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1379 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1380 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1381 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ | |
| 1382 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) | |
| 1383 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) | |
| 1384 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) | |
| 1385 #elif \ | |
| 1386 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ | |
| 1387 JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ | |
| 1388 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1389 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) | |
| 1390 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) | |
| 1391 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1392 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") | |
| 1393 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") | |
| 1394 #else | |
| 1395 #define JSON_HEDLEY_DEPRECATED(since) | |
| 1396 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) | |
| 1397 #endif | |
| 1398 | |
| 1399 #if defined(JSON_HEDLEY_UNAVAILABLE) | |
| 1400 #undef JSON_HEDLEY_UNAVAILABLE | |
| 1401 #endif | |
| 1402 #if \ | |
| 1403 JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ | |
| 1404 JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ | |
| 1405 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1406 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1407 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) | |
| 1408 #else | |
| 1409 #define JSON_HEDLEY_UNAVAILABLE(available_since) | |
| 1410 #endif | |
| 1411 | |
| 1412 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) | |
| 1413 #undef JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 1414 #endif | |
| 1415 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) | |
| 1416 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG | |
| 1417 #endif | |
| 1418 #if \ | |
| 1419 JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ | |
| 1420 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ | |
| 1421 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1422 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1423 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1424 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1425 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1426 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1427 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1428 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1429 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1430 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1431 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1432 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1433 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ | |
| 1434 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ | |
| 1435 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1436 #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) | |
| 1437 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) | |
| 1438 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) | |
| 1439 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) | |
| 1440 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) | |
| 1441 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) | |
| 1442 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) | |
| 1443 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) | |
| 1444 #elif defined(_Check_return_) /* SAL */ | |
| 1445 #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ | |
| 1446 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ | |
| 1447 #else | |
| 1448 #define JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 1449 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) | |
| 1450 #endif | |
| 1451 | |
| 1452 #if defined(JSON_HEDLEY_SENTINEL) | |
| 1453 #undef JSON_HEDLEY_SENTINEL | |
| 1454 #endif | |
| 1455 #if \ | |
| 1456 JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ | |
| 1457 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ | |
| 1458 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1459 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ | |
| 1460 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1461 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) | |
| 1462 #else | |
| 1463 #define JSON_HEDLEY_SENTINEL(position) | |
| 1464 #endif | |
| 1465 | |
| 1466 #if defined(JSON_HEDLEY_NO_RETURN) | |
| 1467 #undef JSON_HEDLEY_NO_RETURN | |
| 1468 #endif | |
| 1469 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1470 #define JSON_HEDLEY_NO_RETURN __noreturn | |
| 1471 #elif \ | |
| 1472 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1473 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1474 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) | |
| 1475 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L | |
| 1476 #define JSON_HEDLEY_NO_RETURN _Noreturn | |
| 1477 #elif defined(__cplusplus) && (__cplusplus >= 201103L) | |
| 1478 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) | |
| 1479 #elif \ | |
| 1480 JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ | |
| 1481 JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ | |
| 1482 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1483 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1484 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1485 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1486 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1487 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1488 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1489 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1490 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1491 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1492 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1493 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1494 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1495 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1496 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) | |
| 1497 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) | |
| 1498 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) | |
| 1499 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") | |
| 1500 #elif \ | |
| 1501 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ | |
| 1502 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1503 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) | |
| 1504 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) | |
| 1505 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") | |
| 1506 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) | |
| 1507 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) | |
| 1508 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) | |
| 1509 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) | |
| 1510 #else | |
| 1511 #define JSON_HEDLEY_NO_RETURN | |
| 1512 #endif | |
| 1513 | |
| 1514 #if defined(JSON_HEDLEY_NO_ESCAPE) | |
| 1515 #undef JSON_HEDLEY_NO_ESCAPE | |
| 1516 #endif | |
| 1517 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) | |
| 1518 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) | |
| 1519 #else | |
| 1520 #define JSON_HEDLEY_NO_ESCAPE | |
| 1521 #endif | |
| 1522 | |
| 1523 #if defined(JSON_HEDLEY_UNREACHABLE) | |
| 1524 #undef JSON_HEDLEY_UNREACHABLE | |
| 1525 #endif | |
| 1526 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN) | |
| 1527 #undef JSON_HEDLEY_UNREACHABLE_RETURN | |
| 1528 #endif | |
| 1529 #if defined(JSON_HEDLEY_ASSUME) | |
| 1530 #undef JSON_HEDLEY_ASSUME | |
| 1531 #endif | |
| 1532 #if \ | |
| 1533 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ | |
| 1534 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1535 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1536 #define JSON_HEDLEY_ASSUME(expr) __assume(expr) | |
| 1537 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) | |
| 1538 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) | |
| 1539 #elif \ | |
| 1540 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ | |
| 1541 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) | |
| 1542 #if defined(__cplusplus) | |
| 1543 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) | |
| 1544 #else | |
| 1545 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) | |
| 1546 #endif | |
| 1547 #endif | |
| 1548 #if \ | |
| 1549 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ | |
| 1550 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ | |
| 1551 JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ | |
| 1552 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1553 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ | |
| 1554 JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ | |
| 1555 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1556 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() | |
| 1557 #elif defined(JSON_HEDLEY_ASSUME) | |
| 1558 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) | |
| 1559 #endif | |
| 1560 #if !defined(JSON_HEDLEY_ASSUME) | |
| 1561 #if defined(JSON_HEDLEY_UNREACHABLE) | |
| 1562 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) | |
| 1563 #else | |
| 1564 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) | |
| 1565 #endif | |
| 1566 #endif | |
| 1567 #if defined(JSON_HEDLEY_UNREACHABLE) | |
| 1568 #if \ | |
| 1569 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ | |
| 1570 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) | |
| 1571 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) | |
| 1572 #else | |
| 1573 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() | |
| 1574 #endif | |
| 1575 #else | |
| 1576 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) | |
| 1577 #endif | |
| 1578 #if !defined(JSON_HEDLEY_UNREACHABLE) | |
| 1579 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) | |
| 1580 #endif | |
| 1581 | |
| 1582 JSON_HEDLEY_DIAGNOSTIC_PUSH | |
| 1583 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic") | |
| 1584 #pragma clang diagnostic ignored "-Wpedantic" | |
| 1585 #endif | |
| 1586 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) | |
| 1587 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" | |
| 1588 #endif | |
| 1589 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) | |
| 1590 #if defined(__clang__) | |
| 1591 #pragma clang diagnostic ignored "-Wvariadic-macros" | |
| 1592 #elif defined(JSON_HEDLEY_GCC_VERSION) | |
| 1593 #pragma GCC diagnostic ignored "-Wvariadic-macros" | |
| 1594 #endif | |
| 1595 #endif | |
| 1596 #if defined(JSON_HEDLEY_NON_NULL) | |
| 1597 #undef JSON_HEDLEY_NON_NULL | |
| 1598 #endif | |
| 1599 #if \ | |
| 1600 JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ | |
| 1601 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ | |
| 1602 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1603 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) | |
| 1604 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) | |
| 1605 #else | |
| 1606 #define JSON_HEDLEY_NON_NULL(...) | |
| 1607 #endif | |
| 1608 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 1609 | |
| 1610 #if defined(JSON_HEDLEY_PRINTF_FORMAT) | |
| 1611 #undef JSON_HEDLEY_PRINTF_FORMAT | |
| 1612 #endif | |
| 1613 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) | |
| 1614 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) | |
| 1615 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) | |
| 1616 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) | |
| 1617 #elif \ | |
| 1618 JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ | |
| 1619 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ | |
| 1620 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1621 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ | |
| 1622 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1623 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1624 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1625 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1626 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1627 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1628 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1629 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1630 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1631 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1632 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1633 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1634 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1635 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) | |
| 1636 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) | |
| 1637 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) | |
| 1638 #else | |
| 1639 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) | |
| 1640 #endif | |
| 1641 | |
| 1642 #if defined(JSON_HEDLEY_CONSTEXPR) | |
| 1643 #undef JSON_HEDLEY_CONSTEXPR | |
| 1644 #endif | |
| 1645 #if defined(__cplusplus) | |
| 1646 #if __cplusplus >= 201103L | |
| 1647 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) | |
| 1648 #endif | |
| 1649 #endif | |
| 1650 #if !defined(JSON_HEDLEY_CONSTEXPR) | |
| 1651 #define JSON_HEDLEY_CONSTEXPR | |
| 1652 #endif | |
| 1653 | |
| 1654 #if defined(JSON_HEDLEY_PREDICT) | |
| 1655 #undef JSON_HEDLEY_PREDICT | |
| 1656 #endif | |
| 1657 #if defined(JSON_HEDLEY_LIKELY) | |
| 1658 #undef JSON_HEDLEY_LIKELY | |
| 1659 #endif | |
| 1660 #if defined(JSON_HEDLEY_UNLIKELY) | |
| 1661 #undef JSON_HEDLEY_UNLIKELY | |
| 1662 #endif | |
| 1663 #if defined(JSON_HEDLEY_UNPREDICTABLE) | |
| 1664 #undef JSON_HEDLEY_UNPREDICTABLE | |
| 1665 #endif | |
| 1666 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) | |
| 1667 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) | |
| 1668 #endif | |
| 1669 #if \ | |
| 1670 (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ | |
| 1671 JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ | |
| 1672 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1673 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) | |
| 1674 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) | |
| 1675 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) | |
| 1676 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | |
| 1677 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | |
| 1678 #elif \ | |
| 1679 (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ | |
| 1680 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ | |
| 1681 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1682 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ | |
| 1683 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1684 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1685 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1686 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ | |
| 1687 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ | |
| 1688 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ | |
| 1689 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ | |
| 1690 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1691 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1692 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ | |
| 1693 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ | |
| 1694 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1695 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \ | |
| 1696 (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) | |
| 1697 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ | |
| 1698 (__extension__ ({ \ | |
| 1699 double hedley_probability_ = (probability); \ | |
| 1700 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ | |
| 1701 })) | |
| 1702 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ | |
| 1703 (__extension__ ({ \ | |
| 1704 double hedley_probability_ = (probability); \ | |
| 1705 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ | |
| 1706 })) | |
| 1707 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) | |
| 1708 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) | |
| 1709 #else | |
| 1710 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) | |
| 1711 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) | |
| 1712 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) | |
| 1713 # define JSON_HEDLEY_LIKELY(expr) (!!(expr)) | |
| 1714 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) | |
| 1715 #endif | |
| 1716 #if !defined(JSON_HEDLEY_UNPREDICTABLE) | |
| 1717 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) | |
| 1718 #endif | |
| 1719 | |
| 1720 #if defined(JSON_HEDLEY_MALLOC) | |
| 1721 #undef JSON_HEDLEY_MALLOC | |
| 1722 #endif | |
| 1723 #if \ | |
| 1724 JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ | |
| 1725 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ | |
| 1726 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1727 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1728 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1729 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ | |
| 1730 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1731 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1732 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1733 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1734 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1735 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1736 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1737 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1738 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1739 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1740 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1741 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1742 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) | |
| 1743 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) | |
| 1744 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") | |
| 1745 #elif \ | |
| 1746 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ | |
| 1747 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1748 #define JSON_HEDLEY_MALLOC __declspec(restrict) | |
| 1749 #else | |
| 1750 #define JSON_HEDLEY_MALLOC | |
| 1751 #endif | |
| 1752 | |
| 1753 #if defined(JSON_HEDLEY_PURE) | |
| 1754 #undef JSON_HEDLEY_PURE | |
| 1755 #endif | |
| 1756 #if \ | |
| 1757 JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ | |
| 1758 JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ | |
| 1759 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1760 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1761 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1762 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1763 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1764 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1765 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1766 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1767 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1768 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1769 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1770 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1771 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1772 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1773 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1774 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ | |
| 1775 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1776 # define JSON_HEDLEY_PURE __attribute__((__pure__)) | |
| 1777 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) | |
| 1778 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") | |
| 1779 #elif defined(__cplusplus) && \ | |
| 1780 ( \ | |
| 1781 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ | |
| 1782 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ | |
| 1783 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ | |
| 1784 ) | |
| 1785 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") | |
| 1786 #else | |
| 1787 # define JSON_HEDLEY_PURE | |
| 1788 #endif | |
| 1789 | |
| 1790 #if defined(JSON_HEDLEY_CONST) | |
| 1791 #undef JSON_HEDLEY_CONST | |
| 1792 #endif | |
| 1793 #if \ | |
| 1794 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ | |
| 1795 JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ | |
| 1796 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1797 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1798 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1799 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1800 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1801 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1802 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1803 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1804 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1805 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1806 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1807 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1808 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1809 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1810 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1811 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ | |
| 1812 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1813 #define JSON_HEDLEY_CONST __attribute__((__const__)) | |
| 1814 #elif \ | |
| 1815 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) | |
| 1816 #define JSON_HEDLEY_CONST _Pragma("no_side_effect") | |
| 1817 #else | |
| 1818 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE | |
| 1819 #endif | |
| 1820 | |
| 1821 #if defined(JSON_HEDLEY_RESTRICT) | |
| 1822 #undef JSON_HEDLEY_RESTRICT | |
| 1823 #endif | |
| 1824 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) | |
| 1825 #define JSON_HEDLEY_RESTRICT restrict | |
| 1826 #elif \ | |
| 1827 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ | |
| 1828 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ | |
| 1829 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1830 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ | |
| 1831 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1832 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1833 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ | |
| 1834 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1835 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ | |
| 1836 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ | |
| 1837 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1838 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ | |
| 1839 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ | |
| 1840 defined(__clang__) || \ | |
| 1841 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1842 #define JSON_HEDLEY_RESTRICT __restrict | |
| 1843 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) | |
| 1844 #define JSON_HEDLEY_RESTRICT _Restrict | |
| 1845 #else | |
| 1846 #define JSON_HEDLEY_RESTRICT | |
| 1847 #endif | |
| 1848 | |
| 1849 #if defined(JSON_HEDLEY_INLINE) | |
| 1850 #undef JSON_HEDLEY_INLINE | |
| 1851 #endif | |
| 1852 #if \ | |
| 1853 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ | |
| 1854 (defined(__cplusplus) && (__cplusplus >= 199711L)) | |
| 1855 #define JSON_HEDLEY_INLINE inline | |
| 1856 #elif \ | |
| 1857 defined(JSON_HEDLEY_GCC_VERSION) || \ | |
| 1858 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) | |
| 1859 #define JSON_HEDLEY_INLINE __inline__ | |
| 1860 #elif \ | |
| 1861 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ | |
| 1862 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ | |
| 1863 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1864 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ | |
| 1865 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ | |
| 1866 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ | |
| 1867 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ | |
| 1868 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1869 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1870 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1871 #define JSON_HEDLEY_INLINE __inline | |
| 1872 #else | |
| 1873 #define JSON_HEDLEY_INLINE | |
| 1874 #endif | |
| 1875 | |
| 1876 #if defined(JSON_HEDLEY_ALWAYS_INLINE) | |
| 1877 #undef JSON_HEDLEY_ALWAYS_INLINE | |
| 1878 #endif | |
| 1879 #if \ | |
| 1880 JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ | |
| 1881 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ | |
| 1882 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1883 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1884 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1885 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1886 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1887 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1888 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1889 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1890 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1891 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1892 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1893 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1894 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1895 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1896 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1897 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ | |
| 1898 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) | |
| 1899 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE | |
| 1900 #elif \ | |
| 1901 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ | |
| 1902 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1903 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline | |
| 1904 #elif defined(__cplusplus) && \ | |
| 1905 ( \ | |
| 1906 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1907 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1908 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1909 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ | |
| 1910 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1911 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ | |
| 1912 ) | |
| 1913 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") | |
| 1914 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1915 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") | |
| 1916 #else | |
| 1917 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE | |
| 1918 #endif | |
| 1919 | |
| 1920 #if defined(JSON_HEDLEY_NEVER_INLINE) | |
| 1921 #undef JSON_HEDLEY_NEVER_INLINE | |
| 1922 #endif | |
| 1923 #if \ | |
| 1924 JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ | |
| 1925 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ | |
| 1926 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1927 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1928 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1929 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ | |
| 1930 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ | |
| 1931 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1932 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ | |
| 1933 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1934 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ | |
| 1935 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1936 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ | |
| 1937 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1938 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ | |
| 1939 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ | |
| 1940 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ | |
| 1941 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ | |
| 1942 JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) | |
| 1943 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) | |
| 1944 #elif \ | |
| 1945 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ | |
| 1946 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 1947 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) | |
| 1948 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) | |
| 1949 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") | |
| 1950 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) | |
| 1951 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") | |
| 1952 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 1953 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") | |
| 1954 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) | |
| 1955 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) | |
| 1956 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) | |
| 1957 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) | |
| 1958 #else | |
| 1959 #define JSON_HEDLEY_NEVER_INLINE | |
| 1960 #endif | |
| 1961 | |
| 1962 #if defined(JSON_HEDLEY_PRIVATE) | |
| 1963 #undef JSON_HEDLEY_PRIVATE | |
| 1964 #endif | |
| 1965 #if defined(JSON_HEDLEY_PUBLIC) | |
| 1966 #undef JSON_HEDLEY_PUBLIC | |
| 1967 #endif | |
| 1968 #if defined(JSON_HEDLEY_IMPORT) | |
| 1969 #undef JSON_HEDLEY_IMPORT | |
| 1970 #endif | |
| 1971 #if defined(_WIN32) || defined(__CYGWIN__) | |
| 1972 # define JSON_HEDLEY_PRIVATE | |
| 1973 # define JSON_HEDLEY_PUBLIC __declspec(dllexport) | |
| 1974 # define JSON_HEDLEY_IMPORT __declspec(dllimport) | |
| 1975 #else | |
| 1976 # if \ | |
| 1977 JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ | |
| 1978 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ | |
| 1979 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ | |
| 1980 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 1981 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 1982 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ | |
| 1983 ( \ | |
| 1984 defined(__TI_EABI__) && \ | |
| 1985 ( \ | |
| 1986 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ | |
| 1987 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ | |
| 1988 ) \ | |
| 1989 ) || \ | |
| 1990 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 1991 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) | |
| 1992 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) | |
| 1993 # else | |
| 1994 # define JSON_HEDLEY_PRIVATE | |
| 1995 # define JSON_HEDLEY_PUBLIC | |
| 1996 # endif | |
| 1997 # define JSON_HEDLEY_IMPORT extern | |
| 1998 #endif | |
| 1999 | |
| 2000 #if defined(JSON_HEDLEY_NO_THROW) | |
| 2001 #undef JSON_HEDLEY_NO_THROW | |
| 2002 #endif | |
| 2003 #if \ | |
| 2004 JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ | |
| 2005 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ | |
| 2006 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 2007 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 2008 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) | |
| 2009 #elif \ | |
| 2010 JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ | |
| 2011 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ | |
| 2012 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) | |
| 2013 #define JSON_HEDLEY_NO_THROW __declspec(nothrow) | |
| 2014 #else | |
| 2015 #define JSON_HEDLEY_NO_THROW | |
| 2016 #endif | |
| 2017 | |
| 2018 #if defined(JSON_HEDLEY_FALL_THROUGH) | |
| 2019 #undef JSON_HEDLEY_FALL_THROUGH | |
| 2020 #endif | |
| 2021 #if \ | |
| 2022 JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ | |
| 2023 JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ | |
| 2024 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 2025 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) | |
| 2026 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) | |
| 2027 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) | |
| 2028 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) | |
| 2029 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) | |
| 2030 #elif defined(__fallthrough) /* SAL */ | |
| 2031 #define JSON_HEDLEY_FALL_THROUGH __fallthrough | |
| 2032 #else | |
| 2033 #define JSON_HEDLEY_FALL_THROUGH | |
| 2034 #endif | |
| 2035 | |
| 2036 #if defined(JSON_HEDLEY_RETURNS_NON_NULL) | |
| 2037 #undef JSON_HEDLEY_RETURNS_NON_NULL | |
| 2038 #endif | |
| 2039 #if \ | |
| 2040 JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ | |
| 2041 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ | |
| 2042 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 2043 #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) | |
| 2044 #elif defined(_Ret_notnull_) /* SAL */ | |
| 2045 #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ | |
| 2046 #else | |
| 2047 #define JSON_HEDLEY_RETURNS_NON_NULL | |
| 2048 #endif | |
| 2049 | |
| 2050 #if defined(JSON_HEDLEY_ARRAY_PARAM) | |
| 2051 #undef JSON_HEDLEY_ARRAY_PARAM | |
| 2052 #endif | |
| 2053 #if \ | |
| 2054 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ | |
| 2055 !defined(__STDC_NO_VLA__) && \ | |
| 2056 !defined(__cplusplus) && \ | |
| 2057 !defined(JSON_HEDLEY_PGI_VERSION) && \ | |
| 2058 !defined(JSON_HEDLEY_TINYC_VERSION) | |
| 2059 #define JSON_HEDLEY_ARRAY_PARAM(name) (name) | |
| 2060 #else | |
| 2061 #define JSON_HEDLEY_ARRAY_PARAM(name) | |
| 2062 #endif | |
| 2063 | |
| 2064 #if defined(JSON_HEDLEY_IS_CONSTANT) | |
| 2065 #undef JSON_HEDLEY_IS_CONSTANT | |
| 2066 #endif | |
| 2067 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) | |
| 2068 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR | |
| 2069 #endif | |
| 2070 /* JSON_HEDLEY_IS_CONSTEXPR_ is for | |
| 2071 HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ | |
| 2072 #if defined(JSON_HEDLEY_IS_CONSTEXPR_) | |
| 2073 #undef JSON_HEDLEY_IS_CONSTEXPR_ | |
| 2074 #endif | |
| 2075 #if \ | |
| 2076 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ | |
| 2077 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ | |
| 2078 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 2079 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ | |
| 2080 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ | |
| 2081 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ | |
| 2082 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ | |
| 2083 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ | |
| 2084 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ | |
| 2085 JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) | |
| 2086 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) | |
| 2087 #endif | |
| 2088 #if !defined(__cplusplus) | |
| 2089 # if \ | |
| 2090 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ | |
| 2091 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ | |
| 2092 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 2093 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ | |
| 2094 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ | |
| 2095 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ | |
| 2096 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) | |
| 2097 #if defined(__INTPTR_TYPE__) | |
| 2098 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) | |
| 2099 #else | |
| 2100 #include <stdint.h> | |
| 2101 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) | |
| 2102 #endif | |
| 2103 # elif \ | |
| 2104 ( \ | |
| 2105 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ | |
| 2106 !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ | |
| 2107 !defined(JSON_HEDLEY_PGI_VERSION) && \ | |
| 2108 !defined(JSON_HEDLEY_IAR_VERSION)) || \ | |
| 2109 (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ | |
| 2110 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ | |
| 2111 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ | |
| 2112 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ | |
| 2113 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) | |
| 2114 #if defined(__INTPTR_TYPE__) | |
| 2115 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) | |
| 2116 #else | |
| 2117 #include <stdint.h> | |
| 2118 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) | |
| 2119 #endif | |
| 2120 # elif \ | |
| 2121 defined(JSON_HEDLEY_GCC_VERSION) || \ | |
| 2122 defined(JSON_HEDLEY_INTEL_VERSION) || \ | |
| 2123 defined(JSON_HEDLEY_TINYC_VERSION) || \ | |
| 2124 defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ | |
| 2125 JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ | |
| 2126 defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ | |
| 2127 defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ | |
| 2128 defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ | |
| 2129 defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ | |
| 2130 defined(__clang__) | |
| 2131 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ | |
| 2132 sizeof(void) != \ | |
| 2133 sizeof(*( \ | |
| 2134 1 ? \ | |
| 2135 ((void*) ((expr) * 0L) ) : \ | |
| 2136 ((struct { char v[sizeof(void) * 2]; } *) 1) \ | |
| 2137 ) \ | |
| 2138 ) \ | |
| 2139 ) | |
| 2140 # endif | |
| 2141 #endif | |
| 2142 #if defined(JSON_HEDLEY_IS_CONSTEXPR_) | |
| 2143 #if !defined(JSON_HEDLEY_IS_CONSTANT) | |
| 2144 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) | |
| 2145 #endif | |
| 2146 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) | |
| 2147 #else | |
| 2148 #if !defined(JSON_HEDLEY_IS_CONSTANT) | |
| 2149 #define JSON_HEDLEY_IS_CONSTANT(expr) (0) | |
| 2150 #endif | |
| 2151 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) | |
| 2152 #endif | |
| 2153 | |
| 2154 #if defined(JSON_HEDLEY_BEGIN_C_DECLS) | |
| 2155 #undef JSON_HEDLEY_BEGIN_C_DECLS | |
| 2156 #endif | |
| 2157 #if defined(JSON_HEDLEY_END_C_DECLS) | |
| 2158 #undef JSON_HEDLEY_END_C_DECLS | |
| 2159 #endif | |
| 2160 #if defined(JSON_HEDLEY_C_DECL) | |
| 2161 #undef JSON_HEDLEY_C_DECL | |
| 2162 #endif | |
| 2163 #if defined(__cplusplus) | |
| 2164 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { | |
| 2165 #define JSON_HEDLEY_END_C_DECLS } | |
| 2166 #define JSON_HEDLEY_C_DECL extern "C" | |
| 2167 #else | |
| 2168 #define JSON_HEDLEY_BEGIN_C_DECLS | |
| 2169 #define JSON_HEDLEY_END_C_DECLS | |
| 2170 #define JSON_HEDLEY_C_DECL | |
| 2171 #endif | |
| 2172 | |
| 2173 #if defined(JSON_HEDLEY_STATIC_ASSERT) | |
| 2174 #undef JSON_HEDLEY_STATIC_ASSERT | |
| 2175 #endif | |
| 2176 #if \ | |
| 2177 !defined(__cplusplus) && ( \ | |
| 2178 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ | |
| 2179 (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ | |
| 2180 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ | |
| 2181 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ | |
| 2182 defined(_Static_assert) \ | |
| 2183 ) | |
| 2184 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) | |
| 2185 #elif \ | |
| 2186 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ | |
| 2187 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ | |
| 2188 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 2189 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) | |
| 2190 #else | |
| 2191 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) | |
| 2192 #endif | |
| 2193 | |
| 2194 #if defined(JSON_HEDLEY_NULL) | |
| 2195 #undef JSON_HEDLEY_NULL | |
| 2196 #endif | |
| 2197 #if defined(__cplusplus) | |
| 2198 #if __cplusplus >= 201103L | |
| 2199 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) | |
| 2200 #elif defined(NULL) | |
| 2201 #define JSON_HEDLEY_NULL NULL | |
| 2202 #else | |
| 2203 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) | |
| 2204 #endif | |
| 2205 #elif defined(NULL) | |
| 2206 #define JSON_HEDLEY_NULL NULL | |
| 2207 #else | |
| 2208 #define JSON_HEDLEY_NULL ((void*) 0) | |
| 2209 #endif | |
| 2210 | |
| 2211 #if defined(JSON_HEDLEY_MESSAGE) | |
| 2212 #undef JSON_HEDLEY_MESSAGE | |
| 2213 #endif | |
| 2214 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") | |
| 2215 # define JSON_HEDLEY_MESSAGE(msg) \ | |
| 2216 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 2217 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ | |
| 2218 JSON_HEDLEY_PRAGMA(message msg) \ | |
| 2219 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 2220 #elif \ | |
| 2221 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ | |
| 2222 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 2223 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) | |
| 2224 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) | |
| 2225 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) | |
| 2226 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) | |
| 2227 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) | |
| 2228 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) | |
| 2229 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) | |
| 2230 #else | |
| 2231 # define JSON_HEDLEY_MESSAGE(msg) | |
| 2232 #endif | |
| 2233 | |
| 2234 #if defined(JSON_HEDLEY_WARNING) | |
| 2235 #undef JSON_HEDLEY_WARNING | |
| 2236 #endif | |
| 2237 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") | |
| 2238 # define JSON_HEDLEY_WARNING(msg) \ | |
| 2239 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 2240 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ | |
| 2241 JSON_HEDLEY_PRAGMA(clang warning msg) \ | |
| 2242 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 2243 #elif \ | |
| 2244 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ | |
| 2245 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ | |
| 2246 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) | |
| 2247 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) | |
| 2248 #elif \ | |
| 2249 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ | |
| 2250 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 2251 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) | |
| 2252 #else | |
| 2253 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) | |
| 2254 #endif | |
| 2255 | |
| 2256 #if defined(JSON_HEDLEY_REQUIRE) | |
| 2257 #undef JSON_HEDLEY_REQUIRE | |
| 2258 #endif | |
| 2259 #if defined(JSON_HEDLEY_REQUIRE_MSG) | |
| 2260 #undef JSON_HEDLEY_REQUIRE_MSG | |
| 2261 #endif | |
| 2262 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) | |
| 2263 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") | |
| 2264 # define JSON_HEDLEY_REQUIRE(expr) \ | |
| 2265 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 2266 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ | |
| 2267 __attribute__((diagnose_if(!(expr), #expr, "error"))) \ | |
| 2268 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 2269 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ | |
| 2270 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 2271 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ | |
| 2272 __attribute__((diagnose_if(!(expr), msg, "error"))) \ | |
| 2273 JSON_HEDLEY_DIAGNOSTIC_POP | |
| 2274 # else | |
| 2275 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) | |
| 2276 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) | |
| 2277 # endif | |
| 2278 #else | |
| 2279 # define JSON_HEDLEY_REQUIRE(expr) | |
| 2280 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) | |
| 2281 #endif | |
| 2282 | |
| 2283 #if defined(JSON_HEDLEY_FLAGS) | |
| 2284 #undef JSON_HEDLEY_FLAGS | |
| 2285 #endif | |
| 2286 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) | |
| 2287 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) | |
| 2288 #else | |
| 2289 #define JSON_HEDLEY_FLAGS | |
| 2290 #endif | |
| 2291 | |
| 2292 #if defined(JSON_HEDLEY_FLAGS_CAST) | |
| 2293 #undef JSON_HEDLEY_FLAGS_CAST | |
| 2294 #endif | |
| 2295 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) | |
| 2296 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ | |
| 2297 JSON_HEDLEY_DIAGNOSTIC_PUSH \ | |
| 2298 _Pragma("warning(disable:188)") \ | |
| 2299 ((T) (expr)); \ | |
| 2300 JSON_HEDLEY_DIAGNOSTIC_POP \ | |
| 2301 })) | |
| 2302 #else | |
| 2303 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) | |
| 2304 #endif | |
| 2305 | |
| 2306 #if defined(JSON_HEDLEY_EMPTY_BASES) | |
| 2307 #undef JSON_HEDLEY_EMPTY_BASES | |
| 2308 #endif | |
| 2309 #if \ | |
| 2310 (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ | |
| 2311 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) | |
| 2312 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) | |
| 2313 #else | |
| 2314 #define JSON_HEDLEY_EMPTY_BASES | |
| 2315 #endif | |
| 2316 | |
| 2317 /* Remaining macros are deprecated. */ | |
| 2318 | |
| 2319 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) | |
| 2320 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK | |
| 2321 #endif | |
| 2322 #if defined(__clang__) | |
| 2323 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) | |
| 2324 #else | |
| 2325 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) | |
| 2326 #endif | |
| 2327 | |
| 2328 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) | |
| 2329 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE | |
| 2330 #endif | |
| 2331 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) | |
| 2332 | |
| 2333 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) | |
| 2334 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE | |
| 2335 #endif | |
| 2336 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) | |
| 2337 | |
| 2338 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) | |
| 2339 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN | |
| 2340 #endif | |
| 2341 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) | |
| 2342 | |
| 2343 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) | |
| 2344 #undef JSON_HEDLEY_CLANG_HAS_FEATURE | |
| 2345 #endif | |
| 2346 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) | |
| 2347 | |
| 2348 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) | |
| 2349 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION | |
| 2350 #endif | |
| 2351 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) | |
| 2352 | |
| 2353 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) | |
| 2354 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE | |
| 2355 #endif | |
| 2356 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) | |
| 2357 | |
| 2358 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING) | |
| 2359 #undef JSON_HEDLEY_CLANG_HAS_WARNING | |
| 2360 #endif | |
| 2361 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) | |
| 2362 | |
| 2363 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ | |
| 2364 | |
| 2365 | |
| 2366 // This file contains all internal macro definitions (except those affecting ABI) | |
| 2367 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them | |
| 2368 | |
| 2369 // #include <nlohmann/detail/abi_macros.hpp> | |
| 2370 | |
| 2371 | |
| 2372 // exclude unsupported compilers | |
| 2373 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) | |
| 2374 #if defined(__clang__) | |
| 2375 #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 | |
| 2376 #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" | |
| 2377 #endif | |
| 2378 #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) | |
| 2379 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 | |
| 2380 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" | |
| 2381 #endif | |
| 2382 #endif | |
| 2383 #endif | |
| 2384 | |
| 2385 // C++ language standard detection | |
| 2386 // if the user manually specified the used c++ version this is skipped | |
| 2387 #if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) | |
| 2388 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) | |
| 2389 #define JSON_HAS_CPP_20 | |
| 2390 #define JSON_HAS_CPP_17 | |
| 2391 #define JSON_HAS_CPP_14 | |
| 2392 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 | |
| 2393 #define JSON_HAS_CPP_17 | |
| 2394 #define JSON_HAS_CPP_14 | |
| 2395 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) | |
| 2396 #define JSON_HAS_CPP_14 | |
| 2397 #endif | |
| 2398 // the cpp 11 flag is always specified because it is the minimal required version | |
| 2399 #define JSON_HAS_CPP_11 | |
| 2400 #endif | |
| 2401 | |
| 2402 #ifdef __has_include | |
| 2403 #if __has_include(<version>) | |
| 2404 #include <version> | |
| 2405 #endif | |
| 2406 #endif | |
| 2407 | |
| 2408 #if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) | |
| 2409 #ifdef JSON_HAS_CPP_17 | |
| 2410 #if defined(__cpp_lib_filesystem) | |
| 2411 #define JSON_HAS_FILESYSTEM 1 | |
| 2412 #elif defined(__cpp_lib_experimental_filesystem) | |
| 2413 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 | |
| 2414 #elif !defined(__has_include) | |
| 2415 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 | |
| 2416 #elif __has_include(<filesystem>) | |
| 2417 #define JSON_HAS_FILESYSTEM 1 | |
| 2418 #elif __has_include(<experimental/filesystem>) | |
| 2419 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 | |
| 2420 #endif | |
| 2421 | |
| 2422 // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ | |
| 2423 #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 | |
| 2424 #undef JSON_HAS_FILESYSTEM | |
| 2425 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2426 #endif | |
| 2427 | |
| 2428 // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support | |
| 2429 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 | |
| 2430 #undef JSON_HAS_FILESYSTEM | |
| 2431 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2432 #endif | |
| 2433 | |
| 2434 // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support | |
| 2435 #if defined(__clang_major__) && __clang_major__ < 7 | |
| 2436 #undef JSON_HAS_FILESYSTEM | |
| 2437 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2438 #endif | |
| 2439 | |
| 2440 // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support | |
| 2441 #if defined(_MSC_VER) && _MSC_VER < 1914 | |
| 2442 #undef JSON_HAS_FILESYSTEM | |
| 2443 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2444 #endif | |
| 2445 | |
| 2446 // no filesystem support before iOS 13 | |
| 2447 #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 | |
| 2448 #undef JSON_HAS_FILESYSTEM | |
| 2449 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2450 #endif | |
| 2451 | |
| 2452 // no filesystem support before macOS Catalina | |
| 2453 #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 | |
| 2454 #undef JSON_HAS_FILESYSTEM | |
| 2455 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2456 #endif | |
| 2457 #endif | |
| 2458 #endif | |
| 2459 | |
| 2460 #ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 2461 #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 | |
| 2462 #endif | |
| 2463 | |
| 2464 #ifndef JSON_HAS_FILESYSTEM | |
| 2465 #define JSON_HAS_FILESYSTEM 0 | |
| 2466 #endif | |
| 2467 | |
| 2468 #ifndef JSON_HAS_THREE_WAY_COMPARISON | |
| 2469 #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ | |
| 2470 && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L | |
| 2471 #define JSON_HAS_THREE_WAY_COMPARISON 1 | |
| 2472 #else | |
| 2473 #define JSON_HAS_THREE_WAY_COMPARISON 0 | |
| 2474 #endif | |
| 2475 #endif | |
| 2476 | |
| 2477 #ifndef JSON_HAS_RANGES | |
| 2478 // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error | |
| 2479 #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 | |
| 2480 #define JSON_HAS_RANGES 0 | |
| 2481 #elif defined(__cpp_lib_ranges) | |
| 2482 #define JSON_HAS_RANGES 1 | |
| 2483 #else | |
| 2484 #define JSON_HAS_RANGES 0 | |
| 2485 #endif | |
| 2486 #endif | |
| 2487 | |
| 2488 #ifndef JSON_HAS_STATIC_RTTI | |
| 2489 #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 | |
| 2490 #define JSON_HAS_STATIC_RTTI 1 | |
| 2491 #else | |
| 2492 #define JSON_HAS_STATIC_RTTI 0 | |
| 2493 #endif | |
| 2494 #endif | |
| 2495 | |
| 2496 #ifdef JSON_HAS_CPP_17 | |
| 2497 #define JSON_INLINE_VARIABLE inline | |
| 2498 #else | |
| 2499 #define JSON_INLINE_VARIABLE | |
| 2500 #endif | |
| 2501 | |
| 2502 #if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) | |
| 2503 #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] | |
| 2504 #else | |
| 2505 #define JSON_NO_UNIQUE_ADDRESS | |
| 2506 #endif | |
| 2507 | |
| 2508 // disable documentation warnings on clang | |
| 2509 #if defined(__clang__) | |
| 2510 #pragma clang diagnostic push | |
| 2511 #pragma clang diagnostic ignored "-Wdocumentation" | |
| 2512 #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" | |
| 2513 #endif | |
| 2514 | |
| 2515 // allow disabling exceptions | |
| 2516 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) | |
| 2517 #define JSON_THROW(exception) throw exception | |
| 2518 #define JSON_TRY try | |
| 2519 #define JSON_CATCH(exception) catch(exception) | |
| 2520 #define JSON_INTERNAL_CATCH(exception) catch(exception) | |
| 2521 #else | |
| 2522 #include <cstdlib> | |
| 2523 #define JSON_THROW(exception) std::abort() | |
| 2524 #define JSON_TRY if(true) | |
| 2525 #define JSON_CATCH(exception) if(false) | |
| 2526 #define JSON_INTERNAL_CATCH(exception) if(false) | |
| 2527 #endif | |
| 2528 | |
| 2529 // override exception macros | |
| 2530 #if defined(JSON_THROW_USER) | |
| 2531 #undef JSON_THROW | |
| 2532 #define JSON_THROW JSON_THROW_USER | |
| 2533 #endif | |
| 2534 #if defined(JSON_TRY_USER) | |
| 2535 #undef JSON_TRY | |
| 2536 #define JSON_TRY JSON_TRY_USER | |
| 2537 #endif | |
| 2538 #if defined(JSON_CATCH_USER) | |
| 2539 #undef JSON_CATCH | |
| 2540 #define JSON_CATCH JSON_CATCH_USER | |
| 2541 #undef JSON_INTERNAL_CATCH | |
| 2542 #define JSON_INTERNAL_CATCH JSON_CATCH_USER | |
| 2543 #endif | |
| 2544 #if defined(JSON_INTERNAL_CATCH_USER) | |
| 2545 #undef JSON_INTERNAL_CATCH | |
| 2546 #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER | |
| 2547 #endif | |
| 2548 | |
| 2549 // allow overriding assert | |
| 2550 #if !defined(JSON_ASSERT) | |
| 2551 #include <cassert> // assert | |
| 2552 #define JSON_ASSERT(x) assert(x) | |
| 2553 #endif | |
| 2554 | |
| 2555 // allow to access some private functions (needed by the test suite) | |
| 2556 #if defined(JSON_TESTS_PRIVATE) | |
| 2557 #define JSON_PRIVATE_UNLESS_TESTED public | |
| 2558 #else | |
| 2559 #define JSON_PRIVATE_UNLESS_TESTED private | |
| 2560 #endif | |
| 2561 | |
| 2562 /*! | |
| 2563 @brief macro to briefly define a mapping between an enum and JSON | |
| 2564 @def NLOHMANN_JSON_SERIALIZE_ENUM | |
| 2565 @since version 3.4.0 | |
| 2566 */ | |
| 2567 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ | |
| 2568 template<typename BasicJsonType> \ | |
| 2569 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ | |
| 2570 { \ | |
| 2571 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \ | |
| 2572 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \ | |
| 2573 auto it = std::find_if(std::begin(m), std::end(m), \ | |
| 2574 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \ | |
| 2575 { \ | |
| 2576 return ej_pair.first == e; \ | |
| 2577 }); \ | |
| 2578 j = ((it != std::end(m)) ? it : std::begin(m))->second; \ | |
| 2579 } \ | |
| 2580 template<typename BasicJsonType> \ | |
| 2581 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ | |
| 2582 { \ | |
| 2583 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \ | |
| 2584 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \ | |
| 2585 auto it = std::find_if(std::begin(m), std::end(m), \ | |
| 2586 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \ | |
| 2587 { \ | |
| 2588 return ej_pair.second == j; \ | |
| 2589 }); \ | |
| 2590 e = ((it != std::end(m)) ? it : std::begin(m))->first; \ | |
| 2591 } | |
| 2592 | |
| 2593 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They | |
| 2594 // may be removed in the future once the class is split. | |
| 2595 | |
| 2596 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ | |
| 2597 template<template<typename, typename, typename...> class ObjectType, \ | |
| 2598 template<typename, typename...> class ArrayType, \ | |
| 2599 class StringType, class BooleanType, class NumberIntegerType, \ | |
| 2600 class NumberUnsignedType, class NumberFloatType, \ | |
| 2601 template<typename> class AllocatorType, \ | |
| 2602 template<typename, typename = void> class JSONSerializer, \ | |
| 2603 class BinaryType, \ | |
| 2604 class CustomBaseClass> | |
| 2605 | |
| 2606 #define NLOHMANN_BASIC_JSON_TPL \ | |
| 2607 basic_json<ObjectType, ArrayType, StringType, BooleanType, \ | |
| 2608 NumberIntegerType, NumberUnsignedType, NumberFloatType, \ | |
| 2609 AllocatorType, JSONSerializer, BinaryType, CustomBaseClass> | |
| 2610 | |
| 2611 // Macros to simplify conversion from/to types | |
| 2612 | |
| 2613 #define NLOHMANN_JSON_EXPAND( x ) x | |
| 2614 #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 | |
| 2615 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ | |
| 2616 NLOHMANN_JSON_PASTE64, \ | |
| 2617 NLOHMANN_JSON_PASTE63, \ | |
| 2618 NLOHMANN_JSON_PASTE62, \ | |
| 2619 NLOHMANN_JSON_PASTE61, \ | |
| 2620 NLOHMANN_JSON_PASTE60, \ | |
| 2621 NLOHMANN_JSON_PASTE59, \ | |
| 2622 NLOHMANN_JSON_PASTE58, \ | |
| 2623 NLOHMANN_JSON_PASTE57, \ | |
| 2624 NLOHMANN_JSON_PASTE56, \ | |
| 2625 NLOHMANN_JSON_PASTE55, \ | |
| 2626 NLOHMANN_JSON_PASTE54, \ | |
| 2627 NLOHMANN_JSON_PASTE53, \ | |
| 2628 NLOHMANN_JSON_PASTE52, \ | |
| 2629 NLOHMANN_JSON_PASTE51, \ | |
| 2630 NLOHMANN_JSON_PASTE50, \ | |
| 2631 NLOHMANN_JSON_PASTE49, \ | |
| 2632 NLOHMANN_JSON_PASTE48, \ | |
| 2633 NLOHMANN_JSON_PASTE47, \ | |
| 2634 NLOHMANN_JSON_PASTE46, \ | |
| 2635 NLOHMANN_JSON_PASTE45, \ | |
| 2636 NLOHMANN_JSON_PASTE44, \ | |
| 2637 NLOHMANN_JSON_PASTE43, \ | |
| 2638 NLOHMANN_JSON_PASTE42, \ | |
| 2639 NLOHMANN_JSON_PASTE41, \ | |
| 2640 NLOHMANN_JSON_PASTE40, \ | |
| 2641 NLOHMANN_JSON_PASTE39, \ | |
| 2642 NLOHMANN_JSON_PASTE38, \ | |
| 2643 NLOHMANN_JSON_PASTE37, \ | |
| 2644 NLOHMANN_JSON_PASTE36, \ | |
| 2645 NLOHMANN_JSON_PASTE35, \ | |
| 2646 NLOHMANN_JSON_PASTE34, \ | |
| 2647 NLOHMANN_JSON_PASTE33, \ | |
| 2648 NLOHMANN_JSON_PASTE32, \ | |
| 2649 NLOHMANN_JSON_PASTE31, \ | |
| 2650 NLOHMANN_JSON_PASTE30, \ | |
| 2651 NLOHMANN_JSON_PASTE29, \ | |
| 2652 NLOHMANN_JSON_PASTE28, \ | |
| 2653 NLOHMANN_JSON_PASTE27, \ | |
| 2654 NLOHMANN_JSON_PASTE26, \ | |
| 2655 NLOHMANN_JSON_PASTE25, \ | |
| 2656 NLOHMANN_JSON_PASTE24, \ | |
| 2657 NLOHMANN_JSON_PASTE23, \ | |
| 2658 NLOHMANN_JSON_PASTE22, \ | |
| 2659 NLOHMANN_JSON_PASTE21, \ | |
| 2660 NLOHMANN_JSON_PASTE20, \ | |
| 2661 NLOHMANN_JSON_PASTE19, \ | |
| 2662 NLOHMANN_JSON_PASTE18, \ | |
| 2663 NLOHMANN_JSON_PASTE17, \ | |
| 2664 NLOHMANN_JSON_PASTE16, \ | |
| 2665 NLOHMANN_JSON_PASTE15, \ | |
| 2666 NLOHMANN_JSON_PASTE14, \ | |
| 2667 NLOHMANN_JSON_PASTE13, \ | |
| 2668 NLOHMANN_JSON_PASTE12, \ | |
| 2669 NLOHMANN_JSON_PASTE11, \ | |
| 2670 NLOHMANN_JSON_PASTE10, \ | |
| 2671 NLOHMANN_JSON_PASTE9, \ | |
| 2672 NLOHMANN_JSON_PASTE8, \ | |
| 2673 NLOHMANN_JSON_PASTE7, \ | |
| 2674 NLOHMANN_JSON_PASTE6, \ | |
| 2675 NLOHMANN_JSON_PASTE5, \ | |
| 2676 NLOHMANN_JSON_PASTE4, \ | |
| 2677 NLOHMANN_JSON_PASTE3, \ | |
| 2678 NLOHMANN_JSON_PASTE2, \ | |
| 2679 NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) | |
| 2680 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1) | |
| 2681 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) | |
| 2682 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) | |
| 2683 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) | |
| 2684 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) | |
| 2685 #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) | |
| 2686 #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) | |
| 2687 #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) | |
| 2688 #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) | |
| 2689 #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) | |
| 2690 #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) | |
| 2691 #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) | |
| 2692 #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) | |
| 2693 #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) | |
| 2694 #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) | |
| 2695 #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) | |
| 2696 #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) | |
| 2697 #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) | |
| 2698 #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) | |
| 2699 #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) | |
| 2700 #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) | |
| 2701 #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) | |
| 2702 #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) | |
| 2703 #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) | |
| 2704 #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) | |
| 2705 #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) | |
| 2706 #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) | |
| 2707 #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) | |
| 2708 #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) | |
| 2709 #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) | |
| 2710 #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) | |
| 2711 #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) | |
| 2712 #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) | |
| 2713 #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) | |
| 2714 #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) | |
| 2715 #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) | |
| 2716 #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) | |
| 2717 #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) | |
| 2718 #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) | |
| 2719 #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) | |
| 2720 #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) | |
| 2721 #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) | |
| 2722 #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) | |
| 2723 #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) | |
| 2724 #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) | |
| 2725 #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) | |
| 2726 #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) | |
| 2727 #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) | |
| 2728 #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) | |
| 2729 #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) | |
| 2730 #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) | |
| 2731 #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) | |
| 2732 #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) | |
| 2733 #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) | |
| 2734 #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) | |
| 2735 #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) | |
| 2736 #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) | |
| 2737 #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) | |
| 2738 #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) | |
| 2739 #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) | |
| 2740 #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) | |
| 2741 #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) | |
| 2742 #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) | |
| 2743 | |
| 2744 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; | |
| 2745 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); | |
| 2746 #define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1); | |
| 2747 | |
| 2748 /*! | |
| 2749 @brief macro | |
| 2750 @def NLOHMANN_DEFINE_TYPE_INTRUSIVE | |
| 2751 @since version 3.9.0 | |
| 2752 */ | |
| 2753 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ | |
| 2754 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__)) } \ | |
| 2755 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__)) } | |
| 2756 | |
| 2757 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ | |
| 2758 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__)) } \ | |
| 2759 friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } | |
| 2760 | |
| 2761 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ | |
| 2762 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__)) } | |
| 2763 | |
| 2764 /*! | |
| 2765 @brief macro | |
| 2766 @def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE | |
| 2767 @since version 3.9.0 | |
| 2768 */ | |
| 2769 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ | |
| 2770 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__)) } \ | |
| 2771 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__)) } | |
| 2772 | |
| 2773 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ | |
| 2774 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__)) } | |
| 2775 | |
| 2776 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ | |
| 2777 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__)) } \ | |
| 2778 inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } | |
| 2779 | |
| 2780 // inspired from https://stackoverflow.com/a/26745591 | |
| 2781 // allows to call any std function as if (e.g. with begin): | |
| 2782 // using std::begin; begin(x); | |
| 2783 // | |
| 2784 // it allows using the detected idiom to retrieve the return type | |
| 2785 // of such an expression | |
| 2786 #define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ | |
| 2787 namespace detail { \ | |
| 2788 using std::std_name; \ | |
| 2789 \ | |
| 2790 template<typename... T> \ | |
| 2791 using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \ | |
| 2792 } \ | |
| 2793 \ | |
| 2794 namespace detail2 { \ | |
| 2795 struct std_name##_tag \ | |
| 2796 { \ | |
| 2797 }; \ | |
| 2798 \ | |
| 2799 template<typename... T> \ | |
| 2800 std_name##_tag std_name(T&&...); \ | |
| 2801 \ | |
| 2802 template<typename... T> \ | |
| 2803 using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \ | |
| 2804 \ | |
| 2805 template<typename... T> \ | |
| 2806 struct would_call_std_##std_name \ | |
| 2807 { \ | |
| 2808 static constexpr auto const value = ::nlohmann::detail:: \ | |
| 2809 is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \ | |
| 2810 }; \ | |
| 2811 } /* namespace detail2 */ \ | |
| 2812 \ | |
| 2813 template<typename... T> \ | |
| 2814 struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...> \ | |
| 2815 { \ | |
| 2816 } | |
| 2817 | |
| 2818 #ifndef JSON_USE_IMPLICIT_CONVERSIONS | |
| 2819 #define JSON_USE_IMPLICIT_CONVERSIONS 1 | |
| 2820 #endif | |
| 2821 | |
| 2822 #if JSON_USE_IMPLICIT_CONVERSIONS | |
| 2823 #define JSON_EXPLICIT | |
| 2824 #else | |
| 2825 #define JSON_EXPLICIT explicit | |
| 2826 #endif | |
| 2827 | |
| 2828 #ifndef JSON_DISABLE_ENUM_SERIALIZATION | |
| 2829 #define JSON_DISABLE_ENUM_SERIALIZATION 0 | |
| 2830 #endif | |
| 2831 | |
| 2832 #ifndef JSON_USE_GLOBAL_UDLS | |
| 2833 #define JSON_USE_GLOBAL_UDLS 1 | |
| 2834 #endif | |
| 2835 | |
| 2836 #if JSON_HAS_THREE_WAY_COMPARISON | |
| 2837 #include <compare> // partial_ordering | |
| 2838 #endif | |
| 2839 | |
| 2840 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 2841 namespace detail | |
| 2842 { | |
| 2843 | |
| 2844 /////////////////////////// | |
| 2845 // JSON type enumeration // | |
| 2846 /////////////////////////// | |
| 2847 | |
| 2848 /*! | |
| 2849 @brief the JSON type enumeration | |
| 2850 | |
| 2851 This enumeration collects the different JSON types. It is internally used to | |
| 2852 distinguish the stored values, and the functions @ref basic_json::is_null(), | |
| 2853 @ref basic_json::is_object(), @ref basic_json::is_array(), | |
| 2854 @ref basic_json::is_string(), @ref basic_json::is_boolean(), | |
| 2855 @ref basic_json::is_number() (with @ref basic_json::is_number_integer(), | |
| 2856 @ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), | |
| 2857 @ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and | |
| 2858 @ref basic_json::is_structured() rely on it. | |
| 2859 | |
| 2860 @note There are three enumeration entries (number_integer, number_unsigned, and | |
| 2861 number_float), because the library distinguishes these three types for numbers: | |
| 2862 @ref basic_json::number_unsigned_t is used for unsigned integers, | |
| 2863 @ref basic_json::number_integer_t is used for signed integers, and | |
| 2864 @ref basic_json::number_float_t is used for floating-point numbers or to | |
| 2865 approximate integers which do not fit in the limits of their respective type. | |
| 2866 | |
| 2867 @sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON | |
| 2868 value with the default value for a given type | |
| 2869 | |
| 2870 @since version 1.0.0 | |
| 2871 */ | |
| 2872 enum class value_t : std::uint8_t | |
| 2873 { | |
| 2874 null, ///< null value | |
| 2875 object, ///< object (unordered set of name/value pairs) | |
| 2876 array, ///< array (ordered collection of values) | |
| 2877 string, ///< string value | |
| 2878 boolean, ///< boolean value | |
| 2879 number_integer, ///< number value (signed integer) | |
| 2880 number_unsigned, ///< number value (unsigned integer) | |
| 2881 number_float, ///< number value (floating-point) | |
| 2882 binary, ///< binary array (ordered collection of bytes) | |
| 2883 discarded ///< discarded by the parser callback function | |
| 2884 }; | |
| 2885 | |
| 2886 /*! | |
| 2887 @brief comparison operator for JSON types | |
| 2888 | |
| 2889 Returns an ordering that is similar to Python: | |
| 2890 - order: null < boolean < number < object < array < string < binary | |
| 2891 - furthermore, each type is not smaller than itself | |
| 2892 - discarded values are not comparable | |
| 2893 - binary is represented as a b"" string in python and directly comparable to a | |
| 2894 string; however, making a binary array directly comparable with a string would | |
| 2895 be surprising behavior in a JSON file. | |
| 2896 | |
| 2897 @since version 1.0.0 | |
| 2898 */ | |
| 2899 #if JSON_HAS_THREE_WAY_COMPARISON | |
| 2900 inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* | |
| 2901 #else | |
| 2902 inline bool operator<(const value_t lhs, const value_t rhs) noexcept | |
| 2903 #endif | |
| 2904 { | |
| 2905 static constexpr std::array<std::uint8_t, 9> order = {{ | |
| 2906 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, | |
| 2907 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, | |
| 2908 6 /* binary */ | |
| 2909 } | |
| 2910 }; | |
| 2911 | |
| 2912 const auto l_index = static_cast<std::size_t>(lhs); | |
| 2913 const auto r_index = static_cast<std::size_t>(rhs); | |
| 2914 #if JSON_HAS_THREE_WAY_COMPARISON | |
| 2915 if (l_index < order.size() && r_index < order.size()) | |
| 2916 { | |
| 2917 return order[l_index] <=> order[r_index]; // *NOPAD* | |
| 2918 } | |
| 2919 return std::partial_ordering::unordered; | |
| 2920 #else | |
| 2921 return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; | |
| 2922 #endif | |
| 2923 } | |
| 2924 | |
| 2925 // GCC selects the built-in operator< over an operator rewritten from | |
| 2926 // a user-defined spaceship operator | |
| 2927 // Clang, MSVC, and ICC select the rewritten candidate | |
| 2928 // (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) | |
| 2929 #if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) | |
| 2930 inline bool operator<(const value_t lhs, const value_t rhs) noexcept | |
| 2931 { | |
| 2932 return std::is_lt(lhs <=> rhs); // *NOPAD* | |
| 2933 } | |
| 2934 #endif | |
| 2935 | |
| 2936 } // namespace detail | |
| 2937 NLOHMANN_JSON_NAMESPACE_END | |
| 2938 | |
| 2939 // #include <nlohmann/detail/string_escape.hpp> | |
| 2940 // __ _____ _____ _____ | |
| 2941 // __| | __| | | | JSON for Modern C++ | |
| 2942 // | | |__ | | | | | | version 3.11.3 | |
| 2943 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 2944 // | |
| 2945 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 2946 // SPDX-License-Identifier: MIT | |
| 2947 | |
| 2948 | |
| 2949 | |
| 2950 // #include <nlohmann/detail/abi_macros.hpp> | |
| 2951 | |
| 2952 | |
| 2953 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 2954 namespace detail | |
| 2955 { | |
| 2956 | |
| 2957 /*! | |
| 2958 @brief replace all occurrences of a substring by another string | |
| 2959 | |
| 2960 @param[in,out] s the string to manipulate; changed so that all | |
| 2961 occurrences of @a f are replaced with @a t | |
| 2962 @param[in] f the substring to replace with @a t | |
| 2963 @param[in] t the string to replace @a f | |
| 2964 | |
| 2965 @pre The search string @a f must not be empty. **This precondition is | |
| 2966 enforced with an assertion.** | |
| 2967 | |
| 2968 @since version 2.0.0 | |
| 2969 */ | |
| 2970 template<typename StringType> | |
| 2971 inline void replace_substring(StringType& s, const StringType& f, | |
| 2972 const StringType& t) | |
| 2973 { | |
| 2974 JSON_ASSERT(!f.empty()); | |
| 2975 for (auto pos = s.find(f); // find first occurrence of f | |
| 2976 pos != StringType::npos; // make sure f was found | |
| 2977 s.replace(pos, f.size(), t), // replace with t, and | |
| 2978 pos = s.find(f, pos + t.size())) // find next occurrence of f | |
| 2979 {} | |
| 2980 } | |
| 2981 | |
| 2982 /*! | |
| 2983 * @brief string escaping as described in RFC 6901 (Sect. 4) | |
| 2984 * @param[in] s string to escape | |
| 2985 * @return escaped string | |
| 2986 * | |
| 2987 * Note the order of escaping "~" to "~0" and "/" to "~1" is important. | |
| 2988 */ | |
| 2989 template<typename StringType> | |
| 2990 inline StringType escape(StringType s) | |
| 2991 { | |
| 2992 replace_substring(s, StringType{"~"}, StringType{"~0"}); | |
| 2993 replace_substring(s, StringType{"/"}, StringType{"~1"}); | |
| 2994 return s; | |
| 2995 } | |
| 2996 | |
| 2997 /*! | |
| 2998 * @brief string unescaping as described in RFC 6901 (Sect. 4) | |
| 2999 * @param[in] s string to unescape | |
| 3000 * @return unescaped string | |
| 3001 * | |
| 3002 * Note the order of escaping "~1" to "/" and "~0" to "~" is important. | |
| 3003 */ | |
| 3004 template<typename StringType> | |
| 3005 static void unescape(StringType& s) | |
| 3006 { | |
| 3007 replace_substring(s, StringType{"~1"}, StringType{"/"}); | |
| 3008 replace_substring(s, StringType{"~0"}, StringType{"~"}); | |
| 3009 } | |
| 3010 | |
| 3011 } // namespace detail | |
| 3012 NLOHMANN_JSON_NAMESPACE_END | |
| 3013 | |
| 3014 // #include <nlohmann/detail/input/position_t.hpp> | |
| 3015 // __ _____ _____ _____ | |
| 3016 // __| | __| | | | JSON for Modern C++ | |
| 3017 // | | |__ | | | | | | version 3.11.3 | |
| 3018 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3019 // | |
| 3020 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3021 // SPDX-License-Identifier: MIT | |
| 3022 | |
| 3023 | |
| 3024 | |
| 3025 #include <cstddef> // size_t | |
| 3026 | |
| 3027 // #include <nlohmann/detail/abi_macros.hpp> | |
| 3028 | |
| 3029 | |
| 3030 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3031 namespace detail | |
| 3032 { | |
| 3033 | |
| 3034 /// struct to capture the start position of the current token | |
| 3035 struct position_t | |
| 3036 { | |
| 3037 /// the total number of characters read | |
| 3038 std::size_t chars_read_total = 0; | |
| 3039 /// the number of characters read in the current line | |
| 3040 std::size_t chars_read_current_line = 0; | |
| 3041 /// the number of lines read | |
| 3042 std::size_t lines_read = 0; | |
| 3043 | |
| 3044 /// conversion to size_t to preserve SAX interface | |
| 3045 constexpr operator size_t() const | |
| 3046 { | |
| 3047 return chars_read_total; | |
| 3048 } | |
| 3049 }; | |
| 3050 | |
| 3051 } // namespace detail | |
| 3052 NLOHMANN_JSON_NAMESPACE_END | |
| 3053 | |
| 3054 // #include <nlohmann/detail/macro_scope.hpp> | |
| 3055 | |
| 3056 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 3057 // __ _____ _____ _____ | |
| 3058 // __| | __| | | | JSON for Modern C++ | |
| 3059 // | | |__ | | | | | | version 3.11.3 | |
| 3060 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3061 // | |
| 3062 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3063 // SPDX-FileCopyrightText: 2018 The Abseil Authors | |
| 3064 // SPDX-License-Identifier: MIT | |
| 3065 | |
| 3066 | |
| 3067 | |
| 3068 #include <array> // array | |
| 3069 #include <cstddef> // size_t | |
| 3070 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type | |
| 3071 #include <utility> // index_sequence, make_index_sequence, index_sequence_for | |
| 3072 | |
| 3073 // #include <nlohmann/detail/macro_scope.hpp> | |
| 3074 | |
| 3075 | |
| 3076 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3077 namespace detail | |
| 3078 { | |
| 3079 | |
| 3080 template<typename T> | |
| 3081 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type; | |
| 3082 | |
| 3083 #ifdef JSON_HAS_CPP_14 | |
| 3084 | |
| 3085 // the following utilities are natively available in C++14 | |
| 3086 using std::enable_if_t; | |
| 3087 using std::index_sequence; | |
| 3088 using std::make_index_sequence; | |
| 3089 using std::index_sequence_for; | |
| 3090 | |
| 3091 #else | |
| 3092 | |
| 3093 // alias templates to reduce boilerplate | |
| 3094 template<bool B, typename T = void> | |
| 3095 using enable_if_t = typename std::enable_if<B, T>::type; | |
| 3096 | |
| 3097 // The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h | |
| 3098 // which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. | |
| 3099 | |
| 3100 //// START OF CODE FROM GOOGLE ABSEIL | |
| 3101 | |
| 3102 // integer_sequence | |
| 3103 // | |
| 3104 // Class template representing a compile-time integer sequence. An instantiation | |
| 3105 // of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its | |
| 3106 // type through its template arguments (which is a common need when | |
| 3107 // working with C++11 variadic templates). `absl::integer_sequence` is designed | |
| 3108 // to be a drop-in replacement for C++14's `std::integer_sequence`. | |
| 3109 // | |
| 3110 // Example: | |
| 3111 // | |
| 3112 // template< class T, T... Ints > | |
| 3113 // void user_function(integer_sequence<T, Ints...>); | |
| 3114 // | |
| 3115 // int main() | |
| 3116 // { | |
| 3117 // // user_function's `T` will be deduced to `int` and `Ints...` | |
| 3118 // // will be deduced to `0, 1, 2, 3, 4`. | |
| 3119 // user_function(make_integer_sequence<int, 5>()); | |
| 3120 // } | |
| 3121 template <typename T, T... Ints> | |
| 3122 struct integer_sequence | |
| 3123 { | |
| 3124 using value_type = T; | |
| 3125 static constexpr std::size_t size() noexcept | |
| 3126 { | |
| 3127 return sizeof...(Ints); | |
| 3128 } | |
| 3129 }; | |
| 3130 | |
| 3131 // index_sequence | |
| 3132 // | |
| 3133 // A helper template for an `integer_sequence` of `size_t`, | |
| 3134 // `absl::index_sequence` is designed to be a drop-in replacement for C++14's | |
| 3135 // `std::index_sequence`. | |
| 3136 template <size_t... Ints> | |
| 3137 using index_sequence = integer_sequence<size_t, Ints...>; | |
| 3138 | |
| 3139 namespace utility_internal | |
| 3140 { | |
| 3141 | |
| 3142 template <typename Seq, size_t SeqSize, size_t Rem> | |
| 3143 struct Extend; | |
| 3144 | |
| 3145 // Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. | |
| 3146 template <typename T, T... Ints, size_t SeqSize> | |
| 3147 struct Extend<integer_sequence<T, Ints...>, SeqSize, 0> | |
| 3148 { | |
| 3149 using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; | |
| 3150 }; | |
| 3151 | |
| 3152 template <typename T, T... Ints, size_t SeqSize> | |
| 3153 struct Extend<integer_sequence<T, Ints...>, SeqSize, 1> | |
| 3154 { | |
| 3155 using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; | |
| 3156 }; | |
| 3157 | |
| 3158 // Recursion helper for 'make_integer_sequence<T, N>'. | |
| 3159 // 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'. | |
| 3160 template <typename T, size_t N> | |
| 3161 struct Gen | |
| 3162 { | |
| 3163 using type = | |
| 3164 typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; | |
| 3165 }; | |
| 3166 | |
| 3167 template <typename T> | |
| 3168 struct Gen<T, 0> | |
| 3169 { | |
| 3170 using type = integer_sequence<T>; | |
| 3171 }; | |
| 3172 | |
| 3173 } // namespace utility_internal | |
| 3174 | |
| 3175 // Compile-time sequences of integers | |
| 3176 | |
| 3177 // make_integer_sequence | |
| 3178 // | |
| 3179 // This template alias is equivalent to | |
| 3180 // `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in | |
| 3181 // replacement for C++14's `std::make_integer_sequence`. | |
| 3182 template <typename T, T N> | |
| 3183 using make_integer_sequence = typename utility_internal::Gen<T, N>::type; | |
| 3184 | |
| 3185 // make_index_sequence | |
| 3186 // | |
| 3187 // This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, | |
| 3188 // and is designed to be a drop-in replacement for C++14's | |
| 3189 // `std::make_index_sequence`. | |
| 3190 template <size_t N> | |
| 3191 using make_index_sequence = make_integer_sequence<size_t, N>; | |
| 3192 | |
| 3193 // index_sequence_for | |
| 3194 // | |
| 3195 // Converts a typename pack into an index sequence of the same length, and | |
| 3196 // is designed to be a drop-in replacement for C++14's | |
| 3197 // `std::index_sequence_for()` | |
| 3198 template <typename... Ts> | |
| 3199 using index_sequence_for = make_index_sequence<sizeof...(Ts)>; | |
| 3200 | |
| 3201 //// END OF CODE FROM GOOGLE ABSEIL | |
| 3202 | |
| 3203 #endif | |
| 3204 | |
| 3205 // dispatch utility (taken from ranges-v3) | |
| 3206 template<unsigned N> struct priority_tag : priority_tag < N - 1 > {}; | |
| 3207 template<> struct priority_tag<0> {}; | |
| 3208 | |
| 3209 // taken from ranges-v3 | |
| 3210 template<typename T> | |
| 3211 struct static_const | |
| 3212 { | |
| 3213 static JSON_INLINE_VARIABLE constexpr T value{}; | |
| 3214 }; | |
| 3215 | |
| 3216 #ifndef JSON_HAS_CPP_17 | |
| 3217 template<typename T> | |
| 3218 constexpr T static_const<T>::value; | |
| 3219 #endif | |
| 3220 | |
| 3221 template<typename T, typename... Args> | |
| 3222 inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args) | |
| 3223 { | |
| 3224 return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}}; | |
| 3225 } | |
| 3226 | |
| 3227 } // namespace detail | |
| 3228 NLOHMANN_JSON_NAMESPACE_END | |
| 3229 | |
| 3230 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 3231 // __ _____ _____ _____ | |
| 3232 // __| | __| | | | JSON for Modern C++ | |
| 3233 // | | |__ | | | | | | version 3.11.3 | |
| 3234 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3235 // | |
| 3236 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3237 // SPDX-License-Identifier: MIT | |
| 3238 | |
| 3239 | |
| 3240 | |
| 3241 #include <limits> // numeric_limits | |
| 3242 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type | |
| 3243 #include <utility> // declval | |
| 3244 #include <tuple> // tuple | |
| 3245 #include <string> // char_traits | |
| 3246 | |
| 3247 // #include <nlohmann/detail/iterators/iterator_traits.hpp> | |
| 3248 // __ _____ _____ _____ | |
| 3249 // __| | __| | | | JSON for Modern C++ | |
| 3250 // | | |__ | | | | | | version 3.11.3 | |
| 3251 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3252 // | |
| 3253 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3254 // SPDX-License-Identifier: MIT | |
| 3255 | |
| 3256 | |
| 3257 | |
| 3258 #include <iterator> // random_access_iterator_tag | |
| 3259 | |
| 3260 // #include <nlohmann/detail/abi_macros.hpp> | |
| 3261 | |
| 3262 // #include <nlohmann/detail/meta/void_t.hpp> | |
| 3263 | |
| 3264 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 3265 | |
| 3266 | |
| 3267 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3268 namespace detail | |
| 3269 { | |
| 3270 | |
| 3271 template<typename It, typename = void> | |
| 3272 struct iterator_types {}; | |
| 3273 | |
| 3274 template<typename It> | |
| 3275 struct iterator_types < | |
| 3276 It, | |
| 3277 void_t<typename It::difference_type, typename It::value_type, typename It::pointer, | |
| 3278 typename It::reference, typename It::iterator_category >> | |
| 3279 { | |
| 3280 using difference_type = typename It::difference_type; | |
| 3281 using value_type = typename It::value_type; | |
| 3282 using pointer = typename It::pointer; | |
| 3283 using reference = typename It::reference; | |
| 3284 using iterator_category = typename It::iterator_category; | |
| 3285 }; | |
| 3286 | |
| 3287 // This is required as some compilers implement std::iterator_traits in a way that | |
| 3288 // doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. | |
| 3289 template<typename T, typename = void> | |
| 3290 struct iterator_traits | |
| 3291 { | |
| 3292 }; | |
| 3293 | |
| 3294 template<typename T> | |
| 3295 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >> | |
| 3296 : iterator_types<T> | |
| 3297 { | |
| 3298 }; | |
| 3299 | |
| 3300 template<typename T> | |
| 3301 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>> | |
| 3302 { | |
| 3303 using iterator_category = std::random_access_iterator_tag; | |
| 3304 using value_type = T; | |
| 3305 using difference_type = ptrdiff_t; | |
| 3306 using pointer = T*; | |
| 3307 using reference = T&; | |
| 3308 }; | |
| 3309 | |
| 3310 } // namespace detail | |
| 3311 NLOHMANN_JSON_NAMESPACE_END | |
| 3312 | |
| 3313 // #include <nlohmann/detail/macro_scope.hpp> | |
| 3314 | |
| 3315 // #include <nlohmann/detail/meta/call_std/begin.hpp> | |
| 3316 // __ _____ _____ _____ | |
| 3317 // __| | __| | | | JSON for Modern C++ | |
| 3318 // | | |__ | | | | | | version 3.11.3 | |
| 3319 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3320 // | |
| 3321 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3322 // SPDX-License-Identifier: MIT | |
| 3323 | |
| 3324 | |
| 3325 | |
| 3326 // #include <nlohmann/detail/macro_scope.hpp> | |
| 3327 | |
| 3328 | |
| 3329 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3330 | |
| 3331 NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); | |
| 3332 | |
| 3333 NLOHMANN_JSON_NAMESPACE_END | |
| 3334 | |
| 3335 // #include <nlohmann/detail/meta/call_std/end.hpp> | |
| 3336 // __ _____ _____ _____ | |
| 3337 // __| | __| | | | JSON for Modern C++ | |
| 3338 // | | |__ | | | | | | version 3.11.3 | |
| 3339 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3340 // | |
| 3341 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3342 // SPDX-License-Identifier: MIT | |
| 3343 | |
| 3344 | |
| 3345 | |
| 3346 // #include <nlohmann/detail/macro_scope.hpp> | |
| 3347 | |
| 3348 | |
| 3349 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3350 | |
| 3351 NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); | |
| 3352 | |
| 3353 NLOHMANN_JSON_NAMESPACE_END | |
| 3354 | |
| 3355 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 3356 | |
| 3357 // #include <nlohmann/detail/meta/detected.hpp> | |
| 3358 | |
| 3359 // #include <nlohmann/json_fwd.hpp> | |
| 3360 // __ _____ _____ _____ | |
| 3361 // __| | __| | | | JSON for Modern C++ | |
| 3362 // | | |__ | | | | | | version 3.11.3 | |
| 3363 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 3364 // | |
| 3365 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 3366 // SPDX-License-Identifier: MIT | |
| 3367 | |
| 3368 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ | |
| 3369 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ | |
| 3370 | |
| 3371 #include <cstdint> // int64_t, uint64_t | |
| 3372 #include <map> // map | |
| 3373 #include <memory> // allocator | |
| 3374 #include <string> // string | |
| 3375 #include <vector> // vector | |
| 3376 | |
| 3377 // #include <nlohmann/detail/abi_macros.hpp> | |
| 3378 | |
| 3379 | |
| 3380 /*! | |
| 3381 @brief namespace for Niels Lohmann | |
| 3382 @see https://github.com/nlohmann | |
| 3383 @since version 1.0.0 | |
| 3384 */ | |
| 3385 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3386 | |
| 3387 /*! | |
| 3388 @brief default JSONSerializer template argument | |
| 3389 | |
| 3390 This serializer ignores the template arguments and uses ADL | |
| 3391 ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) | |
| 3392 for serialization. | |
| 3393 */ | |
| 3394 template<typename T = void, typename SFINAE = void> | |
| 3395 struct adl_serializer; | |
| 3396 | |
| 3397 /// a class to store JSON values | |
| 3398 /// @sa https://json.nlohmann.me/api/basic_json/ | |
| 3399 template<template<typename U, typename V, typename... Args> class ObjectType = | |
| 3400 std::map, | |
| 3401 template<typename U, typename... Args> class ArrayType = std::vector, | |
| 3402 class StringType = std::string, class BooleanType = bool, | |
| 3403 class NumberIntegerType = std::int64_t, | |
| 3404 class NumberUnsignedType = std::uint64_t, | |
| 3405 class NumberFloatType = double, | |
| 3406 template<typename U> class AllocatorType = std::allocator, | |
| 3407 template<typename T, typename SFINAE = void> class JSONSerializer = | |
| 3408 adl_serializer, | |
| 3409 class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError | |
| 3410 class CustomBaseClass = void> | |
| 3411 class basic_json; | |
| 3412 | |
| 3413 /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document | |
| 3414 /// @sa https://json.nlohmann.me/api/json_pointer/ | |
| 3415 template<typename RefStringType> | |
| 3416 class json_pointer; | |
| 3417 | |
| 3418 /*! | |
| 3419 @brief default specialization | |
| 3420 @sa https://json.nlohmann.me/api/json/ | |
| 3421 */ | |
| 3422 using json = basic_json<>; | |
| 3423 | |
| 3424 /// @brief a minimal map-like container that preserves insertion order | |
| 3425 /// @sa https://json.nlohmann.me/api/ordered_map/ | |
| 3426 template<class Key, class T, class IgnoredLess, class Allocator> | |
| 3427 struct ordered_map; | |
| 3428 | |
| 3429 /// @brief specialization that maintains the insertion order of object keys | |
| 3430 /// @sa https://json.nlohmann.me/api/ordered_json/ | |
| 3431 using ordered_json = basic_json<nlohmann::ordered_map>; | |
| 3432 | |
| 3433 NLOHMANN_JSON_NAMESPACE_END | |
| 3434 | |
| 3435 #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ | |
| 3436 | |
| 3437 | |
| 3438 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 3439 /*! | |
| 3440 @brief detail namespace with internal helper functions | |
| 3441 | |
| 3442 This namespace collects functions that should not be exposed, | |
| 3443 implementations of some @ref basic_json methods, and meta-programming helpers. | |
| 3444 | |
| 3445 @since version 2.1.0 | |
| 3446 */ | |
| 3447 namespace detail | |
| 3448 { | |
| 3449 | |
| 3450 ///////////// | |
| 3451 // helpers // | |
| 3452 ///////////// | |
| 3453 | |
| 3454 // Note to maintainers: | |
| 3455 // | |
| 3456 // Every trait in this file expects a non CV-qualified type. | |
| 3457 // The only exceptions are in the 'aliases for detected' section | |
| 3458 // (i.e. those of the form: decltype(T::member_function(std::declval<T>()))) | |
| 3459 // | |
| 3460 // In this case, T has to be properly CV-qualified to constraint the function arguments | |
| 3461 // (e.g. to_json(BasicJsonType&, const T&)) | |
| 3462 | |
| 3463 template<typename> struct is_basic_json : std::false_type {}; | |
| 3464 | |
| 3465 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 3466 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {}; | |
| 3467 | |
| 3468 // used by exceptions create() member functions | |
| 3469 // true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t | |
| 3470 // false_type otherwise | |
| 3471 template<typename BasicJsonContext> | |
| 3472 struct is_basic_json_context : | |
| 3473 std::integral_constant < bool, | |
| 3474 is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value | |
| 3475 || std::is_same<BasicJsonContext, std::nullptr_t>::value > | |
| 3476 {}; | |
| 3477 | |
| 3478 ////////////////////// | |
| 3479 // json_ref helpers // | |
| 3480 ////////////////////// | |
| 3481 | |
| 3482 template<typename> | |
| 3483 class json_ref; | |
| 3484 | |
| 3485 template<typename> | |
| 3486 struct is_json_ref : std::false_type {}; | |
| 3487 | |
| 3488 template<typename T> | |
| 3489 struct is_json_ref<json_ref<T>> : std::true_type {}; | |
| 3490 | |
| 3491 ////////////////////////// | |
| 3492 // aliases for detected // | |
| 3493 ////////////////////////// | |
| 3494 | |
| 3495 template<typename T> | |
| 3496 using mapped_type_t = typename T::mapped_type; | |
| 3497 | |
| 3498 template<typename T> | |
| 3499 using key_type_t = typename T::key_type; | |
| 3500 | |
| 3501 template<typename T> | |
| 3502 using value_type_t = typename T::value_type; | |
| 3503 | |
| 3504 template<typename T> | |
| 3505 using difference_type_t = typename T::difference_type; | |
| 3506 | |
| 3507 template<typename T> | |
| 3508 using pointer_t = typename T::pointer; | |
| 3509 | |
| 3510 template<typename T> | |
| 3511 using reference_t = typename T::reference; | |
| 3512 | |
| 3513 template<typename T> | |
| 3514 using iterator_category_t = typename T::iterator_category; | |
| 3515 | |
| 3516 template<typename T, typename... Args> | |
| 3517 using to_json_function = decltype(T::to_json(std::declval<Args>()...)); | |
| 3518 | |
| 3519 template<typename T, typename... Args> | |
| 3520 using from_json_function = decltype(T::from_json(std::declval<Args>()...)); | |
| 3521 | |
| 3522 template<typename T, typename U> | |
| 3523 using get_template_function = decltype(std::declval<T>().template get<U>()); | |
| 3524 | |
| 3525 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists | |
| 3526 template<typename BasicJsonType, typename T, typename = void> | |
| 3527 struct has_from_json : std::false_type {}; | |
| 3528 | |
| 3529 // trait checking if j.get<T> is valid | |
| 3530 // use this trait instead of std::is_constructible or std::is_convertible, | |
| 3531 // both rely on, or make use of implicit conversions, and thus fail when T | |
| 3532 // has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) | |
| 3533 template <typename BasicJsonType, typename T> | |
| 3534 struct is_getable | |
| 3535 { | |
| 3536 static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value; | |
| 3537 }; | |
| 3538 | |
| 3539 template<typename BasicJsonType, typename T> | |
| 3540 struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >> | |
| 3541 { | |
| 3542 using serializer = typename BasicJsonType::template json_serializer<T, void>; | |
| 3543 | |
| 3544 static constexpr bool value = | |
| 3545 is_detected_exact<void, from_json_function, serializer, | |
| 3546 const BasicJsonType&, T&>::value; | |
| 3547 }; | |
| 3548 | |
| 3549 // This trait checks if JSONSerializer<T>::from_json(json const&) exists | |
| 3550 // this overload is used for non-default-constructible user-defined-types | |
| 3551 template<typename BasicJsonType, typename T, typename = void> | |
| 3552 struct has_non_default_from_json : std::false_type {}; | |
| 3553 | |
| 3554 template<typename BasicJsonType, typename T> | |
| 3555 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >> | |
| 3556 { | |
| 3557 using serializer = typename BasicJsonType::template json_serializer<T, void>; | |
| 3558 | |
| 3559 static constexpr bool value = | |
| 3560 is_detected_exact<T, from_json_function, serializer, | |
| 3561 const BasicJsonType&>::value; | |
| 3562 }; | |
| 3563 | |
| 3564 // This trait checks if BasicJsonType::json_serializer<T>::to_json exists | |
| 3565 // Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. | |
| 3566 template<typename BasicJsonType, typename T, typename = void> | |
| 3567 struct has_to_json : std::false_type {}; | |
| 3568 | |
| 3569 template<typename BasicJsonType, typename T> | |
| 3570 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >> | |
| 3571 { | |
| 3572 using serializer = typename BasicJsonType::template json_serializer<T, void>; | |
| 3573 | |
| 3574 static constexpr bool value = | |
| 3575 is_detected_exact<void, to_json_function, serializer, BasicJsonType&, | |
| 3576 T>::value; | |
| 3577 }; | |
| 3578 | |
| 3579 template<typename T> | |
| 3580 using detect_key_compare = typename T::key_compare; | |
| 3581 | |
| 3582 template<typename T> | |
| 3583 struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {}; | |
| 3584 | |
| 3585 // obtains the actual object key comparator | |
| 3586 template<typename BasicJsonType> | |
| 3587 struct actual_object_comparator | |
| 3588 { | |
| 3589 using object_t = typename BasicJsonType::object_t; | |
| 3590 using object_comparator_t = typename BasicJsonType::default_object_comparator_t; | |
| 3591 using type = typename std::conditional < has_key_compare<object_t>::value, | |
| 3592 typename object_t::key_compare, object_comparator_t>::type; | |
| 3593 }; | |
| 3594 | |
| 3595 template<typename BasicJsonType> | |
| 3596 using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type; | |
| 3597 | |
| 3598 ///////////////// | |
| 3599 // char_traits // | |
| 3600 ///////////////// | |
| 3601 | |
| 3602 // Primary template of char_traits calls std char_traits | |
| 3603 template<typename T> | |
| 3604 struct char_traits : std::char_traits<T> | |
| 3605 {}; | |
| 3606 | |
| 3607 // Explicitly define char traits for unsigned char since it is not standard | |
| 3608 template<> | |
| 3609 struct char_traits<unsigned char> : std::char_traits<char> | |
| 3610 { | |
| 3611 using char_type = unsigned char; | |
| 3612 using int_type = uint64_t; | |
| 3613 | |
| 3614 // Redefine to_int_type function | |
| 3615 static int_type to_int_type(char_type c) noexcept | |
| 3616 { | |
| 3617 return static_cast<int_type>(c); | |
| 3618 } | |
| 3619 | |
| 3620 static char_type to_char_type(int_type i) noexcept | |
| 3621 { | |
| 3622 return static_cast<char_type>(i); | |
| 3623 } | |
| 3624 | |
| 3625 static constexpr int_type eof() noexcept | |
| 3626 { | |
| 3627 return static_cast<int_type>(EOF); | |
| 3628 } | |
| 3629 }; | |
| 3630 | |
| 3631 // Explicitly define char traits for signed char since it is not standard | |
| 3632 template<> | |
| 3633 struct char_traits<signed char> : std::char_traits<char> | |
| 3634 { | |
| 3635 using char_type = signed char; | |
| 3636 using int_type = uint64_t; | |
| 3637 | |
| 3638 // Redefine to_int_type function | |
| 3639 static int_type to_int_type(char_type c) noexcept | |
| 3640 { | |
| 3641 return static_cast<int_type>(c); | |
| 3642 } | |
| 3643 | |
| 3644 static char_type to_char_type(int_type i) noexcept | |
| 3645 { | |
| 3646 return static_cast<char_type>(i); | |
| 3647 } | |
| 3648 | |
| 3649 static constexpr int_type eof() noexcept | |
| 3650 { | |
| 3651 return static_cast<int_type>(EOF); | |
| 3652 } | |
| 3653 }; | |
| 3654 | |
| 3655 /////////////////// | |
| 3656 // is_ functions // | |
| 3657 /////////////////// | |
| 3658 | |
| 3659 // https://en.cppreference.com/w/cpp/types/conjunction | |
| 3660 template<class...> struct conjunction : std::true_type { }; | |
| 3661 template<class B> struct conjunction<B> : B { }; | |
| 3662 template<class B, class... Bn> | |
| 3663 struct conjunction<B, Bn...> | |
| 3664 : std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {}; | |
| 3665 | |
| 3666 // https://en.cppreference.com/w/cpp/types/negation | |
| 3667 template<class B> struct negation : std::integral_constant < bool, !B::value > { }; | |
| 3668 | |
| 3669 // Reimplementation of is_constructible and is_default_constructible, due to them being broken for | |
| 3670 // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). | |
| 3671 // This causes compile errors in e.g. clang 3.5 or gcc 4.9. | |
| 3672 template <typename T> | |
| 3673 struct is_default_constructible : std::is_default_constructible<T> {}; | |
| 3674 | |
| 3675 template <typename T1, typename T2> | |
| 3676 struct is_default_constructible<std::pair<T1, T2>> | |
| 3677 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {}; | |
| 3678 | |
| 3679 template <typename T1, typename T2> | |
| 3680 struct is_default_constructible<const std::pair<T1, T2>> | |
| 3681 : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {}; | |
| 3682 | |
| 3683 template <typename... Ts> | |
| 3684 struct is_default_constructible<std::tuple<Ts...>> | |
| 3685 : conjunction<is_default_constructible<Ts>...> {}; | |
| 3686 | |
| 3687 template <typename... Ts> | |
| 3688 struct is_default_constructible<const std::tuple<Ts...>> | |
| 3689 : conjunction<is_default_constructible<Ts>...> {}; | |
| 3690 | |
| 3691 template <typename T, typename... Args> | |
| 3692 struct is_constructible : std::is_constructible<T, Args...> {}; | |
| 3693 | |
| 3694 template <typename T1, typename T2> | |
| 3695 struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {}; | |
| 3696 | |
| 3697 template <typename T1, typename T2> | |
| 3698 struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {}; | |
| 3699 | |
| 3700 template <typename... Ts> | |
| 3701 struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {}; | |
| 3702 | |
| 3703 template <typename... Ts> | |
| 3704 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {}; | |
| 3705 | |
| 3706 template<typename T, typename = void> | |
| 3707 struct is_iterator_traits : std::false_type {}; | |
| 3708 | |
| 3709 template<typename T> | |
| 3710 struct is_iterator_traits<iterator_traits<T>> | |
| 3711 { | |
| 3712 private: | |
| 3713 using traits = iterator_traits<T>; | |
| 3714 | |
| 3715 public: | |
| 3716 static constexpr auto value = | |
| 3717 is_detected<value_type_t, traits>::value && | |
| 3718 is_detected<difference_type_t, traits>::value && | |
| 3719 is_detected<pointer_t, traits>::value && | |
| 3720 is_detected<iterator_category_t, traits>::value && | |
| 3721 is_detected<reference_t, traits>::value; | |
| 3722 }; | |
| 3723 | |
| 3724 template<typename T> | |
| 3725 struct is_range | |
| 3726 { | |
| 3727 private: | |
| 3728 using t_ref = typename std::add_lvalue_reference<T>::type; | |
| 3729 | |
| 3730 using iterator = detected_t<result_of_begin, t_ref>; | |
| 3731 using sentinel = detected_t<result_of_end, t_ref>; | |
| 3732 | |
| 3733 // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator | |
| 3734 // and https://en.cppreference.com/w/cpp/iterator/sentinel_for | |
| 3735 // but reimplementing these would be too much work, as a lot of other concepts are used underneath | |
| 3736 static constexpr auto is_iterator_begin = | |
| 3737 is_iterator_traits<iterator_traits<iterator>>::value; | |
| 3738 | |
| 3739 public: | |
| 3740 static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin; | |
| 3741 }; | |
| 3742 | |
| 3743 template<typename R> | |
| 3744 using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>; | |
| 3745 | |
| 3746 template<typename T> | |
| 3747 using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>; | |
| 3748 | |
| 3749 // The following implementation of is_complete_type is taken from | |
| 3750 // https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ | |
| 3751 // and is written by Xiang Fan who agreed to using it in this library. | |
| 3752 | |
| 3753 template<typename T, typename = void> | |
| 3754 struct is_complete_type : std::false_type {}; | |
| 3755 | |
| 3756 template<typename T> | |
| 3757 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {}; | |
| 3758 | |
| 3759 template<typename BasicJsonType, typename CompatibleObjectType, | |
| 3760 typename = void> | |
| 3761 struct is_compatible_object_type_impl : std::false_type {}; | |
| 3762 | |
| 3763 template<typename BasicJsonType, typename CompatibleObjectType> | |
| 3764 struct is_compatible_object_type_impl < | |
| 3765 BasicJsonType, CompatibleObjectType, | |
| 3766 enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&& | |
| 3767 is_detected<key_type_t, CompatibleObjectType>::value >> | |
| 3768 { | |
| 3769 using object_t = typename BasicJsonType::object_t; | |
| 3770 | |
| 3771 // macOS's is_constructible does not play well with nonesuch... | |
| 3772 static constexpr bool value = | |
| 3773 is_constructible<typename object_t::key_type, | |
| 3774 typename CompatibleObjectType::key_type>::value && | |
| 3775 is_constructible<typename object_t::mapped_type, | |
| 3776 typename CompatibleObjectType::mapped_type>::value; | |
| 3777 }; | |
| 3778 | |
| 3779 template<typename BasicJsonType, typename CompatibleObjectType> | |
| 3780 struct is_compatible_object_type | |
| 3781 : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {}; | |
| 3782 | |
| 3783 template<typename BasicJsonType, typename ConstructibleObjectType, | |
| 3784 typename = void> | |
| 3785 struct is_constructible_object_type_impl : std::false_type {}; | |
| 3786 | |
| 3787 template<typename BasicJsonType, typename ConstructibleObjectType> | |
| 3788 struct is_constructible_object_type_impl < | |
| 3789 BasicJsonType, ConstructibleObjectType, | |
| 3790 enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&& | |
| 3791 is_detected<key_type_t, ConstructibleObjectType>::value >> | |
| 3792 { | |
| 3793 using object_t = typename BasicJsonType::object_t; | |
| 3794 | |
| 3795 static constexpr bool value = | |
| 3796 (is_default_constructible<ConstructibleObjectType>::value && | |
| 3797 (std::is_move_assignable<ConstructibleObjectType>::value || | |
| 3798 std::is_copy_assignable<ConstructibleObjectType>::value) && | |
| 3799 (is_constructible<typename ConstructibleObjectType::key_type, | |
| 3800 typename object_t::key_type>::value && | |
| 3801 std::is_same < | |
| 3802 typename object_t::mapped_type, | |
| 3803 typename ConstructibleObjectType::mapped_type >::value)) || | |
| 3804 (has_from_json<BasicJsonType, | |
| 3805 typename ConstructibleObjectType::mapped_type>::value || | |
| 3806 has_non_default_from_json < | |
| 3807 BasicJsonType, | |
| 3808 typename ConstructibleObjectType::mapped_type >::value); | |
| 3809 }; | |
| 3810 | |
| 3811 template<typename BasicJsonType, typename ConstructibleObjectType> | |
| 3812 struct is_constructible_object_type | |
| 3813 : is_constructible_object_type_impl<BasicJsonType, | |
| 3814 ConstructibleObjectType> {}; | |
| 3815 | |
| 3816 template<typename BasicJsonType, typename CompatibleStringType> | |
| 3817 struct is_compatible_string_type | |
| 3818 { | |
| 3819 static constexpr auto value = | |
| 3820 is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value; | |
| 3821 }; | |
| 3822 | |
| 3823 template<typename BasicJsonType, typename ConstructibleStringType> | |
| 3824 struct is_constructible_string_type | |
| 3825 { | |
| 3826 // launder type through decltype() to fix compilation failure on ICPC | |
| 3827 #ifdef __INTEL_COMPILER | |
| 3828 using laundered_type = decltype(std::declval<ConstructibleStringType>()); | |
| 3829 #else | |
| 3830 using laundered_type = ConstructibleStringType; | |
| 3831 #endif | |
| 3832 | |
| 3833 static constexpr auto value = | |
| 3834 conjunction < | |
| 3835 is_constructible<laundered_type, typename BasicJsonType::string_t>, | |
| 3836 is_detected_exact<typename BasicJsonType::string_t::value_type, | |
| 3837 value_type_t, laundered_type >>::value; | |
| 3838 }; | |
| 3839 | |
| 3840 template<typename BasicJsonType, typename CompatibleArrayType, typename = void> | |
| 3841 struct is_compatible_array_type_impl : std::false_type {}; | |
| 3842 | |
| 3843 template<typename BasicJsonType, typename CompatibleArrayType> | |
| 3844 struct is_compatible_array_type_impl < | |
| 3845 BasicJsonType, CompatibleArrayType, | |
| 3846 enable_if_t < | |
| 3847 is_detected<iterator_t, CompatibleArrayType>::value&& | |
| 3848 is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&& | |
| 3849 // special case for types like std::filesystem::path whose iterator's value_type are themselves | |
| 3850 // c.f. https://github.com/nlohmann/json/pull/3073 | |
| 3851 !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >> | |
| 3852 { | |
| 3853 static constexpr bool value = | |
| 3854 is_constructible<BasicJsonType, | |
| 3855 range_value_t<CompatibleArrayType>>::value; | |
| 3856 }; | |
| 3857 | |
| 3858 template<typename BasicJsonType, typename CompatibleArrayType> | |
| 3859 struct is_compatible_array_type | |
| 3860 : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {}; | |
| 3861 | |
| 3862 template<typename BasicJsonType, typename ConstructibleArrayType, typename = void> | |
| 3863 struct is_constructible_array_type_impl : std::false_type {}; | |
| 3864 | |
| 3865 template<typename BasicJsonType, typename ConstructibleArrayType> | |
| 3866 struct is_constructible_array_type_impl < | |
| 3867 BasicJsonType, ConstructibleArrayType, | |
| 3868 enable_if_t<std::is_same<ConstructibleArrayType, | |
| 3869 typename BasicJsonType::value_type>::value >> | |
| 3870 : std::true_type {}; | |
| 3871 | |
| 3872 template<typename BasicJsonType, typename ConstructibleArrayType> | |
| 3873 struct is_constructible_array_type_impl < | |
| 3874 BasicJsonType, ConstructibleArrayType, | |
| 3875 enable_if_t < !std::is_same<ConstructibleArrayType, | |
| 3876 typename BasicJsonType::value_type>::value&& | |
| 3877 !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&& | |
| 3878 is_default_constructible<ConstructibleArrayType>::value&& | |
| 3879 (std::is_move_assignable<ConstructibleArrayType>::value || | |
| 3880 std::is_copy_assignable<ConstructibleArrayType>::value)&& | |
| 3881 is_detected<iterator_t, ConstructibleArrayType>::value&& | |
| 3882 is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&& | |
| 3883 is_detected<range_value_t, ConstructibleArrayType>::value&& | |
| 3884 // special case for types like std::filesystem::path whose iterator's value_type are themselves | |
| 3885 // c.f. https://github.com/nlohmann/json/pull/3073 | |
| 3886 !std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&& | |
| 3887 is_complete_type < | |
| 3888 detected_t<range_value_t, ConstructibleArrayType >>::value >> | |
| 3889 { | |
| 3890 using value_type = range_value_t<ConstructibleArrayType>; | |
| 3891 | |
| 3892 static constexpr bool value = | |
| 3893 std::is_same<value_type, | |
| 3894 typename BasicJsonType::array_t::value_type>::value || | |
| 3895 has_from_json<BasicJsonType, | |
| 3896 value_type>::value || | |
| 3897 has_non_default_from_json < | |
| 3898 BasicJsonType, | |
| 3899 value_type >::value; | |
| 3900 }; | |
| 3901 | |
| 3902 template<typename BasicJsonType, typename ConstructibleArrayType> | |
| 3903 struct is_constructible_array_type | |
| 3904 : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {}; | |
| 3905 | |
| 3906 template<typename RealIntegerType, typename CompatibleNumberIntegerType, | |
| 3907 typename = void> | |
| 3908 struct is_compatible_integer_type_impl : std::false_type {}; | |
| 3909 | |
| 3910 template<typename RealIntegerType, typename CompatibleNumberIntegerType> | |
| 3911 struct is_compatible_integer_type_impl < | |
| 3912 RealIntegerType, CompatibleNumberIntegerType, | |
| 3913 enable_if_t < std::is_integral<RealIntegerType>::value&& | |
| 3914 std::is_integral<CompatibleNumberIntegerType>::value&& | |
| 3915 !std::is_same<bool, CompatibleNumberIntegerType>::value >> | |
| 3916 { | |
| 3917 // is there an assert somewhere on overflows? | |
| 3918 using RealLimits = std::numeric_limits<RealIntegerType>; | |
| 3919 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>; | |
| 3920 | |
| 3921 static constexpr auto value = | |
| 3922 is_constructible<RealIntegerType, | |
| 3923 CompatibleNumberIntegerType>::value && | |
| 3924 CompatibleLimits::is_integer && | |
| 3925 RealLimits::is_signed == CompatibleLimits::is_signed; | |
| 3926 }; | |
| 3927 | |
| 3928 template<typename RealIntegerType, typename CompatibleNumberIntegerType> | |
| 3929 struct is_compatible_integer_type | |
| 3930 : is_compatible_integer_type_impl<RealIntegerType, | |
| 3931 CompatibleNumberIntegerType> {}; | |
| 3932 | |
| 3933 template<typename BasicJsonType, typename CompatibleType, typename = void> | |
| 3934 struct is_compatible_type_impl: std::false_type {}; | |
| 3935 | |
| 3936 template<typename BasicJsonType, typename CompatibleType> | |
| 3937 struct is_compatible_type_impl < | |
| 3938 BasicJsonType, CompatibleType, | |
| 3939 enable_if_t<is_complete_type<CompatibleType>::value >> | |
| 3940 { | |
| 3941 static constexpr bool value = | |
| 3942 has_to_json<BasicJsonType, CompatibleType>::value; | |
| 3943 }; | |
| 3944 | |
| 3945 template<typename BasicJsonType, typename CompatibleType> | |
| 3946 struct is_compatible_type | |
| 3947 : is_compatible_type_impl<BasicJsonType, CompatibleType> {}; | |
| 3948 | |
| 3949 template<typename T1, typename T2> | |
| 3950 struct is_constructible_tuple : std::false_type {}; | |
| 3951 | |
| 3952 template<typename T1, typename... Args> | |
| 3953 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {}; | |
| 3954 | |
| 3955 template<typename BasicJsonType, typename T> | |
| 3956 struct is_json_iterator_of : std::false_type {}; | |
| 3957 | |
| 3958 template<typename BasicJsonType> | |
| 3959 struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {}; | |
| 3960 | |
| 3961 template<typename BasicJsonType> | |
| 3962 struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type | |
| 3963 {}; | |
| 3964 | |
| 3965 // checks if a given type T is a template specialization of Primary | |
| 3966 template<template <typename...> class Primary, typename T> | |
| 3967 struct is_specialization_of : std::false_type {}; | |
| 3968 | |
| 3969 template<template <typename...> class Primary, typename... Args> | |
| 3970 struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {}; | |
| 3971 | |
| 3972 template<typename T> | |
| 3973 using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>; | |
| 3974 | |
| 3975 // checks if A and B are comparable using Compare functor | |
| 3976 template<typename Compare, typename A, typename B, typename = void> | |
| 3977 struct is_comparable : std::false_type {}; | |
| 3978 | |
| 3979 template<typename Compare, typename A, typename B> | |
| 3980 struct is_comparable<Compare, A, B, void_t< | |
| 3981 decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())), | |
| 3982 decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>())) | |
| 3983 >> : std::true_type {}; | |
| 3984 | |
| 3985 template<typename T> | |
| 3986 using detect_is_transparent = typename T::is_transparent; | |
| 3987 | |
| 3988 // type trait to check if KeyType can be used as object key (without a BasicJsonType) | |
| 3989 // see is_usable_as_basic_json_key_type below | |
| 3990 template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true, | |
| 3991 bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>> | |
| 3992 using is_usable_as_key_type = typename std::conditional < | |
| 3993 is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value | |
| 3994 && !(ExcludeObjectKeyType && std::is_same<KeyType, | |
| 3995 ObjectKeyType>::value) | |
| 3996 && (!RequireTransparentComparator | |
| 3997 || is_detected <detect_is_transparent, Comparator>::value) | |
| 3998 && !is_json_pointer<KeyType>::value, | |
| 3999 std::true_type, | |
| 4000 std::false_type >::type; | |
| 4001 | |
| 4002 // type trait to check if KeyType can be used as object key | |
| 4003 // true if: | |
| 4004 // - KeyType is comparable with BasicJsonType::object_t::key_type | |
| 4005 // - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type | |
| 4006 // - the comparator is transparent or RequireTransparentComparator is false | |
| 4007 // - KeyType is not a JSON iterator or json_pointer | |
| 4008 template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true, | |
| 4009 bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>> | |
| 4010 using is_usable_as_basic_json_key_type = typename std::conditional < | |
| 4011 is_usable_as_key_type<typename BasicJsonType::object_comparator_t, | |
| 4012 typename BasicJsonType::object_t::key_type, KeyTypeCVRef, | |
| 4013 RequireTransparentComparator, ExcludeObjectKeyType>::value | |
| 4014 && !is_json_iterator_of<BasicJsonType, KeyType>::value, | |
| 4015 std::true_type, | |
| 4016 std::false_type >::type; | |
| 4017 | |
| 4018 template<typename ObjectType, typename KeyType> | |
| 4019 using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>())); | |
| 4020 | |
| 4021 // type trait to check if object_t has an erase() member functions accepting KeyType | |
| 4022 template<typename BasicJsonType, typename KeyType> | |
| 4023 using has_erase_with_key_type = typename std::conditional < | |
| 4024 is_detected < | |
| 4025 detect_erase_with_key_type, | |
| 4026 typename BasicJsonType::object_t, KeyType >::value, | |
| 4027 std::true_type, | |
| 4028 std::false_type >::type; | |
| 4029 | |
| 4030 // a naive helper to check if a type is an ordered_map (exploits the fact that | |
| 4031 // ordered_map inherits capacity() from std::vector) | |
| 4032 template <typename T> | |
| 4033 struct is_ordered_map | |
| 4034 { | |
| 4035 using one = char; | |
| 4036 | |
| 4037 struct two | |
| 4038 { | |
| 4039 char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) | |
| 4040 }; | |
| 4041 | |
| 4042 template <typename C> static one test( decltype(&C::capacity) ) ; | |
| 4043 template <typename C> static two test(...); | |
| 4044 | |
| 4045 enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 4046 }; | |
| 4047 | |
| 4048 // to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) | |
| 4049 template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 > | |
| 4050 T conditional_static_cast(U value) | |
| 4051 { | |
| 4052 return static_cast<T>(value); | |
| 4053 } | |
| 4054 | |
| 4055 template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0> | |
| 4056 T conditional_static_cast(U value) | |
| 4057 { | |
| 4058 return value; | |
| 4059 } | |
| 4060 | |
| 4061 template<typename... Types> | |
| 4062 using all_integral = conjunction<std::is_integral<Types>...>; | |
| 4063 | |
| 4064 template<typename... Types> | |
| 4065 using all_signed = conjunction<std::is_signed<Types>...>; | |
| 4066 | |
| 4067 template<typename... Types> | |
| 4068 using all_unsigned = conjunction<std::is_unsigned<Types>...>; | |
| 4069 | |
| 4070 // there's a disjunction trait in another PR; replace when merged | |
| 4071 template<typename... Types> | |
| 4072 using same_sign = std::integral_constant < bool, | |
| 4073 all_signed<Types...>::value || all_unsigned<Types...>::value >; | |
| 4074 | |
| 4075 template<typename OfType, typename T> | |
| 4076 using never_out_of_range = std::integral_constant < bool, | |
| 4077 (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType))) | |
| 4078 || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >; | |
| 4079 | |
| 4080 template<typename OfType, typename T, | |
| 4081 bool OfTypeSigned = std::is_signed<OfType>::value, | |
| 4082 bool TSigned = std::is_signed<T>::value> | |
| 4083 struct value_in_range_of_impl2; | |
| 4084 | |
| 4085 template<typename OfType, typename T> | |
| 4086 struct value_in_range_of_impl2<OfType, T, false, false> | |
| 4087 { | |
| 4088 static constexpr bool test(T val) | |
| 4089 { | |
| 4090 using CommonType = typename std::common_type<OfType, T>::type; | |
| 4091 return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)()); | |
| 4092 } | |
| 4093 }; | |
| 4094 | |
| 4095 template<typename OfType, typename T> | |
| 4096 struct value_in_range_of_impl2<OfType, T, true, false> | |
| 4097 { | |
| 4098 static constexpr bool test(T val) | |
| 4099 { | |
| 4100 using CommonType = typename std::common_type<OfType, T>::type; | |
| 4101 return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)()); | |
| 4102 } | |
| 4103 }; | |
| 4104 | |
| 4105 template<typename OfType, typename T> | |
| 4106 struct value_in_range_of_impl2<OfType, T, false, true> | |
| 4107 { | |
| 4108 static constexpr bool test(T val) | |
| 4109 { | |
| 4110 using CommonType = typename std::common_type<OfType, T>::type; | |
| 4111 return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)()); | |
| 4112 } | |
| 4113 }; | |
| 4114 | |
| 4115 template<typename OfType, typename T> | |
| 4116 struct value_in_range_of_impl2<OfType, T, true, true> | |
| 4117 { | |
| 4118 static constexpr bool test(T val) | |
| 4119 { | |
| 4120 using CommonType = typename std::common_type<OfType, T>::type; | |
| 4121 return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)()) | |
| 4122 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)()); | |
| 4123 } | |
| 4124 }; | |
| 4125 | |
| 4126 template<typename OfType, typename T, | |
| 4127 bool NeverOutOfRange = never_out_of_range<OfType, T>::value, | |
| 4128 typename = detail::enable_if_t<all_integral<OfType, T>::value>> | |
| 4129 struct value_in_range_of_impl1; | |
| 4130 | |
| 4131 template<typename OfType, typename T> | |
| 4132 struct value_in_range_of_impl1<OfType, T, false> | |
| 4133 { | |
| 4134 static constexpr bool test(T val) | |
| 4135 { | |
| 4136 return value_in_range_of_impl2<OfType, T>::test(val); | |
| 4137 } | |
| 4138 }; | |
| 4139 | |
| 4140 template<typename OfType, typename T> | |
| 4141 struct value_in_range_of_impl1<OfType, T, true> | |
| 4142 { | |
| 4143 static constexpr bool test(T /*val*/) | |
| 4144 { | |
| 4145 return true; | |
| 4146 } | |
| 4147 }; | |
| 4148 | |
| 4149 template<typename OfType, typename T> | |
| 4150 inline constexpr bool value_in_range_of(T val) | |
| 4151 { | |
| 4152 return value_in_range_of_impl1<OfType, T>::test(val); | |
| 4153 } | |
| 4154 | |
| 4155 template<bool Value> | |
| 4156 using bool_constant = std::integral_constant<bool, Value>; | |
| 4157 | |
| 4158 /////////////////////////////////////////////////////////////////////////////// | |
| 4159 // is_c_string | |
| 4160 /////////////////////////////////////////////////////////////////////////////// | |
| 4161 | |
| 4162 namespace impl | |
| 4163 { | |
| 4164 | |
| 4165 template<typename T> | |
| 4166 inline constexpr bool is_c_string() | |
| 4167 { | |
| 4168 using TUnExt = typename std::remove_extent<T>::type; | |
| 4169 using TUnCVExt = typename std::remove_cv<TUnExt>::type; | |
| 4170 using TUnPtr = typename std::remove_pointer<T>::type; | |
| 4171 using TUnCVPtr = typename std::remove_cv<TUnPtr>::type; | |
| 4172 return | |
| 4173 (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value) | |
| 4174 || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value); | |
| 4175 } | |
| 4176 | |
| 4177 } // namespace impl | |
| 4178 | |
| 4179 // checks whether T is a [cv] char */[cv] char[] C string | |
| 4180 template<typename T> | |
| 4181 struct is_c_string : bool_constant<impl::is_c_string<T>()> {}; | |
| 4182 | |
| 4183 template<typename T> | |
| 4184 using is_c_string_uncvref = is_c_string<uncvref_t<T>>; | |
| 4185 | |
| 4186 /////////////////////////////////////////////////////////////////////////////// | |
| 4187 // is_transparent | |
| 4188 /////////////////////////////////////////////////////////////////////////////// | |
| 4189 | |
| 4190 namespace impl | |
| 4191 { | |
| 4192 | |
| 4193 template<typename T> | |
| 4194 inline constexpr bool is_transparent() | |
| 4195 { | |
| 4196 return is_detected<detect_is_transparent, T>::value; | |
| 4197 } | |
| 4198 | |
| 4199 } // namespace impl | |
| 4200 | |
| 4201 // checks whether T has a member named is_transparent | |
| 4202 template<typename T> | |
| 4203 struct is_transparent : bool_constant<impl::is_transparent<T>()> {}; | |
| 4204 | |
| 4205 /////////////////////////////////////////////////////////////////////////////// | |
| 4206 | |
| 4207 } // namespace detail | |
| 4208 NLOHMANN_JSON_NAMESPACE_END | |
| 4209 | |
| 4210 // #include <nlohmann/detail/string_concat.hpp> | |
| 4211 // __ _____ _____ _____ | |
| 4212 // __| | __| | | | JSON for Modern C++ | |
| 4213 // | | |__ | | | | | | version 3.11.3 | |
| 4214 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 4215 // | |
| 4216 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 4217 // SPDX-License-Identifier: MIT | |
| 4218 | |
| 4219 | |
| 4220 | |
| 4221 #include <cstring> // strlen | |
| 4222 #include <string> // string | |
| 4223 #include <utility> // forward | |
| 4224 | |
| 4225 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 4226 | |
| 4227 // #include <nlohmann/detail/meta/detected.hpp> | |
| 4228 | |
| 4229 | |
| 4230 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 4231 namespace detail | |
| 4232 { | |
| 4233 | |
| 4234 inline std::size_t concat_length() | |
| 4235 { | |
| 4236 return 0; | |
| 4237 } | |
| 4238 | |
| 4239 template<typename... Args> | |
| 4240 inline std::size_t concat_length(const char* cstr, const Args& ... rest); | |
| 4241 | |
| 4242 template<typename StringType, typename... Args> | |
| 4243 inline std::size_t concat_length(const StringType& str, const Args& ... rest); | |
| 4244 | |
| 4245 template<typename... Args> | |
| 4246 inline std::size_t concat_length(const char /*c*/, const Args& ... rest) | |
| 4247 { | |
| 4248 return 1 + concat_length(rest...); | |
| 4249 } | |
| 4250 | |
| 4251 template<typename... Args> | |
| 4252 inline std::size_t concat_length(const char* cstr, const Args& ... rest) | |
| 4253 { | |
| 4254 // cppcheck-suppress ignoredReturnValue | |
| 4255 return ::strlen(cstr) + concat_length(rest...); | |
| 4256 } | |
| 4257 | |
| 4258 template<typename StringType, typename... Args> | |
| 4259 inline std::size_t concat_length(const StringType& str, const Args& ... rest) | |
| 4260 { | |
| 4261 return str.size() + concat_length(rest...); | |
| 4262 } | |
| 4263 | |
| 4264 template<typename OutStringType> | |
| 4265 inline void concat_into(OutStringType& /*out*/) | |
| 4266 {} | |
| 4267 | |
| 4268 template<typename StringType, typename Arg> | |
| 4269 using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ())); | |
| 4270 | |
| 4271 template<typename StringType, typename Arg> | |
| 4272 using detect_string_can_append = is_detected<string_can_append, StringType, Arg>; | |
| 4273 | |
| 4274 template<typename StringType, typename Arg> | |
| 4275 using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ()); | |
| 4276 | |
| 4277 template<typename StringType, typename Arg> | |
| 4278 using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>; | |
| 4279 | |
| 4280 template<typename StringType, typename Arg> | |
| 4281 using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end())); | |
| 4282 | |
| 4283 template<typename StringType, typename Arg> | |
| 4284 using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>; | |
| 4285 | |
| 4286 template<typename StringType, typename Arg> | |
| 4287 using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size())); | |
| 4288 | |
| 4289 template<typename StringType, typename Arg> | |
| 4290 using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>; | |
| 4291 | |
| 4292 template < typename OutStringType, typename Arg, typename... Args, | |
| 4293 enable_if_t < !detect_string_can_append<OutStringType, Arg>::value | |
| 4294 && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 > | |
| 4295 inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest); | |
| 4296 | |
| 4297 template < typename OutStringType, typename Arg, typename... Args, | |
| 4298 enable_if_t < !detect_string_can_append<OutStringType, Arg>::value | |
| 4299 && !detect_string_can_append_op<OutStringType, Arg>::value | |
| 4300 && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 > | |
| 4301 inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest); | |
| 4302 | |
| 4303 template < typename OutStringType, typename Arg, typename... Args, | |
| 4304 enable_if_t < !detect_string_can_append<OutStringType, Arg>::value | |
| 4305 && !detect_string_can_append_op<OutStringType, Arg>::value | |
| 4306 && !detect_string_can_append_iter<OutStringType, Arg>::value | |
| 4307 && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 > | |
| 4308 inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest); | |
| 4309 | |
| 4310 template<typename OutStringType, typename Arg, typename... Args, | |
| 4311 enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0> | |
| 4312 inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest) | |
| 4313 { | |
| 4314 out.append(std::forward<Arg>(arg)); | |
| 4315 concat_into(out, std::forward<Args>(rest)...); | |
| 4316 } | |
| 4317 | |
| 4318 template < typename OutStringType, typename Arg, typename... Args, | |
| 4319 enable_if_t < !detect_string_can_append<OutStringType, Arg>::value | |
| 4320 && detect_string_can_append_op<OutStringType, Arg>::value, int > > | |
| 4321 inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest) | |
| 4322 { | |
| 4323 out += std::forward<Arg>(arg); | |
| 4324 concat_into(out, std::forward<Args>(rest)...); | |
| 4325 } | |
| 4326 | |
| 4327 template < typename OutStringType, typename Arg, typename... Args, | |
| 4328 enable_if_t < !detect_string_can_append<OutStringType, Arg>::value | |
| 4329 && !detect_string_can_append_op<OutStringType, Arg>::value | |
| 4330 && detect_string_can_append_iter<OutStringType, Arg>::value, int > > | |
| 4331 inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest) | |
| 4332 { | |
| 4333 out.append(arg.begin(), arg.end()); | |
| 4334 concat_into(out, std::forward<Args>(rest)...); | |
| 4335 } | |
| 4336 | |
| 4337 template < typename OutStringType, typename Arg, typename... Args, | |
| 4338 enable_if_t < !detect_string_can_append<OutStringType, Arg>::value | |
| 4339 && !detect_string_can_append_op<OutStringType, Arg>::value | |
| 4340 && !detect_string_can_append_iter<OutStringType, Arg>::value | |
| 4341 && detect_string_can_append_data<OutStringType, Arg>::value, int > > | |
| 4342 inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest) | |
| 4343 { | |
| 4344 out.append(arg.data(), arg.size()); | |
| 4345 concat_into(out, std::forward<Args>(rest)...); | |
| 4346 } | |
| 4347 | |
| 4348 template<typename OutStringType = std::string, typename... Args> | |
| 4349 inline OutStringType concat(Args && ... args) | |
| 4350 { | |
| 4351 OutStringType str; | |
| 4352 str.reserve(concat_length(args...)); | |
| 4353 concat_into(str, std::forward<Args>(args)...); | |
| 4354 return str; | |
| 4355 } | |
| 4356 | |
| 4357 } // namespace detail | |
| 4358 NLOHMANN_JSON_NAMESPACE_END | |
| 4359 | |
| 4360 | |
| 4361 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 4362 namespace detail | |
| 4363 { | |
| 4364 | |
| 4365 //////////////// | |
| 4366 // exceptions // | |
| 4367 //////////////// | |
| 4368 | |
| 4369 /// @brief general exception of the @ref basic_json class | |
| 4370 /// @sa https://json.nlohmann.me/api/basic_json/exception/ | |
| 4371 class exception : public std::exception | |
| 4372 { | |
| 4373 public: | |
| 4374 /// returns the explanatory string | |
| 4375 const char* what() const noexcept override | |
| 4376 { | |
| 4377 return m.what(); | |
| 4378 } | |
| 4379 | |
| 4380 /// the id of the exception | |
| 4381 const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes) | |
| 4382 | |
| 4383 protected: | |
| 4384 JSON_HEDLEY_NON_NULL(3) | |
| 4385 exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing) | |
| 4386 | |
| 4387 static std::string name(const std::string& ename, int id_) | |
| 4388 { | |
| 4389 return concat("[json.exception.", ename, '.', std::to_string(id_), "] "); | |
| 4390 } | |
| 4391 | |
| 4392 static std::string diagnostics(std::nullptr_t /*leaf_element*/) | |
| 4393 { | |
| 4394 return ""; | |
| 4395 } | |
| 4396 | |
| 4397 template<typename BasicJsonType> | |
| 4398 static std::string diagnostics(const BasicJsonType* leaf_element) | |
| 4399 { | |
| 4400 #if JSON_DIAGNOSTICS | |
| 4401 std::vector<std::string> tokens; | |
| 4402 for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent) | |
| 4403 { | |
| 4404 switch (current->m_parent->type()) | |
| 4405 { | |
| 4406 case value_t::array: | |
| 4407 { | |
| 4408 for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i) | |
| 4409 { | |
| 4410 if (¤t->m_parent->m_data.m_value.array->operator[](i) == current) | |
| 4411 { | |
| 4412 tokens.emplace_back(std::to_string(i)); | |
| 4413 break; | |
| 4414 } | |
| 4415 } | |
| 4416 break; | |
| 4417 } | |
| 4418 | |
| 4419 case value_t::object: | |
| 4420 { | |
| 4421 for (const auto& element : *current->m_parent->m_data.m_value.object) | |
| 4422 { | |
| 4423 if (&element.second == current) | |
| 4424 { | |
| 4425 tokens.emplace_back(element.first.c_str()); | |
| 4426 break; | |
| 4427 } | |
| 4428 } | |
| 4429 break; | |
| 4430 } | |
| 4431 | |
| 4432 case value_t::null: // LCOV_EXCL_LINE | |
| 4433 case value_t::string: // LCOV_EXCL_LINE | |
| 4434 case value_t::boolean: // LCOV_EXCL_LINE | |
| 4435 case value_t::number_integer: // LCOV_EXCL_LINE | |
| 4436 case value_t::number_unsigned: // LCOV_EXCL_LINE | |
| 4437 case value_t::number_float: // LCOV_EXCL_LINE | |
| 4438 case value_t::binary: // LCOV_EXCL_LINE | |
| 4439 case value_t::discarded: // LCOV_EXCL_LINE | |
| 4440 default: // LCOV_EXCL_LINE | |
| 4441 break; // LCOV_EXCL_LINE | |
| 4442 } | |
| 4443 } | |
| 4444 | |
| 4445 if (tokens.empty()) | |
| 4446 { | |
| 4447 return ""; | |
| 4448 } | |
| 4449 | |
| 4450 auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{}, | |
| 4451 [](const std::string & a, const std::string & b) | |
| 4452 { | |
| 4453 return concat(a, '/', detail::escape(b)); | |
| 4454 }); | |
| 4455 return concat('(', str, ") "); | |
| 4456 #else | |
| 4457 static_cast<void>(leaf_element); | |
| 4458 return ""; | |
| 4459 #endif | |
| 4460 } | |
| 4461 | |
| 4462 private: | |
| 4463 /// an exception object as storage for error messages | |
| 4464 std::runtime_error m; | |
| 4465 }; | |
| 4466 | |
| 4467 /// @brief exception indicating a parse error | |
| 4468 /// @sa https://json.nlohmann.me/api/basic_json/parse_error/ | |
| 4469 class parse_error : public exception | |
| 4470 { | |
| 4471 public: | |
| 4472 /*! | |
| 4473 @brief create a parse error exception | |
| 4474 @param[in] id_ the id of the exception | |
| 4475 @param[in] pos the position where the error occurred (or with | |
| 4476 chars_read_total=0 if the position cannot be | |
| 4477 determined) | |
| 4478 @param[in] what_arg the explanatory string | |
| 4479 @return parse_error object | |
| 4480 */ | |
| 4481 template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0> | |
| 4482 static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context) | |
| 4483 { | |
| 4484 const std::string w = concat(exception::name("parse_error", id_), "parse error", | |
| 4485 position_string(pos), ": ", exception::diagnostics(context), what_arg); | |
| 4486 return {id_, pos.chars_read_total, w.c_str()}; | |
| 4487 } | |
| 4488 | |
| 4489 template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0> | |
| 4490 static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context) | |
| 4491 { | |
| 4492 const std::string w = concat(exception::name("parse_error", id_), "parse error", | |
| 4493 (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""), | |
| 4494 ": ", exception::diagnostics(context), what_arg); | |
| 4495 return {id_, byte_, w.c_str()}; | |
| 4496 } | |
| 4497 | |
| 4498 /*! | |
| 4499 @brief byte index of the parse error | |
| 4500 | |
| 4501 The byte index of the last read character in the input file. | |
| 4502 | |
| 4503 @note For an input with n bytes, 1 is the index of the first character and | |
| 4504 n+1 is the index of the terminating null byte or the end of file. | |
| 4505 This also holds true when reading a byte vector (CBOR or MessagePack). | |
| 4506 */ | |
| 4507 const std::size_t byte; | |
| 4508 | |
| 4509 private: | |
| 4510 parse_error(int id_, std::size_t byte_, const char* what_arg) | |
| 4511 : exception(id_, what_arg), byte(byte_) {} | |
| 4512 | |
| 4513 static std::string position_string(const position_t& pos) | |
| 4514 { | |
| 4515 return concat(" at line ", std::to_string(pos.lines_read + 1), | |
| 4516 ", column ", std::to_string(pos.chars_read_current_line)); | |
| 4517 } | |
| 4518 }; | |
| 4519 | |
| 4520 /// @brief exception indicating errors with iterators | |
| 4521 /// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/ | |
| 4522 class invalid_iterator : public exception | |
| 4523 { | |
| 4524 public: | |
| 4525 template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0> | |
| 4526 static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context) | |
| 4527 { | |
| 4528 const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg); | |
| 4529 return {id_, w.c_str()}; | |
| 4530 } | |
| 4531 | |
| 4532 private: | |
| 4533 JSON_HEDLEY_NON_NULL(3) | |
| 4534 invalid_iterator(int id_, const char* what_arg) | |
| 4535 : exception(id_, what_arg) {} | |
| 4536 }; | |
| 4537 | |
| 4538 /// @brief exception indicating executing a member function with a wrong type | |
| 4539 /// @sa https://json.nlohmann.me/api/basic_json/type_error/ | |
| 4540 class type_error : public exception | |
| 4541 { | |
| 4542 public: | |
| 4543 template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0> | |
| 4544 static type_error create(int id_, const std::string& what_arg, BasicJsonContext context) | |
| 4545 { | |
| 4546 const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg); | |
| 4547 return {id_, w.c_str()}; | |
| 4548 } | |
| 4549 | |
| 4550 private: | |
| 4551 JSON_HEDLEY_NON_NULL(3) | |
| 4552 type_error(int id_, const char* what_arg) : exception(id_, what_arg) {} | |
| 4553 }; | |
| 4554 | |
| 4555 /// @brief exception indicating access out of the defined range | |
| 4556 /// @sa https://json.nlohmann.me/api/basic_json/out_of_range/ | |
| 4557 class out_of_range : public exception | |
| 4558 { | |
| 4559 public: | |
| 4560 template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0> | |
| 4561 static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context) | |
| 4562 { | |
| 4563 const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg); | |
| 4564 return {id_, w.c_str()}; | |
| 4565 } | |
| 4566 | |
| 4567 private: | |
| 4568 JSON_HEDLEY_NON_NULL(3) | |
| 4569 out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {} | |
| 4570 }; | |
| 4571 | |
| 4572 /// @brief exception indicating other library errors | |
| 4573 /// @sa https://json.nlohmann.me/api/basic_json/other_error/ | |
| 4574 class other_error : public exception | |
| 4575 { | |
| 4576 public: | |
| 4577 template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0> | |
| 4578 static other_error create(int id_, const std::string& what_arg, BasicJsonContext context) | |
| 4579 { | |
| 4580 const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg); | |
| 4581 return {id_, w.c_str()}; | |
| 4582 } | |
| 4583 | |
| 4584 private: | |
| 4585 JSON_HEDLEY_NON_NULL(3) | |
| 4586 other_error(int id_, const char* what_arg) : exception(id_, what_arg) {} | |
| 4587 }; | |
| 4588 | |
| 4589 } // namespace detail | |
| 4590 NLOHMANN_JSON_NAMESPACE_END | |
| 4591 | |
| 4592 // #include <nlohmann/detail/macro_scope.hpp> | |
| 4593 | |
| 4594 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 4595 | |
| 4596 // #include <nlohmann/detail/meta/identity_tag.hpp> | |
| 4597 // __ _____ _____ _____ | |
| 4598 // __| | __| | | | JSON for Modern C++ | |
| 4599 // | | |__ | | | | | | version 3.11.3 | |
| 4600 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 4601 // | |
| 4602 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 4603 // SPDX-License-Identifier: MIT | |
| 4604 | |
| 4605 | |
| 4606 | |
| 4607 // #include <nlohmann/detail/abi_macros.hpp> | |
| 4608 | |
| 4609 | |
| 4610 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 4611 namespace detail | |
| 4612 { | |
| 4613 | |
| 4614 // dispatching helper struct | |
| 4615 template <class T> struct identity_tag {}; | |
| 4616 | |
| 4617 } // namespace detail | |
| 4618 NLOHMANN_JSON_NAMESPACE_END | |
| 4619 | |
| 4620 // #include <nlohmann/detail/meta/std_fs.hpp> | |
| 4621 // __ _____ _____ _____ | |
| 4622 // __| | __| | | | JSON for Modern C++ | |
| 4623 // | | |__ | | | | | | version 3.11.3 | |
| 4624 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 4625 // | |
| 4626 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 4627 // SPDX-License-Identifier: MIT | |
| 4628 | |
| 4629 | |
| 4630 | |
| 4631 // #include <nlohmann/detail/macro_scope.hpp> | |
| 4632 | |
| 4633 | |
| 4634 #if JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 4635 #include <experimental/filesystem> | |
| 4636 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 4637 namespace detail | |
| 4638 { | |
| 4639 namespace std_fs = std::experimental::filesystem; | |
| 4640 } // namespace detail | |
| 4641 NLOHMANN_JSON_NAMESPACE_END | |
| 4642 #elif JSON_HAS_FILESYSTEM | |
| 4643 #include <filesystem> | |
| 4644 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 4645 namespace detail | |
| 4646 { | |
| 4647 namespace std_fs = std::filesystem; | |
| 4648 } // namespace detail | |
| 4649 NLOHMANN_JSON_NAMESPACE_END | |
| 4650 #endif | |
| 4651 | |
| 4652 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 4653 | |
| 4654 // #include <nlohmann/detail/string_concat.hpp> | |
| 4655 | |
| 4656 // #include <nlohmann/detail/value_t.hpp> | |
| 4657 | |
| 4658 | |
| 4659 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 4660 namespace detail | |
| 4661 { | |
| 4662 | |
| 4663 template<typename BasicJsonType> | |
| 4664 inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n) | |
| 4665 { | |
| 4666 if (JSON_HEDLEY_UNLIKELY(!j.is_null())) | |
| 4667 { | |
| 4668 JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j)); | |
| 4669 } | |
| 4670 n = nullptr; | |
| 4671 } | |
| 4672 | |
| 4673 // overloads for basic_json template parameters | |
| 4674 template < typename BasicJsonType, typename ArithmeticType, | |
| 4675 enable_if_t < std::is_arithmetic<ArithmeticType>::value&& | |
| 4676 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value, | |
| 4677 int > = 0 > | |
| 4678 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val) | |
| 4679 { | |
| 4680 switch (static_cast<value_t>(j)) | |
| 4681 { | |
| 4682 case value_t::number_unsigned: | |
| 4683 { | |
| 4684 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>()); | |
| 4685 break; | |
| 4686 } | |
| 4687 case value_t::number_integer: | |
| 4688 { | |
| 4689 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>()); | |
| 4690 break; | |
| 4691 } | |
| 4692 case value_t::number_float: | |
| 4693 { | |
| 4694 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>()); | |
| 4695 break; | |
| 4696 } | |
| 4697 | |
| 4698 case value_t::null: | |
| 4699 case value_t::object: | |
| 4700 case value_t::array: | |
| 4701 case value_t::string: | |
| 4702 case value_t::boolean: | |
| 4703 case value_t::binary: | |
| 4704 case value_t::discarded: | |
| 4705 default: | |
| 4706 JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); | |
| 4707 } | |
| 4708 } | |
| 4709 | |
| 4710 template<typename BasicJsonType> | |
| 4711 inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b) | |
| 4712 { | |
| 4713 if (JSON_HEDLEY_UNLIKELY(!j.is_boolean())) | |
| 4714 { | |
| 4715 JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j)); | |
| 4716 } | |
| 4717 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>(); | |
| 4718 } | |
| 4719 | |
| 4720 template<typename BasicJsonType> | |
| 4721 inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s) | |
| 4722 { | |
| 4723 if (JSON_HEDLEY_UNLIKELY(!j.is_string())) | |
| 4724 { | |
| 4725 JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); | |
| 4726 } | |
| 4727 s = *j.template get_ptr<const typename BasicJsonType::string_t*>(); | |
| 4728 } | |
| 4729 | |
| 4730 template < | |
| 4731 typename BasicJsonType, typename StringType, | |
| 4732 enable_if_t < | |
| 4733 std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value | |
| 4734 && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value | |
| 4735 && !std::is_same<typename BasicJsonType::string_t, StringType>::value | |
| 4736 && !is_json_ref<StringType>::value, int > = 0 > | |
| 4737 inline void from_json(const BasicJsonType& j, StringType& s) | |
| 4738 { | |
| 4739 if (JSON_HEDLEY_UNLIKELY(!j.is_string())) | |
| 4740 { | |
| 4741 JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); | |
| 4742 } | |
| 4743 | |
| 4744 s = *j.template get_ptr<const typename BasicJsonType::string_t*>(); | |
| 4745 } | |
| 4746 | |
| 4747 template<typename BasicJsonType> | |
| 4748 inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val) | |
| 4749 { | |
| 4750 get_arithmetic_value(j, val); | |
| 4751 } | |
| 4752 | |
| 4753 template<typename BasicJsonType> | |
| 4754 inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val) | |
| 4755 { | |
| 4756 get_arithmetic_value(j, val); | |
| 4757 } | |
| 4758 | |
| 4759 template<typename BasicJsonType> | |
| 4760 inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val) | |
| 4761 { | |
| 4762 get_arithmetic_value(j, val); | |
| 4763 } | |
| 4764 | |
| 4765 #if !JSON_DISABLE_ENUM_SERIALIZATION | |
| 4766 template<typename BasicJsonType, typename EnumType, | |
| 4767 enable_if_t<std::is_enum<EnumType>::value, int> = 0> | |
| 4768 inline void from_json(const BasicJsonType& j, EnumType& e) | |
| 4769 { | |
| 4770 typename std::underlying_type<EnumType>::type val; | |
| 4771 get_arithmetic_value(j, val); | |
| 4772 e = static_cast<EnumType>(val); | |
| 4773 } | |
| 4774 #endif // JSON_DISABLE_ENUM_SERIALIZATION | |
| 4775 | |
| 4776 // forward_list doesn't have an insert method | |
| 4777 template<typename BasicJsonType, typename T, typename Allocator, | |
| 4778 enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0> | |
| 4779 inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l) | |
| 4780 { | |
| 4781 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 4782 { | |
| 4783 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 4784 } | |
| 4785 l.clear(); | |
| 4786 std::transform(j.rbegin(), j.rend(), | |
| 4787 std::front_inserter(l), [](const BasicJsonType & i) | |
| 4788 { | |
| 4789 return i.template get<T>(); | |
| 4790 }); | |
| 4791 } | |
| 4792 | |
| 4793 // valarray doesn't have an insert method | |
| 4794 template<typename BasicJsonType, typename T, | |
| 4795 enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0> | |
| 4796 inline void from_json(const BasicJsonType& j, std::valarray<T>& l) | |
| 4797 { | |
| 4798 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 4799 { | |
| 4800 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 4801 } | |
| 4802 l.resize(j.size()); | |
| 4803 std::transform(j.begin(), j.end(), std::begin(l), | |
| 4804 [](const BasicJsonType & elem) | |
| 4805 { | |
| 4806 return elem.template get<T>(); | |
| 4807 }); | |
| 4808 } | |
| 4809 | |
| 4810 template<typename BasicJsonType, typename T, std::size_t N> | |
| 4811 auto from_json(const BasicJsonType& j, T (&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) | |
| 4812 -> decltype(j.template get<T>(), void()) | |
| 4813 { | |
| 4814 for (std::size_t i = 0; i < N; ++i) | |
| 4815 { | |
| 4816 arr[i] = j.at(i).template get<T>(); | |
| 4817 } | |
| 4818 } | |
| 4819 | |
| 4820 template<typename BasicJsonType> | |
| 4821 inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/) | |
| 4822 { | |
| 4823 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>(); | |
| 4824 } | |
| 4825 | |
| 4826 template<typename BasicJsonType, typename T, std::size_t N> | |
| 4827 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr, | |
| 4828 priority_tag<2> /*unused*/) | |
| 4829 -> decltype(j.template get<T>(), void()) | |
| 4830 { | |
| 4831 for (std::size_t i = 0; i < N; ++i) | |
| 4832 { | |
| 4833 arr[i] = j.at(i).template get<T>(); | |
| 4834 } | |
| 4835 } | |
| 4836 | |
| 4837 template<typename BasicJsonType, typename ConstructibleArrayType, | |
| 4838 enable_if_t< | |
| 4839 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value, | |
| 4840 int> = 0> | |
| 4841 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/) | |
| 4842 -> decltype( | |
| 4843 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()), | |
| 4844 j.template get<typename ConstructibleArrayType::value_type>(), | |
| 4845 void()) | |
| 4846 { | |
| 4847 using std::end; | |
| 4848 | |
| 4849 ConstructibleArrayType ret; | |
| 4850 ret.reserve(j.size()); | |
| 4851 std::transform(j.begin(), j.end(), | |
| 4852 std::inserter(ret, end(ret)), [](const BasicJsonType & i) | |
| 4853 { | |
| 4854 // get<BasicJsonType>() returns *this, this won't call a from_json | |
| 4855 // method when value_type is BasicJsonType | |
| 4856 return i.template get<typename ConstructibleArrayType::value_type>(); | |
| 4857 }); | |
| 4858 arr = std::move(ret); | |
| 4859 } | |
| 4860 | |
| 4861 template<typename BasicJsonType, typename ConstructibleArrayType, | |
| 4862 enable_if_t< | |
| 4863 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value, | |
| 4864 int> = 0> | |
| 4865 inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, | |
| 4866 priority_tag<0> /*unused*/) | |
| 4867 { | |
| 4868 using std::end; | |
| 4869 | |
| 4870 ConstructibleArrayType ret; | |
| 4871 std::transform( | |
| 4872 j.begin(), j.end(), std::inserter(ret, end(ret)), | |
| 4873 [](const BasicJsonType & i) | |
| 4874 { | |
| 4875 // get<BasicJsonType>() returns *this, this won't call a from_json | |
| 4876 // method when value_type is BasicJsonType | |
| 4877 return i.template get<typename ConstructibleArrayType::value_type>(); | |
| 4878 }); | |
| 4879 arr = std::move(ret); | |
| 4880 } | |
| 4881 | |
| 4882 template < typename BasicJsonType, typename ConstructibleArrayType, | |
| 4883 enable_if_t < | |
| 4884 is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&& | |
| 4885 !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&& | |
| 4886 !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&& | |
| 4887 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&& | |
| 4888 !is_basic_json<ConstructibleArrayType>::value, | |
| 4889 int > = 0 > | |
| 4890 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr) | |
| 4891 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}), | |
| 4892 j.template get<typename ConstructibleArrayType::value_type>(), | |
| 4893 void()) | |
| 4894 { | |
| 4895 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 4896 { | |
| 4897 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 4898 } | |
| 4899 | |
| 4900 from_json_array_impl(j, arr, priority_tag<3> {}); | |
| 4901 } | |
| 4902 | |
| 4903 template < typename BasicJsonType, typename T, std::size_t... Idx > | |
| 4904 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j, | |
| 4905 identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/) | |
| 4906 { | |
| 4907 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } }; | |
| 4908 } | |
| 4909 | |
| 4910 template < typename BasicJsonType, typename T, std::size_t N > | |
| 4911 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag) | |
| 4912 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {})) | |
| 4913 { | |
| 4914 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 4915 { | |
| 4916 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 4917 } | |
| 4918 | |
| 4919 return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}); | |
| 4920 } | |
| 4921 | |
| 4922 template<typename BasicJsonType> | |
| 4923 inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin) | |
| 4924 { | |
| 4925 if (JSON_HEDLEY_UNLIKELY(!j.is_binary())) | |
| 4926 { | |
| 4927 JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j)); | |
| 4928 } | |
| 4929 | |
| 4930 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>(); | |
| 4931 } | |
| 4932 | |
| 4933 template<typename BasicJsonType, typename ConstructibleObjectType, | |
| 4934 enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0> | |
| 4935 inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj) | |
| 4936 { | |
| 4937 if (JSON_HEDLEY_UNLIKELY(!j.is_object())) | |
| 4938 { | |
| 4939 JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j)); | |
| 4940 } | |
| 4941 | |
| 4942 ConstructibleObjectType ret; | |
| 4943 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>(); | |
| 4944 using value_type = typename ConstructibleObjectType::value_type; | |
| 4945 std::transform( | |
| 4946 inner_object->begin(), inner_object->end(), | |
| 4947 std::inserter(ret, ret.begin()), | |
| 4948 [](typename BasicJsonType::object_t::value_type const & p) | |
| 4949 { | |
| 4950 return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>()); | |
| 4951 }); | |
| 4952 obj = std::move(ret); | |
| 4953 } | |
| 4954 | |
| 4955 // overload for arithmetic types, not chosen for basic_json template arguments | |
| 4956 // (BooleanType, etc..); note: Is it really necessary to provide explicit | |
| 4957 // overloads for boolean_t etc. in case of a custom BooleanType which is not | |
| 4958 // an arithmetic type? | |
| 4959 template < typename BasicJsonType, typename ArithmeticType, | |
| 4960 enable_if_t < | |
| 4961 std::is_arithmetic<ArithmeticType>::value&& | |
| 4962 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&& | |
| 4963 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&& | |
| 4964 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&& | |
| 4965 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value, | |
| 4966 int > = 0 > | |
| 4967 inline void from_json(const BasicJsonType& j, ArithmeticType& val) | |
| 4968 { | |
| 4969 switch (static_cast<value_t>(j)) | |
| 4970 { | |
| 4971 case value_t::number_unsigned: | |
| 4972 { | |
| 4973 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>()); | |
| 4974 break; | |
| 4975 } | |
| 4976 case value_t::number_integer: | |
| 4977 { | |
| 4978 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>()); | |
| 4979 break; | |
| 4980 } | |
| 4981 case value_t::number_float: | |
| 4982 { | |
| 4983 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>()); | |
| 4984 break; | |
| 4985 } | |
| 4986 case value_t::boolean: | |
| 4987 { | |
| 4988 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>()); | |
| 4989 break; | |
| 4990 } | |
| 4991 | |
| 4992 case value_t::null: | |
| 4993 case value_t::object: | |
| 4994 case value_t::array: | |
| 4995 case value_t::string: | |
| 4996 case value_t::binary: | |
| 4997 case value_t::discarded: | |
| 4998 default: | |
| 4999 JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); | |
| 5000 } | |
| 5001 } | |
| 5002 | |
| 5003 template<typename BasicJsonType, typename... Args, std::size_t... Idx> | |
| 5004 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/) | |
| 5005 { | |
| 5006 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...); | |
| 5007 } | |
| 5008 | |
| 5009 template < typename BasicJsonType, class A1, class A2 > | |
| 5010 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/) | |
| 5011 { | |
| 5012 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(), | |
| 5013 std::forward<BasicJsonType>(j).at(1).template get<A2>()}; | |
| 5014 } | |
| 5015 | |
| 5016 template<typename BasicJsonType, typename A1, typename A2> | |
| 5017 inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/) | |
| 5018 { | |
| 5019 p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {}); | |
| 5020 } | |
| 5021 | |
| 5022 template<typename BasicJsonType, typename... Args> | |
| 5023 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/) | |
| 5024 { | |
| 5025 return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {}); | |
| 5026 } | |
| 5027 | |
| 5028 template<typename BasicJsonType, typename... Args> | |
| 5029 inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/) | |
| 5030 { | |
| 5031 t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {}); | |
| 5032 } | |
| 5033 | |
| 5034 template<typename BasicJsonType, typename TupleRelated> | |
| 5035 auto from_json(BasicJsonType&& j, TupleRelated&& t) | |
| 5036 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {})) | |
| 5037 { | |
| 5038 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 5039 { | |
| 5040 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 5041 } | |
| 5042 | |
| 5043 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}); | |
| 5044 } | |
| 5045 | |
| 5046 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator, | |
| 5047 typename = enable_if_t < !std::is_constructible < | |
| 5048 typename BasicJsonType::string_t, Key >::value >> | |
| 5049 inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m) | |
| 5050 { | |
| 5051 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 5052 { | |
| 5053 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 5054 } | |
| 5055 m.clear(); | |
| 5056 for (const auto& p : j) | |
| 5057 { | |
| 5058 if (JSON_HEDLEY_UNLIKELY(!p.is_array())) | |
| 5059 { | |
| 5060 JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j)); | |
| 5061 } | |
| 5062 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>()); | |
| 5063 } | |
| 5064 } | |
| 5065 | |
| 5066 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator, | |
| 5067 typename = enable_if_t < !std::is_constructible < | |
| 5068 typename BasicJsonType::string_t, Key >::value >> | |
| 5069 inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m) | |
| 5070 { | |
| 5071 if (JSON_HEDLEY_UNLIKELY(!j.is_array())) | |
| 5072 { | |
| 5073 JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); | |
| 5074 } | |
| 5075 m.clear(); | |
| 5076 for (const auto& p : j) | |
| 5077 { | |
| 5078 if (JSON_HEDLEY_UNLIKELY(!p.is_array())) | |
| 5079 { | |
| 5080 JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j)); | |
| 5081 } | |
| 5082 m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>()); | |
| 5083 } | |
| 5084 } | |
| 5085 | |
| 5086 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 5087 template<typename BasicJsonType> | |
| 5088 inline void from_json(const BasicJsonType& j, std_fs::path& p) | |
| 5089 { | |
| 5090 if (JSON_HEDLEY_UNLIKELY(!j.is_string())) | |
| 5091 { | |
| 5092 JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); | |
| 5093 } | |
| 5094 p = *j.template get_ptr<const typename BasicJsonType::string_t*>(); | |
| 5095 } | |
| 5096 #endif | |
| 5097 | |
| 5098 struct from_json_fn | |
| 5099 { | |
| 5100 template<typename BasicJsonType, typename T> | |
| 5101 auto operator()(const BasicJsonType& j, T&& val) const | |
| 5102 noexcept(noexcept(from_json(j, std::forward<T>(val)))) | |
| 5103 -> decltype(from_json(j, std::forward<T>(val))) | |
| 5104 { | |
| 5105 return from_json(j, std::forward<T>(val)); | |
| 5106 } | |
| 5107 }; | |
| 5108 | |
| 5109 } // namespace detail | |
| 5110 | |
| 5111 #ifndef JSON_HAS_CPP_17 | |
| 5112 /// namespace to hold default `from_json` function | |
| 5113 /// to see why this is required: | |
| 5114 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html | |
| 5115 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces) | |
| 5116 { | |
| 5117 #endif | |
| 5118 JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers) | |
| 5119 detail::static_const<detail::from_json_fn>::value; | |
| 5120 #ifndef JSON_HAS_CPP_17 | |
| 5121 } // namespace | |
| 5122 #endif | |
| 5123 | |
| 5124 NLOHMANN_JSON_NAMESPACE_END | |
| 5125 | |
| 5126 // #include <nlohmann/detail/conversions/to_json.hpp> | |
| 5127 // __ _____ _____ _____ | |
| 5128 // __| | __| | | | JSON for Modern C++ | |
| 5129 // | | |__ | | | | | | version 3.11.3 | |
| 5130 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 5131 // | |
| 5132 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 5133 // SPDX-License-Identifier: MIT | |
| 5134 | |
| 5135 | |
| 5136 | |
| 5137 #include <algorithm> // copy | |
| 5138 #include <iterator> // begin, end | |
| 5139 #include <string> // string | |
| 5140 #include <tuple> // tuple, get | |
| 5141 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type | |
| 5142 #include <utility> // move, forward, declval, pair | |
| 5143 #include <valarray> // valarray | |
| 5144 #include <vector> // vector | |
| 5145 | |
| 5146 // #include <nlohmann/detail/iterators/iteration_proxy.hpp> | |
| 5147 // __ _____ _____ _____ | |
| 5148 // __| | __| | | | JSON for Modern C++ | |
| 5149 // | | |__ | | | | | | version 3.11.3 | |
| 5150 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 5151 // | |
| 5152 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 5153 // SPDX-License-Identifier: MIT | |
| 5154 | |
| 5155 | |
| 5156 | |
| 5157 #include <cstddef> // size_t | |
| 5158 #include <iterator> // input_iterator_tag | |
| 5159 #include <string> // string, to_string | |
| 5160 #include <tuple> // tuple_size, get, tuple_element | |
| 5161 #include <utility> // move | |
| 5162 | |
| 5163 #if JSON_HAS_RANGES | |
| 5164 #include <ranges> // enable_borrowed_range | |
| 5165 #endif | |
| 5166 | |
| 5167 // #include <nlohmann/detail/abi_macros.hpp> | |
| 5168 | |
| 5169 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 5170 | |
| 5171 // #include <nlohmann/detail/value_t.hpp> | |
| 5172 | |
| 5173 | |
| 5174 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 5175 namespace detail | |
| 5176 { | |
| 5177 | |
| 5178 template<typename string_type> | |
| 5179 void int_to_string( string_type& target, std::size_t value ) | |
| 5180 { | |
| 5181 // For ADL | |
| 5182 using std::to_string; | |
| 5183 target = to_string(value); | |
| 5184 } | |
| 5185 template<typename IteratorType> class iteration_proxy_value | |
| 5186 { | |
| 5187 public: | |
| 5188 using difference_type = std::ptrdiff_t; | |
| 5189 using value_type = iteration_proxy_value; | |
| 5190 using pointer = value_type *; | |
| 5191 using reference = value_type &; | |
| 5192 using iterator_category = std::input_iterator_tag; | |
| 5193 using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type; | |
| 5194 | |
| 5195 private: | |
| 5196 /// the iterator | |
| 5197 IteratorType anchor{}; | |
| 5198 /// an index for arrays (used to create key names) | |
| 5199 std::size_t array_index = 0; | |
| 5200 /// last stringified array index | |
| 5201 mutable std::size_t array_index_last = 0; | |
| 5202 /// a string representation of the array index | |
| 5203 mutable string_type array_index_str = "0"; | |
| 5204 /// an empty string (to return a reference for primitive values) | |
| 5205 string_type empty_str{}; | |
| 5206 | |
| 5207 public: | |
| 5208 explicit iteration_proxy_value() = default; | |
| 5209 explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0) | |
| 5210 noexcept(std::is_nothrow_move_constructible<IteratorType>::value | |
| 5211 && std::is_nothrow_default_constructible<string_type>::value) | |
| 5212 : anchor(std::move(it)) | |
| 5213 , array_index(array_index_) | |
| 5214 {} | |
| 5215 | |
| 5216 iteration_proxy_value(iteration_proxy_value const&) = default; | |
| 5217 iteration_proxy_value& operator=(iteration_proxy_value const&) = default; | |
| 5218 // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions | |
| 5219 iteration_proxy_value(iteration_proxy_value&&) | |
| 5220 noexcept(std::is_nothrow_move_constructible<IteratorType>::value | |
| 5221 && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations) | |
| 5222 iteration_proxy_value& operator=(iteration_proxy_value&&) | |
| 5223 noexcept(std::is_nothrow_move_assignable<IteratorType>::value | |
| 5224 && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations) | |
| 5225 ~iteration_proxy_value() = default; | |
| 5226 | |
| 5227 /// dereference operator (needed for range-based for) | |
| 5228 const iteration_proxy_value& operator*() const | |
| 5229 { | |
| 5230 return *this; | |
| 5231 } | |
| 5232 | |
| 5233 /// increment operator (needed for range-based for) | |
| 5234 iteration_proxy_value& operator++() | |
| 5235 { | |
| 5236 ++anchor; | |
| 5237 ++array_index; | |
| 5238 | |
| 5239 return *this; | |
| 5240 } | |
| 5241 | |
| 5242 iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp) | |
| 5243 { | |
| 5244 auto tmp = iteration_proxy_value(anchor, array_index); | |
| 5245 ++anchor; | |
| 5246 ++array_index; | |
| 5247 return tmp; | |
| 5248 } | |
| 5249 | |
| 5250 /// equality operator (needed for InputIterator) | |
| 5251 bool operator==(const iteration_proxy_value& o) const | |
| 5252 { | |
| 5253 return anchor == o.anchor; | |
| 5254 } | |
| 5255 | |
| 5256 /// inequality operator (needed for range-based for) | |
| 5257 bool operator!=(const iteration_proxy_value& o) const | |
| 5258 { | |
| 5259 return anchor != o.anchor; | |
| 5260 } | |
| 5261 | |
| 5262 /// return key of the iterator | |
| 5263 const string_type& key() const | |
| 5264 { | |
| 5265 JSON_ASSERT(anchor.m_object != nullptr); | |
| 5266 | |
| 5267 switch (anchor.m_object->type()) | |
| 5268 { | |
| 5269 // use integer array index as key | |
| 5270 case value_t::array: | |
| 5271 { | |
| 5272 if (array_index != array_index_last) | |
| 5273 { | |
| 5274 int_to_string( array_index_str, array_index ); | |
| 5275 array_index_last = array_index; | |
| 5276 } | |
| 5277 return array_index_str; | |
| 5278 } | |
| 5279 | |
| 5280 // use key from the object | |
| 5281 case value_t::object: | |
| 5282 return anchor.key(); | |
| 5283 | |
| 5284 // use an empty key for all primitive types | |
| 5285 case value_t::null: | |
| 5286 case value_t::string: | |
| 5287 case value_t::boolean: | |
| 5288 case value_t::number_integer: | |
| 5289 case value_t::number_unsigned: | |
| 5290 case value_t::number_float: | |
| 5291 case value_t::binary: | |
| 5292 case value_t::discarded: | |
| 5293 default: | |
| 5294 return empty_str; | |
| 5295 } | |
| 5296 } | |
| 5297 | |
| 5298 /// return value of the iterator | |
| 5299 typename IteratorType::reference value() const | |
| 5300 { | |
| 5301 return anchor.value(); | |
| 5302 } | |
| 5303 }; | |
| 5304 | |
| 5305 /// proxy class for the items() function | |
| 5306 template<typename IteratorType> class iteration_proxy | |
| 5307 { | |
| 5308 private: | |
| 5309 /// the container to iterate | |
| 5310 typename IteratorType::pointer container = nullptr; | |
| 5311 | |
| 5312 public: | |
| 5313 explicit iteration_proxy() = default; | |
| 5314 | |
| 5315 /// construct iteration proxy from a container | |
| 5316 explicit iteration_proxy(typename IteratorType::reference cont) noexcept | |
| 5317 : container(&cont) {} | |
| 5318 | |
| 5319 iteration_proxy(iteration_proxy const&) = default; | |
| 5320 iteration_proxy& operator=(iteration_proxy const&) = default; | |
| 5321 iteration_proxy(iteration_proxy&&) noexcept = default; | |
| 5322 iteration_proxy& operator=(iteration_proxy&&) noexcept = default; | |
| 5323 ~iteration_proxy() = default; | |
| 5324 | |
| 5325 /// return iterator begin (needed for range-based for) | |
| 5326 iteration_proxy_value<IteratorType> begin() const noexcept | |
| 5327 { | |
| 5328 return iteration_proxy_value<IteratorType>(container->begin()); | |
| 5329 } | |
| 5330 | |
| 5331 /// return iterator end (needed for range-based for) | |
| 5332 iteration_proxy_value<IteratorType> end() const noexcept | |
| 5333 { | |
| 5334 return iteration_proxy_value<IteratorType>(container->end()); | |
| 5335 } | |
| 5336 }; | |
| 5337 | |
| 5338 // Structured Bindings Support | |
| 5339 // For further reference see https://blog.tartanllama.xyz/structured-bindings/ | |
| 5340 // And see https://github.com/nlohmann/json/pull/1391 | |
| 5341 template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0> | |
| 5342 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key()) | |
| 5343 { | |
| 5344 return i.key(); | |
| 5345 } | |
| 5346 // Structured Bindings Support | |
| 5347 // For further reference see https://blog.tartanllama.xyz/structured-bindings/ | |
| 5348 // And see https://github.com/nlohmann/json/pull/1391 | |
| 5349 template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0> | |
| 5350 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value()) | |
| 5351 { | |
| 5352 return i.value(); | |
| 5353 } | |
| 5354 | |
| 5355 } // namespace detail | |
| 5356 NLOHMANN_JSON_NAMESPACE_END | |
| 5357 | |
| 5358 // The Addition to the STD Namespace is required to add | |
| 5359 // Structured Bindings Support to the iteration_proxy_value class | |
| 5360 // For further reference see https://blog.tartanllama.xyz/structured-bindings/ | |
| 5361 // And see https://github.com/nlohmann/json/pull/1391 | |
| 5362 namespace std | |
| 5363 { | |
| 5364 | |
| 5365 #if defined(__clang__) | |
| 5366 // Fix: https://github.com/nlohmann/json/issues/1401 | |
| 5367 #pragma clang diagnostic push | |
| 5368 #pragma clang diagnostic ignored "-Wmismatched-tags" | |
| 5369 #endif | |
| 5370 template<typename IteratorType> | |
| 5371 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp) | |
| 5372 : public std::integral_constant<std::size_t, 2> {}; | |
| 5373 | |
| 5374 template<std::size_t N, typename IteratorType> | |
| 5375 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp) | |
| 5376 { | |
| 5377 public: | |
| 5378 using type = decltype( | |
| 5379 get<N>(std::declval < | |
| 5380 ::nlohmann::detail::iteration_proxy_value<IteratorType >> ())); | |
| 5381 }; | |
| 5382 #if defined(__clang__) | |
| 5383 #pragma clang diagnostic pop | |
| 5384 #endif | |
| 5385 | |
| 5386 } // namespace std | |
| 5387 | |
| 5388 #if JSON_HAS_RANGES | |
| 5389 template <typename IteratorType> | |
| 5390 inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true; | |
| 5391 #endif | |
| 5392 | |
| 5393 // #include <nlohmann/detail/macro_scope.hpp> | |
| 5394 | |
| 5395 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 5396 | |
| 5397 // #include <nlohmann/detail/meta/std_fs.hpp> | |
| 5398 | |
| 5399 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 5400 | |
| 5401 // #include <nlohmann/detail/value_t.hpp> | |
| 5402 | |
| 5403 | |
| 5404 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 5405 namespace detail | |
| 5406 { | |
| 5407 | |
| 5408 ////////////////// | |
| 5409 // constructors // | |
| 5410 ////////////////// | |
| 5411 | |
| 5412 /* | |
| 5413 * Note all external_constructor<>::construct functions need to call | |
| 5414 * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an | |
| 5415 * allocated value (e.g., a string). See bug issue | |
| 5416 * https://github.com/nlohmann/json/issues/2865 for more information. | |
| 5417 */ | |
| 5418 | |
| 5419 template<value_t> struct external_constructor; | |
| 5420 | |
| 5421 template<> | |
| 5422 struct external_constructor<value_t::boolean> | |
| 5423 { | |
| 5424 template<typename BasicJsonType> | |
| 5425 static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept | |
| 5426 { | |
| 5427 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5428 j.m_data.m_type = value_t::boolean; | |
| 5429 j.m_data.m_value = b; | |
| 5430 j.assert_invariant(); | |
| 5431 } | |
| 5432 }; | |
| 5433 | |
| 5434 template<> | |
| 5435 struct external_constructor<value_t::string> | |
| 5436 { | |
| 5437 template<typename BasicJsonType> | |
| 5438 static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s) | |
| 5439 { | |
| 5440 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5441 j.m_data.m_type = value_t::string; | |
| 5442 j.m_data.m_value = s; | |
| 5443 j.assert_invariant(); | |
| 5444 } | |
| 5445 | |
| 5446 template<typename BasicJsonType> | |
| 5447 static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s) | |
| 5448 { | |
| 5449 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5450 j.m_data.m_type = value_t::string; | |
| 5451 j.m_data.m_value = std::move(s); | |
| 5452 j.assert_invariant(); | |
| 5453 } | |
| 5454 | |
| 5455 template < typename BasicJsonType, typename CompatibleStringType, | |
| 5456 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value, | |
| 5457 int > = 0 > | |
| 5458 static void construct(BasicJsonType& j, const CompatibleStringType& str) | |
| 5459 { | |
| 5460 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5461 j.m_data.m_type = value_t::string; | |
| 5462 j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str); | |
| 5463 j.assert_invariant(); | |
| 5464 } | |
| 5465 }; | |
| 5466 | |
| 5467 template<> | |
| 5468 struct external_constructor<value_t::binary> | |
| 5469 { | |
| 5470 template<typename BasicJsonType> | |
| 5471 static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b) | |
| 5472 { | |
| 5473 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5474 j.m_data.m_type = value_t::binary; | |
| 5475 j.m_data.m_value = typename BasicJsonType::binary_t(b); | |
| 5476 j.assert_invariant(); | |
| 5477 } | |
| 5478 | |
| 5479 template<typename BasicJsonType> | |
| 5480 static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b) | |
| 5481 { | |
| 5482 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5483 j.m_data.m_type = value_t::binary; | |
| 5484 j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b)); | |
| 5485 j.assert_invariant(); | |
| 5486 } | |
| 5487 }; | |
| 5488 | |
| 5489 template<> | |
| 5490 struct external_constructor<value_t::number_float> | |
| 5491 { | |
| 5492 template<typename BasicJsonType> | |
| 5493 static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept | |
| 5494 { | |
| 5495 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5496 j.m_data.m_type = value_t::number_float; | |
| 5497 j.m_data.m_value = val; | |
| 5498 j.assert_invariant(); | |
| 5499 } | |
| 5500 }; | |
| 5501 | |
| 5502 template<> | |
| 5503 struct external_constructor<value_t::number_unsigned> | |
| 5504 { | |
| 5505 template<typename BasicJsonType> | |
| 5506 static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept | |
| 5507 { | |
| 5508 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5509 j.m_data.m_type = value_t::number_unsigned; | |
| 5510 j.m_data.m_value = val; | |
| 5511 j.assert_invariant(); | |
| 5512 } | |
| 5513 }; | |
| 5514 | |
| 5515 template<> | |
| 5516 struct external_constructor<value_t::number_integer> | |
| 5517 { | |
| 5518 template<typename BasicJsonType> | |
| 5519 static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept | |
| 5520 { | |
| 5521 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5522 j.m_data.m_type = value_t::number_integer; | |
| 5523 j.m_data.m_value = val; | |
| 5524 j.assert_invariant(); | |
| 5525 } | |
| 5526 }; | |
| 5527 | |
| 5528 template<> | |
| 5529 struct external_constructor<value_t::array> | |
| 5530 { | |
| 5531 template<typename BasicJsonType> | |
| 5532 static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr) | |
| 5533 { | |
| 5534 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5535 j.m_data.m_type = value_t::array; | |
| 5536 j.m_data.m_value = arr; | |
| 5537 j.set_parents(); | |
| 5538 j.assert_invariant(); | |
| 5539 } | |
| 5540 | |
| 5541 template<typename BasicJsonType> | |
| 5542 static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr) | |
| 5543 { | |
| 5544 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5545 j.m_data.m_type = value_t::array; | |
| 5546 j.m_data.m_value = std::move(arr); | |
| 5547 j.set_parents(); | |
| 5548 j.assert_invariant(); | |
| 5549 } | |
| 5550 | |
| 5551 template < typename BasicJsonType, typename CompatibleArrayType, | |
| 5552 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value, | |
| 5553 int > = 0 > | |
| 5554 static void construct(BasicJsonType& j, const CompatibleArrayType& arr) | |
| 5555 { | |
| 5556 using std::begin; | |
| 5557 using std::end; | |
| 5558 | |
| 5559 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5560 j.m_data.m_type = value_t::array; | |
| 5561 j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr)); | |
| 5562 j.set_parents(); | |
| 5563 j.assert_invariant(); | |
| 5564 } | |
| 5565 | |
| 5566 template<typename BasicJsonType> | |
| 5567 static void construct(BasicJsonType& j, const std::vector<bool>& arr) | |
| 5568 { | |
| 5569 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5570 j.m_data.m_type = value_t::array; | |
| 5571 j.m_data.m_value = value_t::array; | |
| 5572 j.m_data.m_value.array->reserve(arr.size()); | |
| 5573 for (const bool x : arr) | |
| 5574 { | |
| 5575 j.m_data.m_value.array->push_back(x); | |
| 5576 j.set_parent(j.m_data.m_value.array->back()); | |
| 5577 } | |
| 5578 j.assert_invariant(); | |
| 5579 } | |
| 5580 | |
| 5581 template<typename BasicJsonType, typename T, | |
| 5582 enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0> | |
| 5583 static void construct(BasicJsonType& j, const std::valarray<T>& arr) | |
| 5584 { | |
| 5585 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5586 j.m_data.m_type = value_t::array; | |
| 5587 j.m_data.m_value = value_t::array; | |
| 5588 j.m_data.m_value.array->resize(arr.size()); | |
| 5589 if (arr.size() > 0) | |
| 5590 { | |
| 5591 std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin()); | |
| 5592 } | |
| 5593 j.set_parents(); | |
| 5594 j.assert_invariant(); | |
| 5595 } | |
| 5596 }; | |
| 5597 | |
| 5598 template<> | |
| 5599 struct external_constructor<value_t::object> | |
| 5600 { | |
| 5601 template<typename BasicJsonType> | |
| 5602 static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj) | |
| 5603 { | |
| 5604 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5605 j.m_data.m_type = value_t::object; | |
| 5606 j.m_data.m_value = obj; | |
| 5607 j.set_parents(); | |
| 5608 j.assert_invariant(); | |
| 5609 } | |
| 5610 | |
| 5611 template<typename BasicJsonType> | |
| 5612 static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj) | |
| 5613 { | |
| 5614 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5615 j.m_data.m_type = value_t::object; | |
| 5616 j.m_data.m_value = std::move(obj); | |
| 5617 j.set_parents(); | |
| 5618 j.assert_invariant(); | |
| 5619 } | |
| 5620 | |
| 5621 template < typename BasicJsonType, typename CompatibleObjectType, | |
| 5622 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 > | |
| 5623 static void construct(BasicJsonType& j, const CompatibleObjectType& obj) | |
| 5624 { | |
| 5625 using std::begin; | |
| 5626 using std::end; | |
| 5627 | |
| 5628 j.m_data.m_value.destroy(j.m_data.m_type); | |
| 5629 j.m_data.m_type = value_t::object; | |
| 5630 j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj)); | |
| 5631 j.set_parents(); | |
| 5632 j.assert_invariant(); | |
| 5633 } | |
| 5634 }; | |
| 5635 | |
| 5636 ///////////// | |
| 5637 // to_json // | |
| 5638 ///////////// | |
| 5639 | |
| 5640 template<typename BasicJsonType, typename T, | |
| 5641 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0> | |
| 5642 inline void to_json(BasicJsonType& j, T b) noexcept | |
| 5643 { | |
| 5644 external_constructor<value_t::boolean>::construct(j, b); | |
| 5645 } | |
| 5646 | |
| 5647 template < typename BasicJsonType, typename BoolRef, | |
| 5648 enable_if_t < | |
| 5649 ((std::is_same<std::vector<bool>::reference, BoolRef>::value | |
| 5650 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value) | |
| 5651 || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value | |
| 5652 && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>, | |
| 5653 typename BasicJsonType::boolean_t >::value)) | |
| 5654 && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 > | |
| 5655 inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept | |
| 5656 { | |
| 5657 external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b)); | |
| 5658 } | |
| 5659 | |
| 5660 template<typename BasicJsonType, typename CompatibleString, | |
| 5661 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0> | |
| 5662 inline void to_json(BasicJsonType& j, const CompatibleString& s) | |
| 5663 { | |
| 5664 external_constructor<value_t::string>::construct(j, s); | |
| 5665 } | |
| 5666 | |
| 5667 template<typename BasicJsonType> | |
| 5668 inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s) | |
| 5669 { | |
| 5670 external_constructor<value_t::string>::construct(j, std::move(s)); | |
| 5671 } | |
| 5672 | |
| 5673 template<typename BasicJsonType, typename FloatType, | |
| 5674 enable_if_t<std::is_floating_point<FloatType>::value, int> = 0> | |
| 5675 inline void to_json(BasicJsonType& j, FloatType val) noexcept | |
| 5676 { | |
| 5677 external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val)); | |
| 5678 } | |
| 5679 | |
| 5680 template<typename BasicJsonType, typename CompatibleNumberUnsignedType, | |
| 5681 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0> | |
| 5682 inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept | |
| 5683 { | |
| 5684 external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val)); | |
| 5685 } | |
| 5686 | |
| 5687 template<typename BasicJsonType, typename CompatibleNumberIntegerType, | |
| 5688 enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0> | |
| 5689 inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept | |
| 5690 { | |
| 5691 external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val)); | |
| 5692 } | |
| 5693 | |
| 5694 #if !JSON_DISABLE_ENUM_SERIALIZATION | |
| 5695 template<typename BasicJsonType, typename EnumType, | |
| 5696 enable_if_t<std::is_enum<EnumType>::value, int> = 0> | |
| 5697 inline void to_json(BasicJsonType& j, EnumType e) noexcept | |
| 5698 { | |
| 5699 using underlying_type = typename std::underlying_type<EnumType>::type; | |
| 5700 external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e)); | |
| 5701 } | |
| 5702 #endif // JSON_DISABLE_ENUM_SERIALIZATION | |
| 5703 | |
| 5704 template<typename BasicJsonType> | |
| 5705 inline void to_json(BasicJsonType& j, const std::vector<bool>& e) | |
| 5706 { | |
| 5707 external_constructor<value_t::array>::construct(j, e); | |
| 5708 } | |
| 5709 | |
| 5710 template < typename BasicJsonType, typename CompatibleArrayType, | |
| 5711 enable_if_t < is_compatible_array_type<BasicJsonType, | |
| 5712 CompatibleArrayType>::value&& | |
| 5713 !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&& | |
| 5714 !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&& | |
| 5715 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&& | |
| 5716 !is_basic_json<CompatibleArrayType>::value, | |
| 5717 int > = 0 > | |
| 5718 inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr) | |
| 5719 { | |
| 5720 external_constructor<value_t::array>::construct(j, arr); | |
| 5721 } | |
| 5722 | |
| 5723 template<typename BasicJsonType> | |
| 5724 inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin) | |
| 5725 { | |
| 5726 external_constructor<value_t::binary>::construct(j, bin); | |
| 5727 } | |
| 5728 | |
| 5729 template<typename BasicJsonType, typename T, | |
| 5730 enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0> | |
| 5731 inline void to_json(BasicJsonType& j, const std::valarray<T>& arr) | |
| 5732 { | |
| 5733 external_constructor<value_t::array>::construct(j, std::move(arr)); | |
| 5734 } | |
| 5735 | |
| 5736 template<typename BasicJsonType> | |
| 5737 inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr) | |
| 5738 { | |
| 5739 external_constructor<value_t::array>::construct(j, std::move(arr)); | |
| 5740 } | |
| 5741 | |
| 5742 template < typename BasicJsonType, typename CompatibleObjectType, | |
| 5743 enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 > | |
| 5744 inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj) | |
| 5745 { | |
| 5746 external_constructor<value_t::object>::construct(j, obj); | |
| 5747 } | |
| 5748 | |
| 5749 template<typename BasicJsonType> | |
| 5750 inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj) | |
| 5751 { | |
| 5752 external_constructor<value_t::object>::construct(j, std::move(obj)); | |
| 5753 } | |
| 5754 | |
| 5755 template < | |
| 5756 typename BasicJsonType, typename T, std::size_t N, | |
| 5757 enable_if_t < !std::is_constructible<typename BasicJsonType::string_t, | |
| 5758 const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) | |
| 5759 int > = 0 > | |
| 5760 inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) | |
| 5761 { | |
| 5762 external_constructor<value_t::array>::construct(j, arr); | |
| 5763 } | |
| 5764 | |
| 5765 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 > | |
| 5766 inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p) | |
| 5767 { | |
| 5768 j = { p.first, p.second }; | |
| 5769 } | |
| 5770 | |
| 5771 // for https://github.com/nlohmann/json/pull/1134 | |
| 5772 template<typename BasicJsonType, typename T, | |
| 5773 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0> | |
| 5774 inline void to_json(BasicJsonType& j, const T& b) | |
| 5775 { | |
| 5776 j = { {b.key(), b.value()} }; | |
| 5777 } | |
| 5778 | |
| 5779 template<typename BasicJsonType, typename Tuple, std::size_t... Idx> | |
| 5780 inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/) | |
| 5781 { | |
| 5782 j = { std::get<Idx>(t)... }; | |
| 5783 } | |
| 5784 | |
| 5785 template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0> | |
| 5786 inline void to_json(BasicJsonType& j, const T& t) | |
| 5787 { | |
| 5788 to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {}); | |
| 5789 } | |
| 5790 | |
| 5791 #if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 5792 template<typename BasicJsonType> | |
| 5793 inline void to_json(BasicJsonType& j, const std_fs::path& p) | |
| 5794 { | |
| 5795 j = p.string(); | |
| 5796 } | |
| 5797 #endif | |
| 5798 | |
| 5799 struct to_json_fn | |
| 5800 { | |
| 5801 template<typename BasicJsonType, typename T> | |
| 5802 auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val)))) | |
| 5803 -> decltype(to_json(j, std::forward<T>(val)), void()) | |
| 5804 { | |
| 5805 return to_json(j, std::forward<T>(val)); | |
| 5806 } | |
| 5807 }; | |
| 5808 } // namespace detail | |
| 5809 | |
| 5810 #ifndef JSON_HAS_CPP_17 | |
| 5811 /// namespace to hold default `to_json` function | |
| 5812 /// to see why this is required: | |
| 5813 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html | |
| 5814 namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces) | |
| 5815 { | |
| 5816 #endif | |
| 5817 JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers) | |
| 5818 detail::static_const<detail::to_json_fn>::value; | |
| 5819 #ifndef JSON_HAS_CPP_17 | |
| 5820 } // namespace | |
| 5821 #endif | |
| 5822 | |
| 5823 NLOHMANN_JSON_NAMESPACE_END | |
| 5824 | |
| 5825 // #include <nlohmann/detail/meta/identity_tag.hpp> | |
| 5826 | |
| 5827 | |
| 5828 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 5829 | |
| 5830 /// @sa https://json.nlohmann.me/api/adl_serializer/ | |
| 5831 template<typename ValueType, typename> | |
| 5832 struct adl_serializer | |
| 5833 { | |
| 5834 /// @brief convert a JSON value to any value type | |
| 5835 /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/ | |
| 5836 template<typename BasicJsonType, typename TargetType = ValueType> | |
| 5837 static auto from_json(BasicJsonType && j, TargetType& val) noexcept( | |
| 5838 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val))) | |
| 5839 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void()) | |
| 5840 { | |
| 5841 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val); | |
| 5842 } | |
| 5843 | |
| 5844 /// @brief convert a JSON value to any value type | |
| 5845 /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/ | |
| 5846 template<typename BasicJsonType, typename TargetType = ValueType> | |
| 5847 static auto from_json(BasicJsonType && j) noexcept( | |
| 5848 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))) | |
| 5849 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})) | |
| 5850 { | |
| 5851 return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}); | |
| 5852 } | |
| 5853 | |
| 5854 /// @brief convert any value type to a JSON value | |
| 5855 /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/ | |
| 5856 template<typename BasicJsonType, typename TargetType = ValueType> | |
| 5857 static auto to_json(BasicJsonType& j, TargetType && val) noexcept( | |
| 5858 noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val)))) | |
| 5859 -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void()) | |
| 5860 { | |
| 5861 ::nlohmann::to_json(j, std::forward<TargetType>(val)); | |
| 5862 } | |
| 5863 }; | |
| 5864 | |
| 5865 NLOHMANN_JSON_NAMESPACE_END | |
| 5866 | |
| 5867 // #include <nlohmann/byte_container_with_subtype.hpp> | |
| 5868 // __ _____ _____ _____ | |
| 5869 // __| | __| | | | JSON for Modern C++ | |
| 5870 // | | |__ | | | | | | version 3.11.3 | |
| 5871 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 5872 // | |
| 5873 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 5874 // SPDX-License-Identifier: MIT | |
| 5875 | |
| 5876 | |
| 5877 | |
| 5878 #include <cstdint> // uint8_t, uint64_t | |
| 5879 #include <tuple> // tie | |
| 5880 #include <utility> // move | |
| 5881 | |
| 5882 // #include <nlohmann/detail/abi_macros.hpp> | |
| 5883 | |
| 5884 | |
| 5885 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 5886 | |
| 5887 /// @brief an internal type for a backed binary type | |
| 5888 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/ | |
| 5889 template<typename BinaryType> | |
| 5890 class byte_container_with_subtype : public BinaryType | |
| 5891 { | |
| 5892 public: | |
| 5893 using container_type = BinaryType; | |
| 5894 using subtype_type = std::uint64_t; | |
| 5895 | |
| 5896 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ | |
| 5897 byte_container_with_subtype() noexcept(noexcept(container_type())) | |
| 5898 : container_type() | |
| 5899 {} | |
| 5900 | |
| 5901 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ | |
| 5902 byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b))) | |
| 5903 : container_type(b) | |
| 5904 {} | |
| 5905 | |
| 5906 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ | |
| 5907 byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b)))) | |
| 5908 : container_type(std::move(b)) | |
| 5909 {} | |
| 5910 | |
| 5911 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ | |
| 5912 byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b))) | |
| 5913 : container_type(b) | |
| 5914 , m_subtype(subtype_) | |
| 5915 , m_has_subtype(true) | |
| 5916 {} | |
| 5917 | |
| 5918 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/ | |
| 5919 byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b)))) | |
| 5920 : container_type(std::move(b)) | |
| 5921 , m_subtype(subtype_) | |
| 5922 , m_has_subtype(true) | |
| 5923 {} | |
| 5924 | |
| 5925 bool operator==(const byte_container_with_subtype& rhs) const | |
| 5926 { | |
| 5927 return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) == | |
| 5928 std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype); | |
| 5929 } | |
| 5930 | |
| 5931 bool operator!=(const byte_container_with_subtype& rhs) const | |
| 5932 { | |
| 5933 return !(rhs == *this); | |
| 5934 } | |
| 5935 | |
| 5936 /// @brief sets the binary subtype | |
| 5937 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/ | |
| 5938 void set_subtype(subtype_type subtype_) noexcept | |
| 5939 { | |
| 5940 m_subtype = subtype_; | |
| 5941 m_has_subtype = true; | |
| 5942 } | |
| 5943 | |
| 5944 /// @brief return the binary subtype | |
| 5945 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/ | |
| 5946 constexpr subtype_type subtype() const noexcept | |
| 5947 { | |
| 5948 return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1); | |
| 5949 } | |
| 5950 | |
| 5951 /// @brief return whether the value has a subtype | |
| 5952 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/ | |
| 5953 constexpr bool has_subtype() const noexcept | |
| 5954 { | |
| 5955 return m_has_subtype; | |
| 5956 } | |
| 5957 | |
| 5958 /// @brief clears the binary subtype | |
| 5959 /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/ | |
| 5960 void clear_subtype() noexcept | |
| 5961 { | |
| 5962 m_subtype = 0; | |
| 5963 m_has_subtype = false; | |
| 5964 } | |
| 5965 | |
| 5966 private: | |
| 5967 subtype_type m_subtype = 0; | |
| 5968 bool m_has_subtype = false; | |
| 5969 }; | |
| 5970 | |
| 5971 NLOHMANN_JSON_NAMESPACE_END | |
| 5972 | |
| 5973 // #include <nlohmann/detail/conversions/from_json.hpp> | |
| 5974 | |
| 5975 // #include <nlohmann/detail/conversions/to_json.hpp> | |
| 5976 | |
| 5977 // #include <nlohmann/detail/exceptions.hpp> | |
| 5978 | |
| 5979 // #include <nlohmann/detail/hash.hpp> | |
| 5980 // __ _____ _____ _____ | |
| 5981 // __| | __| | | | JSON for Modern C++ | |
| 5982 // | | |__ | | | | | | version 3.11.3 | |
| 5983 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 5984 // | |
| 5985 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 5986 // SPDX-License-Identifier: MIT | |
| 5987 | |
| 5988 | |
| 5989 | |
| 5990 #include <cstdint> // uint8_t | |
| 5991 #include <cstddef> // size_t | |
| 5992 #include <functional> // hash | |
| 5993 | |
| 5994 // #include <nlohmann/detail/abi_macros.hpp> | |
| 5995 | |
| 5996 // #include <nlohmann/detail/value_t.hpp> | |
| 5997 | |
| 5998 | |
| 5999 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 6000 namespace detail | |
| 6001 { | |
| 6002 | |
| 6003 // boost::hash_combine | |
| 6004 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept | |
| 6005 { | |
| 6006 seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U); | |
| 6007 return seed; | |
| 6008 } | |
| 6009 | |
| 6010 /*! | |
| 6011 @brief hash a JSON value | |
| 6012 | |
| 6013 The hash function tries to rely on std::hash where possible. Furthermore, the | |
| 6014 type of the JSON value is taken into account to have different hash values for | |
| 6015 null, 0, 0U, and false, etc. | |
| 6016 | |
| 6017 @tparam BasicJsonType basic_json specialization | |
| 6018 @param j JSON value to hash | |
| 6019 @return hash value of j | |
| 6020 */ | |
| 6021 template<typename BasicJsonType> | |
| 6022 std::size_t hash(const BasicJsonType& j) | |
| 6023 { | |
| 6024 using string_t = typename BasicJsonType::string_t; | |
| 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 | |
| 6029 const auto type = static_cast<std::size_t>(j.type()); | |
| 6030 switch (j.type()) | |
| 6031 { | |
| 6032 case BasicJsonType::value_t::null: | |
| 6033 case BasicJsonType::value_t::discarded: | |
| 6034 { | |
| 6035 return combine(type, 0); | |
| 6036 } | |
| 6037 | |
| 6038 case BasicJsonType::value_t::object: | |
| 6039 { | |
| 6040 auto seed = combine(type, j.size()); | |
| 6041 for (const auto& element : j.items()) | |
| 6042 { | |
| 6043 const auto h = std::hash<string_t> {}(element.key()); | |
| 6044 seed = combine(seed, h); | |
| 6045 seed = combine(seed, hash(element.value())); | |
| 6046 } | |
| 6047 return seed; | |
| 6048 } | |
| 6049 | |
| 6050 case BasicJsonType::value_t::array: | |
| 6051 { | |
| 6052 auto seed = combine(type, j.size()); | |
| 6053 for (const auto& element : j) | |
| 6054 { | |
| 6055 seed = combine(seed, hash(element)); | |
| 6056 } | |
| 6057 return seed; | |
| 6058 } | |
| 6059 | |
| 6060 case BasicJsonType::value_t::string: | |
| 6061 { | |
| 6062 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>()); | |
| 6063 return combine(type, h); | |
| 6064 } | |
| 6065 | |
| 6066 case BasicJsonType::value_t::boolean: | |
| 6067 { | |
| 6068 const auto h = std::hash<bool> {}(j.template get<bool>()); | |
| 6069 return combine(type, h); | |
| 6070 } | |
| 6071 | |
| 6072 case BasicJsonType::value_t::number_integer: | |
| 6073 { | |
| 6074 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>()); | |
| 6075 return combine(type, h); | |
| 6076 } | |
| 6077 | |
| 6078 case BasicJsonType::value_t::number_unsigned: | |
| 6079 { | |
| 6080 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>()); | |
| 6081 return combine(type, h); | |
| 6082 } | |
| 6083 | |
| 6084 case BasicJsonType::value_t::number_float: | |
| 6085 { | |
| 6086 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>()); | |
| 6087 return combine(type, h); | |
| 6088 } | |
| 6089 | |
| 6090 case BasicJsonType::value_t::binary: | |
| 6091 { | |
| 6092 auto seed = combine(type, j.get_binary().size()); | |
| 6093 const auto h = std::hash<bool> {}(j.get_binary().has_subtype()); | |
| 6094 seed = combine(seed, h); | |
| 6095 seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype())); | |
| 6096 for (const auto byte : j.get_binary()) | |
| 6097 { | |
| 6098 seed = combine(seed, std::hash<std::uint8_t> {}(byte)); | |
| 6099 } | |
| 6100 return seed; | |
| 6101 } | |
| 6102 | |
| 6103 default: // LCOV_EXCL_LINE | |
| 6104 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 6105 return 0; // LCOV_EXCL_LINE | |
| 6106 } | |
| 6107 } | |
| 6108 | |
| 6109 } // namespace detail | |
| 6110 NLOHMANN_JSON_NAMESPACE_END | |
| 6111 | |
| 6112 // #include <nlohmann/detail/input/binary_reader.hpp> | |
| 6113 // __ _____ _____ _____ | |
| 6114 // __| | __| | | | JSON for Modern C++ | |
| 6115 // | | |__ | | | | | | version 3.11.3 | |
| 6116 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 6117 // | |
| 6118 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 6119 // SPDX-License-Identifier: MIT | |
| 6120 | |
| 6121 | |
| 6122 | |
| 6123 #include <algorithm> // generate_n | |
| 6124 #include <array> // array | |
| 6125 #include <cmath> // ldexp | |
| 6126 #include <cstddef> // size_t | |
| 6127 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t | |
| 6128 #include <cstdio> // snprintf | |
| 6129 #include <cstring> // memcpy | |
| 6130 #include <iterator> // back_inserter | |
| 6131 #include <limits> // numeric_limits | |
| 6132 #include <string> // char_traits, string | |
| 6133 #include <utility> // make_pair, move | |
| 6134 #include <vector> // vector | |
| 6135 | |
| 6136 // #include <nlohmann/detail/exceptions.hpp> | |
| 6137 | |
| 6138 // #include <nlohmann/detail/input/input_adapters.hpp> | |
| 6139 // __ _____ _____ _____ | |
| 6140 // __| | __| | | | JSON for Modern C++ | |
| 6141 // | | |__ | | | | | | version 3.11.3 | |
| 6142 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 6143 // | |
| 6144 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 6145 // SPDX-License-Identifier: MIT | |
| 6146 | |
| 6147 | |
| 6148 | |
| 6149 #include <array> // array | |
| 6150 #include <cstddef> // size_t | |
| 6151 #include <cstring> // strlen | |
| 6152 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next | |
| 6153 #include <memory> // shared_ptr, make_shared, addressof | |
| 6154 #include <numeric> // accumulate | |
| 6155 #include <string> // string, char_traits | |
| 6156 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer | |
| 6157 #include <utility> // pair, declval | |
| 6158 | |
| 6159 #ifndef JSON_NO_IO | |
| 6160 #include <cstdio> // FILE * | |
| 6161 #include <istream> // istream | |
| 6162 #endif // JSON_NO_IO | |
| 6163 | |
| 6164 // #include <nlohmann/detail/iterators/iterator_traits.hpp> | |
| 6165 | |
| 6166 // #include <nlohmann/detail/macro_scope.hpp> | |
| 6167 | |
| 6168 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 6169 | |
| 6170 | |
| 6171 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 6172 namespace detail | |
| 6173 { | |
| 6174 | |
| 6175 /// the supported input formats | |
| 6176 enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata }; | |
| 6177 | |
| 6178 //////////////////// | |
| 6179 // input adapters // | |
| 6180 //////////////////// | |
| 6181 | |
| 6182 #ifndef JSON_NO_IO | |
| 6183 /*! | |
| 6184 Input adapter for stdio file access. This adapter read only 1 byte and do not use any | |
| 6185 buffer. This adapter is a very low level adapter. | |
| 6186 */ | |
| 6187 class file_input_adapter | |
| 6188 { | |
| 6189 public: | |
| 6190 using char_type = char; | |
| 6191 | |
| 6192 JSON_HEDLEY_NON_NULL(2) | |
| 6193 explicit file_input_adapter(std::FILE* f) noexcept | |
| 6194 : m_file(f) | |
| 6195 { | |
| 6196 JSON_ASSERT(m_file != nullptr); | |
| 6197 } | |
| 6198 | |
| 6199 // make class move-only | |
| 6200 file_input_adapter(const file_input_adapter&) = delete; | |
| 6201 file_input_adapter(file_input_adapter&&) noexcept = default; | |
| 6202 file_input_adapter& operator=(const file_input_adapter&) = delete; | |
| 6203 file_input_adapter& operator=(file_input_adapter&&) = delete; | |
| 6204 ~file_input_adapter() = default; | |
| 6205 | |
| 6206 std::char_traits<char>::int_type get_character() noexcept | |
| 6207 { | |
| 6208 return std::fgetc(m_file); | |
| 6209 } | |
| 6210 | |
| 6211 private: | |
| 6212 /// the file pointer to read from | |
| 6213 std::FILE* m_file; | |
| 6214 }; | |
| 6215 | |
| 6216 /*! | |
| 6217 Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at | |
| 6218 beginning of input. Does not support changing the underlying std::streambuf | |
| 6219 in mid-input. Maintains underlying std::istream and std::streambuf to support | |
| 6220 subsequent use of standard std::istream operations to process any input | |
| 6221 characters following those used in parsing the JSON input. Clears the | |
| 6222 std::istream flags; any input errors (e.g., EOF) will be detected by the first | |
| 6223 subsequent call for input from the std::istream. | |
| 6224 */ | |
| 6225 class input_stream_adapter | |
| 6226 { | |
| 6227 public: | |
| 6228 using char_type = char; | |
| 6229 | |
| 6230 ~input_stream_adapter() | |
| 6231 { | |
| 6232 // clear stream flags; we use underlying streambuf I/O, do not | |
| 6233 // maintain ifstream flags, except eof | |
| 6234 if (is != nullptr) | |
| 6235 { | |
| 6236 is->clear(is->rdstate() & std::ios::eofbit); | |
| 6237 } | |
| 6238 } | |
| 6239 | |
| 6240 explicit input_stream_adapter(std::istream& i) | |
| 6241 : is(&i), sb(i.rdbuf()) | |
| 6242 {} | |
| 6243 | |
| 6244 // delete because of pointer members | |
| 6245 input_stream_adapter(const input_stream_adapter&) = delete; | |
| 6246 input_stream_adapter& operator=(input_stream_adapter&) = delete; | |
| 6247 input_stream_adapter& operator=(input_stream_adapter&&) = delete; | |
| 6248 | |
| 6249 input_stream_adapter(input_stream_adapter&& rhs) noexcept | |
| 6250 : is(rhs.is), sb(rhs.sb) | |
| 6251 { | |
| 6252 rhs.is = nullptr; | |
| 6253 rhs.sb = nullptr; | |
| 6254 } | |
| 6255 | |
| 6256 // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to | |
| 6257 // ensure that std::char_traits<char>::eof() and the character 0xFF do not | |
| 6258 // end up as the same value, e.g. 0xFFFFFFFF. | |
| 6259 std::char_traits<char>::int_type get_character() | |
| 6260 { | |
| 6261 auto res = sb->sbumpc(); | |
| 6262 // set eof manually, as we don't use the istream interface. | |
| 6263 if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof())) | |
| 6264 { | |
| 6265 is->clear(is->rdstate() | std::ios::eofbit); | |
| 6266 } | |
| 6267 return res; | |
| 6268 } | |
| 6269 | |
| 6270 private: | |
| 6271 /// the associated input stream | |
| 6272 std::istream* is = nullptr; | |
| 6273 std::streambuf* sb = nullptr; | |
| 6274 }; | |
| 6275 #endif // JSON_NO_IO | |
| 6276 | |
| 6277 // General-purpose iterator-based adapter. It might not be as fast as | |
| 6278 // theoretically possible for some containers, but it is extremely versatile. | |
| 6279 template<typename IteratorType> | |
| 6280 class iterator_input_adapter | |
| 6281 { | |
| 6282 public: | |
| 6283 using char_type = typename std::iterator_traits<IteratorType>::value_type; | |
| 6284 | |
| 6285 iterator_input_adapter(IteratorType first, IteratorType last) | |
| 6286 : current(std::move(first)), end(std::move(last)) | |
| 6287 {} | |
| 6288 | |
| 6289 typename char_traits<char_type>::int_type get_character() | |
| 6290 { | |
| 6291 if (JSON_HEDLEY_LIKELY(current != end)) | |
| 6292 { | |
| 6293 auto result = char_traits<char_type>::to_int_type(*current); | |
| 6294 std::advance(current, 1); | |
| 6295 return result; | |
| 6296 } | |
| 6297 | |
| 6298 return char_traits<char_type>::eof(); | |
| 6299 } | |
| 6300 | |
| 6301 private: | |
| 6302 IteratorType current; | |
| 6303 IteratorType end; | |
| 6304 | |
| 6305 template<typename BaseInputAdapter, size_t T> | |
| 6306 friend struct wide_string_input_helper; | |
| 6307 | |
| 6308 bool empty() const | |
| 6309 { | |
| 6310 return current == end; | |
| 6311 } | |
| 6312 }; | |
| 6313 | |
| 6314 template<typename BaseInputAdapter, size_t T> | |
| 6315 struct wide_string_input_helper; | |
| 6316 | |
| 6317 template<typename BaseInputAdapter> | |
| 6318 struct wide_string_input_helper<BaseInputAdapter, 4> | |
| 6319 { | |
| 6320 // UTF-32 | |
| 6321 static void fill_buffer(BaseInputAdapter& input, | |
| 6322 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, | |
| 6323 size_t& utf8_bytes_index, | |
| 6324 size_t& utf8_bytes_filled) | |
| 6325 { | |
| 6326 utf8_bytes_index = 0; | |
| 6327 | |
| 6328 if (JSON_HEDLEY_UNLIKELY(input.empty())) | |
| 6329 { | |
| 6330 utf8_bytes[0] = std::char_traits<char>::eof(); | |
| 6331 utf8_bytes_filled = 1; | |
| 6332 } | |
| 6333 else | |
| 6334 { | |
| 6335 // get the current character | |
| 6336 const auto wc = input.get_character(); | |
| 6337 | |
| 6338 // UTF-32 to UTF-8 encoding | |
| 6339 if (wc < 0x80) | |
| 6340 { | |
| 6341 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc); | |
| 6342 utf8_bytes_filled = 1; | |
| 6343 } | |
| 6344 else if (wc <= 0x7FF) | |
| 6345 { | |
| 6346 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu)); | |
| 6347 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu)); | |
| 6348 utf8_bytes_filled = 2; | |
| 6349 } | |
| 6350 else if (wc <= 0xFFFF) | |
| 6351 { | |
| 6352 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu)); | |
| 6353 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu)); | |
| 6354 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu)); | |
| 6355 utf8_bytes_filled = 3; | |
| 6356 } | |
| 6357 else if (wc <= 0x10FFFF) | |
| 6358 { | |
| 6359 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u)); | |
| 6360 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu)); | |
| 6361 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu)); | |
| 6362 utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu)); | |
| 6363 utf8_bytes_filled = 4; | |
| 6364 } | |
| 6365 else | |
| 6366 { | |
| 6367 // unknown character | |
| 6368 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc); | |
| 6369 utf8_bytes_filled = 1; | |
| 6370 } | |
| 6371 } | |
| 6372 } | |
| 6373 }; | |
| 6374 | |
| 6375 template<typename BaseInputAdapter> | |
| 6376 struct wide_string_input_helper<BaseInputAdapter, 2> | |
| 6377 { | |
| 6378 // UTF-16 | |
| 6379 static void fill_buffer(BaseInputAdapter& input, | |
| 6380 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes, | |
| 6381 size_t& utf8_bytes_index, | |
| 6382 size_t& utf8_bytes_filled) | |
| 6383 { | |
| 6384 utf8_bytes_index = 0; | |
| 6385 | |
| 6386 if (JSON_HEDLEY_UNLIKELY(input.empty())) | |
| 6387 { | |
| 6388 utf8_bytes[0] = std::char_traits<char>::eof(); | |
| 6389 utf8_bytes_filled = 1; | |
| 6390 } | |
| 6391 else | |
| 6392 { | |
| 6393 // get the current character | |
| 6394 const auto wc = input.get_character(); | |
| 6395 | |
| 6396 // UTF-16 to UTF-8 encoding | |
| 6397 if (wc < 0x80) | |
| 6398 { | |
| 6399 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc); | |
| 6400 utf8_bytes_filled = 1; | |
| 6401 } | |
| 6402 else if (wc <= 0x7FF) | |
| 6403 { | |
| 6404 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u))); | |
| 6405 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu)); | |
| 6406 utf8_bytes_filled = 2; | |
| 6407 } | |
| 6408 else if (0xD800 > wc || wc >= 0xE000) | |
| 6409 { | |
| 6410 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u))); | |
| 6411 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu)); | |
| 6412 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu)); | |
| 6413 utf8_bytes_filled = 3; | |
| 6414 } | |
| 6415 else | |
| 6416 { | |
| 6417 if (JSON_HEDLEY_UNLIKELY(!input.empty())) | |
| 6418 { | |
| 6419 const auto wc2 = static_cast<unsigned int>(input.get_character()); | |
| 6420 const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu)); | |
| 6421 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u)); | |
| 6422 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu)); | |
| 6423 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu)); | |
| 6424 utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu)); | |
| 6425 utf8_bytes_filled = 4; | |
| 6426 } | |
| 6427 else | |
| 6428 { | |
| 6429 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc); | |
| 6430 utf8_bytes_filled = 1; | |
| 6431 } | |
| 6432 } | |
| 6433 } | |
| 6434 } | |
| 6435 }; | |
| 6436 | |
| 6437 // Wraps another input adapter to convert wide character types into individual bytes. | |
| 6438 template<typename BaseInputAdapter, typename WideCharType> | |
| 6439 class wide_string_input_adapter | |
| 6440 { | |
| 6441 public: | |
| 6442 using char_type = char; | |
| 6443 | |
| 6444 wide_string_input_adapter(BaseInputAdapter base) | |
| 6445 : base_adapter(base) {} | |
| 6446 | |
| 6447 typename std::char_traits<char>::int_type get_character() noexcept | |
| 6448 { | |
| 6449 // check if buffer needs to be filled | |
| 6450 if (utf8_bytes_index == utf8_bytes_filled) | |
| 6451 { | |
| 6452 fill_buffer<sizeof(WideCharType)>(); | |
| 6453 | |
| 6454 JSON_ASSERT(utf8_bytes_filled > 0); | |
| 6455 JSON_ASSERT(utf8_bytes_index == 0); | |
| 6456 } | |
| 6457 | |
| 6458 // use buffer | |
| 6459 JSON_ASSERT(utf8_bytes_filled > 0); | |
| 6460 JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled); | |
| 6461 return utf8_bytes[utf8_bytes_index++]; | |
| 6462 } | |
| 6463 | |
| 6464 private: | |
| 6465 BaseInputAdapter base_adapter; | |
| 6466 | |
| 6467 template<size_t T> | |
| 6468 void fill_buffer() | |
| 6469 { | |
| 6470 wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled); | |
| 6471 } | |
| 6472 | |
| 6473 /// a buffer for UTF-8 bytes | |
| 6474 std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}}; | |
| 6475 | |
| 6476 /// index to the utf8_codes array for the next valid byte | |
| 6477 std::size_t utf8_bytes_index = 0; | |
| 6478 /// number of valid bytes in the utf8_codes array | |
| 6479 std::size_t utf8_bytes_filled = 0; | |
| 6480 }; | |
| 6481 | |
| 6482 template<typename IteratorType, typename Enable = void> | |
| 6483 struct iterator_input_adapter_factory | |
| 6484 { | |
| 6485 using iterator_type = IteratorType; | |
| 6486 using char_type = typename std::iterator_traits<iterator_type>::value_type; | |
| 6487 using adapter_type = iterator_input_adapter<iterator_type>; | |
| 6488 | |
| 6489 static adapter_type create(IteratorType first, IteratorType last) | |
| 6490 { | |
| 6491 return adapter_type(std::move(first), std::move(last)); | |
| 6492 } | |
| 6493 }; | |
| 6494 | |
| 6495 template<typename T> | |
| 6496 struct is_iterator_of_multibyte | |
| 6497 { | |
| 6498 using value_type = typename std::iterator_traits<T>::value_type; | |
| 6499 enum | |
| 6500 { | |
| 6501 value = sizeof(value_type) > 1 | |
| 6502 }; | |
| 6503 }; | |
| 6504 | |
| 6505 template<typename IteratorType> | |
| 6506 struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>> | |
| 6507 { | |
| 6508 using iterator_type = IteratorType; | |
| 6509 using char_type = typename std::iterator_traits<iterator_type>::value_type; | |
| 6510 using base_adapter_type = iterator_input_adapter<iterator_type>; | |
| 6511 using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>; | |
| 6512 | |
| 6513 static adapter_type create(IteratorType first, IteratorType last) | |
| 6514 { | |
| 6515 return adapter_type(base_adapter_type(std::move(first), std::move(last))); | |
| 6516 } | |
| 6517 }; | |
| 6518 | |
| 6519 // General purpose iterator-based input | |
| 6520 template<typename IteratorType> | |
| 6521 typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last) | |
| 6522 { | |
| 6523 using factory_type = iterator_input_adapter_factory<IteratorType>; | |
| 6524 return factory_type::create(first, last); | |
| 6525 } | |
| 6526 | |
| 6527 // Convenience shorthand from container to iterator | |
| 6528 // Enables ADL on begin(container) and end(container) | |
| 6529 // Encloses the using declarations in namespace for not to leak them to outside scope | |
| 6530 | |
| 6531 namespace container_input_adapter_factory_impl | |
| 6532 { | |
| 6533 | |
| 6534 using std::begin; | |
| 6535 using std::end; | |
| 6536 | |
| 6537 template<typename ContainerType, typename Enable = void> | |
| 6538 struct container_input_adapter_factory {}; | |
| 6539 | |
| 6540 template<typename ContainerType> | |
| 6541 struct container_input_adapter_factory< ContainerType, | |
| 6542 void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>> | |
| 6543 { | |
| 6544 using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))); | |
| 6545 | |
| 6546 static adapter_type create(const ContainerType& container) | |
| 6547 { | |
| 6548 return input_adapter(begin(container), end(container)); | |
| 6549 } | |
| 6550 }; | |
| 6551 | |
| 6552 } // namespace container_input_adapter_factory_impl | |
| 6553 | |
| 6554 template<typename ContainerType> | |
| 6555 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container) | |
| 6556 { | |
| 6557 return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container); | |
| 6558 } | |
| 6559 | |
| 6560 #ifndef JSON_NO_IO | |
| 6561 // Special cases with fast paths | |
| 6562 inline file_input_adapter input_adapter(std::FILE* file) | |
| 6563 { | |
| 6564 return file_input_adapter(file); | |
| 6565 } | |
| 6566 | |
| 6567 inline input_stream_adapter input_adapter(std::istream& stream) | |
| 6568 { | |
| 6569 return input_stream_adapter(stream); | |
| 6570 } | |
| 6571 | |
| 6572 inline input_stream_adapter input_adapter(std::istream&& stream) | |
| 6573 { | |
| 6574 return input_stream_adapter(stream); | |
| 6575 } | |
| 6576 #endif // JSON_NO_IO | |
| 6577 | |
| 6578 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>())); | |
| 6579 | |
| 6580 // Null-delimited strings, and the like. | |
| 6581 template < typename CharT, | |
| 6582 typename std::enable_if < | |
| 6583 std::is_pointer<CharT>::value&& | |
| 6584 !std::is_array<CharT>::value&& | |
| 6585 std::is_integral<typename std::remove_pointer<CharT>::type>::value&& | |
| 6586 sizeof(typename std::remove_pointer<CharT>::type) == 1, | |
| 6587 int >::type = 0 > | |
| 6588 contiguous_bytes_input_adapter input_adapter(CharT b) | |
| 6589 { | |
| 6590 auto length = std::strlen(reinterpret_cast<const char*>(b)); | |
| 6591 const auto* ptr = reinterpret_cast<const char*>(b); | |
| 6592 return input_adapter(ptr, ptr + length); | |
| 6593 } | |
| 6594 | |
| 6595 template<typename T, std::size_t N> | |
| 6596 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) | |
| 6597 { | |
| 6598 return input_adapter(array, array + N); | |
| 6599 } | |
| 6600 | |
| 6601 // This class only handles inputs of input_buffer_adapter type. | |
| 6602 // It's required so that expressions like {ptr, len} can be implicitly cast | |
| 6603 // to the correct adapter. | |
| 6604 class span_input_adapter | |
| 6605 { | |
| 6606 public: | |
| 6607 template < typename CharT, | |
| 6608 typename std::enable_if < | |
| 6609 std::is_pointer<CharT>::value&& | |
| 6610 std::is_integral<typename std::remove_pointer<CharT>::type>::value&& | |
| 6611 sizeof(typename std::remove_pointer<CharT>::type) == 1, | |
| 6612 int >::type = 0 > | |
| 6613 span_input_adapter(CharT b, std::size_t l) | |
| 6614 : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {} | |
| 6615 | |
| 6616 template<class IteratorType, | |
| 6617 typename std::enable_if< | |
| 6618 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value, | |
| 6619 int>::type = 0> | |
| 6620 span_input_adapter(IteratorType first, IteratorType last) | |
| 6621 : ia(input_adapter(first, last)) {} | |
| 6622 | |
| 6623 contiguous_bytes_input_adapter&& get() | |
| 6624 { | |
| 6625 return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg) | |
| 6626 } | |
| 6627 | |
| 6628 private: | |
| 6629 contiguous_bytes_input_adapter ia; | |
| 6630 }; | |
| 6631 | |
| 6632 } // namespace detail | |
| 6633 NLOHMANN_JSON_NAMESPACE_END | |
| 6634 | |
| 6635 // #include <nlohmann/detail/input/json_sax.hpp> | |
| 6636 // __ _____ _____ _____ | |
| 6637 // __| | __| | | | JSON for Modern C++ | |
| 6638 // | | |__ | | | | | | version 3.11.3 | |
| 6639 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 6640 // | |
| 6641 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 6642 // SPDX-License-Identifier: MIT | |
| 6643 | |
| 6644 | |
| 6645 | |
| 6646 #include <cstddef> | |
| 6647 #include <string> // string | |
| 6648 #include <utility> // move | |
| 6649 #include <vector> // vector | |
| 6650 | |
| 6651 // #include <nlohmann/detail/exceptions.hpp> | |
| 6652 | |
| 6653 // #include <nlohmann/detail/macro_scope.hpp> | |
| 6654 | |
| 6655 // #include <nlohmann/detail/string_concat.hpp> | |
| 6656 | |
| 6657 | |
| 6658 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 6659 | |
| 6660 /*! | |
| 6661 @brief SAX interface | |
| 6662 | |
| 6663 This class describes the SAX interface used by @ref nlohmann::json::sax_parse. | |
| 6664 Each function is called in different situations while the input is parsed. The | |
| 6665 boolean return value informs the parser whether to continue processing the | |
| 6666 input. | |
| 6667 */ | |
| 6668 template<typename BasicJsonType> | |
| 6669 struct json_sax | |
| 6670 { | |
| 6671 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 6672 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 6673 using number_float_t = typename BasicJsonType::number_float_t; | |
| 6674 using string_t = typename BasicJsonType::string_t; | |
| 6675 using binary_t = typename BasicJsonType::binary_t; | |
| 6676 | |
| 6677 /*! | |
| 6678 @brief a null value was read | |
| 6679 @return whether parsing should proceed | |
| 6680 */ | |
| 6681 virtual bool null() = 0; | |
| 6682 | |
| 6683 /*! | |
| 6684 @brief a boolean value was read | |
| 6685 @param[in] val boolean value | |
| 6686 @return whether parsing should proceed | |
| 6687 */ | |
| 6688 virtual bool boolean(bool val) = 0; | |
| 6689 | |
| 6690 /*! | |
| 6691 @brief an integer number was read | |
| 6692 @param[in] val integer value | |
| 6693 @return whether parsing should proceed | |
| 6694 */ | |
| 6695 virtual bool number_integer(number_integer_t val) = 0; | |
| 6696 | |
| 6697 /*! | |
| 6698 @brief an unsigned integer number was read | |
| 6699 @param[in] val unsigned integer value | |
| 6700 @return whether parsing should proceed | |
| 6701 */ | |
| 6702 virtual bool number_unsigned(number_unsigned_t val) = 0; | |
| 6703 | |
| 6704 /*! | |
| 6705 @brief a floating-point number was read | |
| 6706 @param[in] val floating-point value | |
| 6707 @param[in] s raw token value | |
| 6708 @return whether parsing should proceed | |
| 6709 */ | |
| 6710 virtual bool number_float(number_float_t val, const string_t& s) = 0; | |
| 6711 | |
| 6712 /*! | |
| 6713 @brief a string value was read | |
| 6714 @param[in] val string value | |
| 6715 @return whether parsing should proceed | |
| 6716 @note It is safe to move the passed string value. | |
| 6717 */ | |
| 6718 virtual bool string(string_t& val) = 0; | |
| 6719 | |
| 6720 /*! | |
| 6721 @brief a binary value was read | |
| 6722 @param[in] val binary value | |
| 6723 @return whether parsing should proceed | |
| 6724 @note It is safe to move the passed binary value. | |
| 6725 */ | |
| 6726 virtual bool binary(binary_t& val) = 0; | |
| 6727 | |
| 6728 /*! | |
| 6729 @brief the beginning of an object was read | |
| 6730 @param[in] elements number of object elements or -1 if unknown | |
| 6731 @return whether parsing should proceed | |
| 6732 @note binary formats may report the number of elements | |
| 6733 */ | |
| 6734 virtual bool start_object(std::size_t elements) = 0; | |
| 6735 | |
| 6736 /*! | |
| 6737 @brief an object key was read | |
| 6738 @param[in] val object key | |
| 6739 @return whether parsing should proceed | |
| 6740 @note It is safe to move the passed string. | |
| 6741 */ | |
| 6742 virtual bool key(string_t& val) = 0; | |
| 6743 | |
| 6744 /*! | |
| 6745 @brief the end of an object was read | |
| 6746 @return whether parsing should proceed | |
| 6747 */ | |
| 6748 virtual bool end_object() = 0; | |
| 6749 | |
| 6750 /*! | |
| 6751 @brief the beginning of an array was read | |
| 6752 @param[in] elements number of array elements or -1 if unknown | |
| 6753 @return whether parsing should proceed | |
| 6754 @note binary formats may report the number of elements | |
| 6755 */ | |
| 6756 virtual bool start_array(std::size_t elements) = 0; | |
| 6757 | |
| 6758 /*! | |
| 6759 @brief the end of an array was read | |
| 6760 @return whether parsing should proceed | |
| 6761 */ | |
| 6762 virtual bool end_array() = 0; | |
| 6763 | |
| 6764 /*! | |
| 6765 @brief a parse error occurred | |
| 6766 @param[in] position the position in the input where the error occurs | |
| 6767 @param[in] last_token the last read token | |
| 6768 @param[in] ex an exception object describing the error | |
| 6769 @return whether parsing should proceed (must return false) | |
| 6770 */ | |
| 6771 virtual bool parse_error(std::size_t position, | |
| 6772 const std::string& last_token, | |
| 6773 const detail::exception& ex) = 0; | |
| 6774 | |
| 6775 json_sax() = default; | |
| 6776 json_sax(const json_sax&) = default; | |
| 6777 json_sax(json_sax&&) noexcept = default; | |
| 6778 json_sax& operator=(const json_sax&) = default; | |
| 6779 json_sax& operator=(json_sax&&) noexcept = default; | |
| 6780 virtual ~json_sax() = default; | |
| 6781 }; | |
| 6782 | |
| 6783 namespace detail | |
| 6784 { | |
| 6785 /*! | |
| 6786 @brief SAX implementation to create a JSON value from SAX events | |
| 6787 | |
| 6788 This class implements the @ref json_sax interface and processes the SAX events | |
| 6789 to create a JSON value which makes it basically a DOM parser. The structure or | |
| 6790 hierarchy of the JSON value is managed by the stack `ref_stack` which contains | |
| 6791 a pointer to the respective array or object for each recursion depth. | |
| 6792 | |
| 6793 After successful parsing, the value that is passed by reference to the | |
| 6794 constructor contains the parsed value. | |
| 6795 | |
| 6796 @tparam BasicJsonType the JSON type | |
| 6797 */ | |
| 6798 template<typename BasicJsonType> | |
| 6799 class json_sax_dom_parser | |
| 6800 { | |
| 6801 public: | |
| 6802 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 6803 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 6804 using number_float_t = typename BasicJsonType::number_float_t; | |
| 6805 using string_t = typename BasicJsonType::string_t; | |
| 6806 using binary_t = typename BasicJsonType::binary_t; | |
| 6807 | |
| 6808 /*! | |
| 6809 @param[in,out] r reference to a JSON value that is manipulated while | |
| 6810 parsing | |
| 6811 @param[in] allow_exceptions_ whether parse errors yield exceptions | |
| 6812 */ | |
| 6813 explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true) | |
| 6814 : root(r), allow_exceptions(allow_exceptions_) | |
| 6815 {} | |
| 6816 | |
| 6817 // make class move-only | |
| 6818 json_sax_dom_parser(const json_sax_dom_parser&) = delete; | |
| 6819 json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 6820 json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete; | |
| 6821 json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 6822 ~json_sax_dom_parser() = default; | |
| 6823 | |
| 6824 bool null() | |
| 6825 { | |
| 6826 handle_value(nullptr); | |
| 6827 return true; | |
| 6828 } | |
| 6829 | |
| 6830 bool boolean(bool val) | |
| 6831 { | |
| 6832 handle_value(val); | |
| 6833 return true; | |
| 6834 } | |
| 6835 | |
| 6836 bool number_integer(number_integer_t val) | |
| 6837 { | |
| 6838 handle_value(val); | |
| 6839 return true; | |
| 6840 } | |
| 6841 | |
| 6842 bool number_unsigned(number_unsigned_t val) | |
| 6843 { | |
| 6844 handle_value(val); | |
| 6845 return true; | |
| 6846 } | |
| 6847 | |
| 6848 bool number_float(number_float_t val, const string_t& /*unused*/) | |
| 6849 { | |
| 6850 handle_value(val); | |
| 6851 return true; | |
| 6852 } | |
| 6853 | |
| 6854 bool string(string_t& val) | |
| 6855 { | |
| 6856 handle_value(val); | |
| 6857 return true; | |
| 6858 } | |
| 6859 | |
| 6860 bool binary(binary_t& val) | |
| 6861 { | |
| 6862 handle_value(std::move(val)); | |
| 6863 return true; | |
| 6864 } | |
| 6865 | |
| 6866 bool start_object(std::size_t len) | |
| 6867 { | |
| 6868 ref_stack.push_back(handle_value(BasicJsonType::value_t::object)); | |
| 6869 | |
| 6870 if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size())) | |
| 6871 { | |
| 6872 JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back())); | |
| 6873 } | |
| 6874 | |
| 6875 return true; | |
| 6876 } | |
| 6877 | |
| 6878 bool key(string_t& val) | |
| 6879 { | |
| 6880 JSON_ASSERT(!ref_stack.empty()); | |
| 6881 JSON_ASSERT(ref_stack.back()->is_object()); | |
| 6882 | |
| 6883 // add null at given key and store the reference for later | |
| 6884 object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val)); | |
| 6885 return true; | |
| 6886 } | |
| 6887 | |
| 6888 bool end_object() | |
| 6889 { | |
| 6890 JSON_ASSERT(!ref_stack.empty()); | |
| 6891 JSON_ASSERT(ref_stack.back()->is_object()); | |
| 6892 | |
| 6893 ref_stack.back()->set_parents(); | |
| 6894 ref_stack.pop_back(); | |
| 6895 return true; | |
| 6896 } | |
| 6897 | |
| 6898 bool start_array(std::size_t len) | |
| 6899 { | |
| 6900 ref_stack.push_back(handle_value(BasicJsonType::value_t::array)); | |
| 6901 | |
| 6902 if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size())) | |
| 6903 { | |
| 6904 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back())); | |
| 6905 } | |
| 6906 | |
| 6907 return true; | |
| 6908 } | |
| 6909 | |
| 6910 bool end_array() | |
| 6911 { | |
| 6912 JSON_ASSERT(!ref_stack.empty()); | |
| 6913 JSON_ASSERT(ref_stack.back()->is_array()); | |
| 6914 | |
| 6915 ref_stack.back()->set_parents(); | |
| 6916 ref_stack.pop_back(); | |
| 6917 return true; | |
| 6918 } | |
| 6919 | |
| 6920 template<class Exception> | |
| 6921 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, | |
| 6922 const Exception& ex) | |
| 6923 { | |
| 6924 errored = true; | |
| 6925 static_cast<void>(ex); | |
| 6926 if (allow_exceptions) | |
| 6927 { | |
| 6928 JSON_THROW(ex); | |
| 6929 } | |
| 6930 return false; | |
| 6931 } | |
| 6932 | |
| 6933 constexpr bool is_errored() const | |
| 6934 { | |
| 6935 return errored; | |
| 6936 } | |
| 6937 | |
| 6938 private: | |
| 6939 /*! | |
| 6940 @invariant If the ref stack is empty, then the passed value will be the new | |
| 6941 root. | |
| 6942 @invariant If the ref stack contains a value, then it is an array or an | |
| 6943 object to which we can add elements | |
| 6944 */ | |
| 6945 template<typename Value> | |
| 6946 JSON_HEDLEY_RETURNS_NON_NULL | |
| 6947 BasicJsonType* handle_value(Value&& v) | |
| 6948 { | |
| 6949 if (ref_stack.empty()) | |
| 6950 { | |
| 6951 root = BasicJsonType(std::forward<Value>(v)); | |
| 6952 return &root; | |
| 6953 } | |
| 6954 | |
| 6955 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); | |
| 6956 | |
| 6957 if (ref_stack.back()->is_array()) | |
| 6958 { | |
| 6959 ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v)); | |
| 6960 return &(ref_stack.back()->m_data.m_value.array->back()); | |
| 6961 } | |
| 6962 | |
| 6963 JSON_ASSERT(ref_stack.back()->is_object()); | |
| 6964 JSON_ASSERT(object_element); | |
| 6965 *object_element = BasicJsonType(std::forward<Value>(v)); | |
| 6966 return object_element; | |
| 6967 } | |
| 6968 | |
| 6969 /// the parsed JSON value | |
| 6970 BasicJsonType& root; | |
| 6971 /// stack to model hierarchy of values | |
| 6972 std::vector<BasicJsonType*> ref_stack {}; | |
| 6973 /// helper to hold the reference for the next object element | |
| 6974 BasicJsonType* object_element = nullptr; | |
| 6975 /// whether a syntax error occurred | |
| 6976 bool errored = false; | |
| 6977 /// whether to throw exceptions in case of errors | |
| 6978 const bool allow_exceptions = true; | |
| 6979 }; | |
| 6980 | |
| 6981 template<typename BasicJsonType> | |
| 6982 class json_sax_dom_callback_parser | |
| 6983 { | |
| 6984 public: | |
| 6985 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 6986 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 6987 using number_float_t = typename BasicJsonType::number_float_t; | |
| 6988 using string_t = typename BasicJsonType::string_t; | |
| 6989 using binary_t = typename BasicJsonType::binary_t; | |
| 6990 using parser_callback_t = typename BasicJsonType::parser_callback_t; | |
| 6991 using parse_event_t = typename BasicJsonType::parse_event_t; | |
| 6992 | |
| 6993 json_sax_dom_callback_parser(BasicJsonType& r, | |
| 6994 const parser_callback_t cb, | |
| 6995 const bool allow_exceptions_ = true) | |
| 6996 : root(r), callback(cb), allow_exceptions(allow_exceptions_) | |
| 6997 { | |
| 6998 keep_stack.push_back(true); | |
| 6999 } | |
| 7000 | |
| 7001 // make class move-only | |
| 7002 json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete; | |
| 7003 json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 7004 json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete; | |
| 7005 json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 7006 ~json_sax_dom_callback_parser() = default; | |
| 7007 | |
| 7008 bool null() | |
| 7009 { | |
| 7010 handle_value(nullptr); | |
| 7011 return true; | |
| 7012 } | |
| 7013 | |
| 7014 bool boolean(bool val) | |
| 7015 { | |
| 7016 handle_value(val); | |
| 7017 return true; | |
| 7018 } | |
| 7019 | |
| 7020 bool number_integer(number_integer_t val) | |
| 7021 { | |
| 7022 handle_value(val); | |
| 7023 return true; | |
| 7024 } | |
| 7025 | |
| 7026 bool number_unsigned(number_unsigned_t val) | |
| 7027 { | |
| 7028 handle_value(val); | |
| 7029 return true; | |
| 7030 } | |
| 7031 | |
| 7032 bool number_float(number_float_t val, const string_t& /*unused*/) | |
| 7033 { | |
| 7034 handle_value(val); | |
| 7035 return true; | |
| 7036 } | |
| 7037 | |
| 7038 bool string(string_t& val) | |
| 7039 { | |
| 7040 handle_value(val); | |
| 7041 return true; | |
| 7042 } | |
| 7043 | |
| 7044 bool binary(binary_t& val) | |
| 7045 { | |
| 7046 handle_value(std::move(val)); | |
| 7047 return true; | |
| 7048 } | |
| 7049 | |
| 7050 bool start_object(std::size_t len) | |
| 7051 { | |
| 7052 // check callback for object start | |
| 7053 const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded); | |
| 7054 keep_stack.push_back(keep); | |
| 7055 | |
| 7056 auto val = handle_value(BasicJsonType::value_t::object, true); | |
| 7057 ref_stack.push_back(val.second); | |
| 7058 | |
| 7059 // check object limit | |
| 7060 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size())) | |
| 7061 { | |
| 7062 JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back())); | |
| 7063 } | |
| 7064 | |
| 7065 return true; | |
| 7066 } | |
| 7067 | |
| 7068 bool key(string_t& val) | |
| 7069 { | |
| 7070 BasicJsonType k = BasicJsonType(val); | |
| 7071 | |
| 7072 // check callback for key | |
| 7073 const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k); | |
| 7074 key_keep_stack.push_back(keep); | |
| 7075 | |
| 7076 // add discarded value at given key and store the reference for later | |
| 7077 if (keep && ref_stack.back()) | |
| 7078 { | |
| 7079 object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded); | |
| 7080 } | |
| 7081 | |
| 7082 return true; | |
| 7083 } | |
| 7084 | |
| 7085 bool end_object() | |
| 7086 { | |
| 7087 if (ref_stack.back()) | |
| 7088 { | |
| 7089 if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back())) | |
| 7090 { | |
| 7091 // discard object | |
| 7092 *ref_stack.back() = discarded; | |
| 7093 } | |
| 7094 else | |
| 7095 { | |
| 7096 ref_stack.back()->set_parents(); | |
| 7097 } | |
| 7098 } | |
| 7099 | |
| 7100 JSON_ASSERT(!ref_stack.empty()); | |
| 7101 JSON_ASSERT(!keep_stack.empty()); | |
| 7102 ref_stack.pop_back(); | |
| 7103 keep_stack.pop_back(); | |
| 7104 | |
| 7105 if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured()) | |
| 7106 { | |
| 7107 // remove discarded value | |
| 7108 for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it) | |
| 7109 { | |
| 7110 if (it->is_discarded()) | |
| 7111 { | |
| 7112 ref_stack.back()->erase(it); | |
| 7113 break; | |
| 7114 } | |
| 7115 } | |
| 7116 } | |
| 7117 | |
| 7118 return true; | |
| 7119 } | |
| 7120 | |
| 7121 bool start_array(std::size_t len) | |
| 7122 { | |
| 7123 const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded); | |
| 7124 keep_stack.push_back(keep); | |
| 7125 | |
| 7126 auto val = handle_value(BasicJsonType::value_t::array, true); | |
| 7127 ref_stack.push_back(val.second); | |
| 7128 | |
| 7129 // check array limit | |
| 7130 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size())) | |
| 7131 { | |
| 7132 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back())); | |
| 7133 } | |
| 7134 | |
| 7135 return true; | |
| 7136 } | |
| 7137 | |
| 7138 bool end_array() | |
| 7139 { | |
| 7140 bool keep = true; | |
| 7141 | |
| 7142 if (ref_stack.back()) | |
| 7143 { | |
| 7144 keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back()); | |
| 7145 if (keep) | |
| 7146 { | |
| 7147 ref_stack.back()->set_parents(); | |
| 7148 } | |
| 7149 else | |
| 7150 { | |
| 7151 // discard array | |
| 7152 *ref_stack.back() = discarded; | |
| 7153 } | |
| 7154 } | |
| 7155 | |
| 7156 JSON_ASSERT(!ref_stack.empty()); | |
| 7157 JSON_ASSERT(!keep_stack.empty()); | |
| 7158 ref_stack.pop_back(); | |
| 7159 keep_stack.pop_back(); | |
| 7160 | |
| 7161 // remove discarded value | |
| 7162 if (!keep && !ref_stack.empty() && ref_stack.back()->is_array()) | |
| 7163 { | |
| 7164 ref_stack.back()->m_data.m_value.array->pop_back(); | |
| 7165 } | |
| 7166 | |
| 7167 return true; | |
| 7168 } | |
| 7169 | |
| 7170 template<class Exception> | |
| 7171 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, | |
| 7172 const Exception& ex) | |
| 7173 { | |
| 7174 errored = true; | |
| 7175 static_cast<void>(ex); | |
| 7176 if (allow_exceptions) | |
| 7177 { | |
| 7178 JSON_THROW(ex); | |
| 7179 } | |
| 7180 return false; | |
| 7181 } | |
| 7182 | |
| 7183 constexpr bool is_errored() const | |
| 7184 { | |
| 7185 return errored; | |
| 7186 } | |
| 7187 | |
| 7188 private: | |
| 7189 /*! | |
| 7190 @param[in] v value to add to the JSON value we build during parsing | |
| 7191 @param[in] skip_callback whether we should skip calling the callback | |
| 7192 function; this is required after start_array() and | |
| 7193 start_object() SAX events, because otherwise we would call the | |
| 7194 callback function with an empty array or object, respectively. | |
| 7195 | |
| 7196 @invariant If the ref stack is empty, then the passed value will be the new | |
| 7197 root. | |
| 7198 @invariant If the ref stack contains a value, then it is an array or an | |
| 7199 object to which we can add elements | |
| 7200 | |
| 7201 @return pair of boolean (whether value should be kept) and pointer (to the | |
| 7202 passed value in the ref_stack hierarchy; nullptr if not kept) | |
| 7203 */ | |
| 7204 template<typename Value> | |
| 7205 std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false) | |
| 7206 { | |
| 7207 JSON_ASSERT(!keep_stack.empty()); | |
| 7208 | |
| 7209 // do not handle this value if we know it would be added to a discarded | |
| 7210 // container | |
| 7211 if (!keep_stack.back()) | |
| 7212 { | |
| 7213 return {false, nullptr}; | |
| 7214 } | |
| 7215 | |
| 7216 // create value | |
| 7217 auto value = BasicJsonType(std::forward<Value>(v)); | |
| 7218 | |
| 7219 // check callback | |
| 7220 const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value); | |
| 7221 | |
| 7222 // do not handle this value if we just learnt it shall be discarded | |
| 7223 if (!keep) | |
| 7224 { | |
| 7225 return {false, nullptr}; | |
| 7226 } | |
| 7227 | |
| 7228 if (ref_stack.empty()) | |
| 7229 { | |
| 7230 root = std::move(value); | |
| 7231 return {true, & root}; | |
| 7232 } | |
| 7233 | |
| 7234 // skip this value if we already decided to skip the parent | |
| 7235 // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360) | |
| 7236 if (!ref_stack.back()) | |
| 7237 { | |
| 7238 return {false, nullptr}; | |
| 7239 } | |
| 7240 | |
| 7241 // we now only expect arrays and objects | |
| 7242 JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); | |
| 7243 | |
| 7244 // array | |
| 7245 if (ref_stack.back()->is_array()) | |
| 7246 { | |
| 7247 ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value)); | |
| 7248 return {true, & (ref_stack.back()->m_data.m_value.array->back())}; | |
| 7249 } | |
| 7250 | |
| 7251 // object | |
| 7252 JSON_ASSERT(ref_stack.back()->is_object()); | |
| 7253 // check if we should store an element for the current key | |
| 7254 JSON_ASSERT(!key_keep_stack.empty()); | |
| 7255 const bool store_element = key_keep_stack.back(); | |
| 7256 key_keep_stack.pop_back(); | |
| 7257 | |
| 7258 if (!store_element) | |
| 7259 { | |
| 7260 return {false, nullptr}; | |
| 7261 } | |
| 7262 | |
| 7263 JSON_ASSERT(object_element); | |
| 7264 *object_element = std::move(value); | |
| 7265 return {true, object_element}; | |
| 7266 } | |
| 7267 | |
| 7268 /// the parsed JSON value | |
| 7269 BasicJsonType& root; | |
| 7270 /// stack to model hierarchy of values | |
| 7271 std::vector<BasicJsonType*> ref_stack {}; | |
| 7272 /// stack to manage which values to keep | |
| 7273 std::vector<bool> keep_stack {}; | |
| 7274 /// stack to manage which object keys to keep | |
| 7275 std::vector<bool> key_keep_stack {}; | |
| 7276 /// helper to hold the reference for the next object element | |
| 7277 BasicJsonType* object_element = nullptr; | |
| 7278 /// whether a syntax error occurred | |
| 7279 bool errored = false; | |
| 7280 /// callback function | |
| 7281 const parser_callback_t callback = nullptr; | |
| 7282 /// whether to throw exceptions in case of errors | |
| 7283 const bool allow_exceptions = true; | |
| 7284 /// a discarded value for the callback | |
| 7285 BasicJsonType discarded = BasicJsonType::value_t::discarded; | |
| 7286 }; | |
| 7287 | |
| 7288 template<typename BasicJsonType> | |
| 7289 class json_sax_acceptor | |
| 7290 { | |
| 7291 public: | |
| 7292 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 7293 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 7294 using number_float_t = typename BasicJsonType::number_float_t; | |
| 7295 using string_t = typename BasicJsonType::string_t; | |
| 7296 using binary_t = typename BasicJsonType::binary_t; | |
| 7297 | |
| 7298 bool null() | |
| 7299 { | |
| 7300 return true; | |
| 7301 } | |
| 7302 | |
| 7303 bool boolean(bool /*unused*/) | |
| 7304 { | |
| 7305 return true; | |
| 7306 } | |
| 7307 | |
| 7308 bool number_integer(number_integer_t /*unused*/) | |
| 7309 { | |
| 7310 return true; | |
| 7311 } | |
| 7312 | |
| 7313 bool number_unsigned(number_unsigned_t /*unused*/) | |
| 7314 { | |
| 7315 return true; | |
| 7316 } | |
| 7317 | |
| 7318 bool number_float(number_float_t /*unused*/, const string_t& /*unused*/) | |
| 7319 { | |
| 7320 return true; | |
| 7321 } | |
| 7322 | |
| 7323 bool string(string_t& /*unused*/) | |
| 7324 { | |
| 7325 return true; | |
| 7326 } | |
| 7327 | |
| 7328 bool binary(binary_t& /*unused*/) | |
| 7329 { | |
| 7330 return true; | |
| 7331 } | |
| 7332 | |
| 7333 bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1)) | |
| 7334 { | |
| 7335 return true; | |
| 7336 } | |
| 7337 | |
| 7338 bool key(string_t& /*unused*/) | |
| 7339 { | |
| 7340 return true; | |
| 7341 } | |
| 7342 | |
| 7343 bool end_object() | |
| 7344 { | |
| 7345 return true; | |
| 7346 } | |
| 7347 | |
| 7348 bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1)) | |
| 7349 { | |
| 7350 return true; | |
| 7351 } | |
| 7352 | |
| 7353 bool end_array() | |
| 7354 { | |
| 7355 return true; | |
| 7356 } | |
| 7357 | |
| 7358 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/) | |
| 7359 { | |
| 7360 return false; | |
| 7361 } | |
| 7362 }; | |
| 7363 | |
| 7364 } // namespace detail | |
| 7365 NLOHMANN_JSON_NAMESPACE_END | |
| 7366 | |
| 7367 // #include <nlohmann/detail/input/lexer.hpp> | |
| 7368 // __ _____ _____ _____ | |
| 7369 // __| | __| | | | JSON for Modern C++ | |
| 7370 // | | |__ | | | | | | version 3.11.3 | |
| 7371 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 7372 // | |
| 7373 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 7374 // SPDX-License-Identifier: MIT | |
| 7375 | |
| 7376 | |
| 7377 | |
| 7378 #include <array> // array | |
| 7379 #include <clocale> // localeconv | |
| 7380 #include <cstddef> // size_t | |
| 7381 #include <cstdio> // snprintf | |
| 7382 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull | |
| 7383 #include <initializer_list> // initializer_list | |
| 7384 #include <string> // char_traits, string | |
| 7385 #include <utility> // move | |
| 7386 #include <vector> // vector | |
| 7387 | |
| 7388 // #include <nlohmann/detail/input/input_adapters.hpp> | |
| 7389 | |
| 7390 // #include <nlohmann/detail/input/position_t.hpp> | |
| 7391 | |
| 7392 // #include <nlohmann/detail/macro_scope.hpp> | |
| 7393 | |
| 7394 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 7395 | |
| 7396 | |
| 7397 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 7398 namespace detail | |
| 7399 { | |
| 7400 | |
| 7401 /////////// | |
| 7402 // lexer // | |
| 7403 /////////// | |
| 7404 | |
| 7405 template<typename BasicJsonType> | |
| 7406 class lexer_base | |
| 7407 { | |
| 7408 public: | |
| 7409 /// token types for the parser | |
| 7410 enum class token_type | |
| 7411 { | |
| 7412 uninitialized, ///< indicating the scanner is uninitialized | |
| 7413 literal_true, ///< the `true` literal | |
| 7414 literal_false, ///< the `false` literal | |
| 7415 literal_null, ///< the `null` literal | |
| 7416 value_string, ///< a string -- use get_string() for actual value | |
| 7417 value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for actual value | |
| 7418 value_integer, ///< a signed integer -- use get_number_integer() for actual value | |
| 7419 value_float, ///< an floating point number -- use get_number_float() for actual value | |
| 7420 begin_array, ///< the character for array begin `[` | |
| 7421 begin_object, ///< the character for object begin `{` | |
| 7422 end_array, ///< the character for array end `]` | |
| 7423 end_object, ///< the character for object end `}` | |
| 7424 name_separator, ///< the name separator `:` | |
| 7425 value_separator, ///< the value separator `,` | |
| 7426 parse_error, ///< indicating a parse error | |
| 7427 end_of_input, ///< indicating the end of the input buffer | |
| 7428 literal_or_value ///< a literal or the begin of a value (only for diagnostics) | |
| 7429 }; | |
| 7430 | |
| 7431 /// return name of values of type token_type (only used for errors) | |
| 7432 JSON_HEDLEY_RETURNS_NON_NULL | |
| 7433 JSON_HEDLEY_CONST | |
| 7434 static const char* token_type_name(const token_type t) noexcept | |
| 7435 { | |
| 7436 switch (t) | |
| 7437 { | |
| 7438 case token_type::uninitialized: | |
| 7439 return "<uninitialized>"; | |
| 7440 case token_type::literal_true: | |
| 7441 return "true literal"; | |
| 7442 case token_type::literal_false: | |
| 7443 return "false literal"; | |
| 7444 case token_type::literal_null: | |
| 7445 return "null literal"; | |
| 7446 case token_type::value_string: | |
| 7447 return "string literal"; | |
| 7448 case token_type::value_unsigned: | |
| 7449 case token_type::value_integer: | |
| 7450 case token_type::value_float: | |
| 7451 return "number literal"; | |
| 7452 case token_type::begin_array: | |
| 7453 return "'['"; | |
| 7454 case token_type::begin_object: | |
| 7455 return "'{'"; | |
| 7456 case token_type::end_array: | |
| 7457 return "']'"; | |
| 7458 case token_type::end_object: | |
| 7459 return "'}'"; | |
| 7460 case token_type::name_separator: | |
| 7461 return "':'"; | |
| 7462 case token_type::value_separator: | |
| 7463 return "','"; | |
| 7464 case token_type::parse_error: | |
| 7465 return "<parse error>"; | |
| 7466 case token_type::end_of_input: | |
| 7467 return "end of input"; | |
| 7468 case token_type::literal_or_value: | |
| 7469 return "'[', '{', or a literal"; | |
| 7470 // LCOV_EXCL_START | |
| 7471 default: // catch non-enum values | |
| 7472 return "unknown token"; | |
| 7473 // LCOV_EXCL_STOP | |
| 7474 } | |
| 7475 } | |
| 7476 }; | |
| 7477 /*! | |
| 7478 @brief lexical analysis | |
| 7479 | |
| 7480 This class organizes the lexical analysis during JSON deserialization. | |
| 7481 */ | |
| 7482 template<typename BasicJsonType, typename InputAdapterType> | |
| 7483 class lexer : public lexer_base<BasicJsonType> | |
| 7484 { | |
| 7485 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 7486 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 7487 using number_float_t = typename BasicJsonType::number_float_t; | |
| 7488 using string_t = typename BasicJsonType::string_t; | |
| 7489 using char_type = typename InputAdapterType::char_type; | |
| 7490 using char_int_type = typename char_traits<char_type>::int_type; | |
| 7491 | |
| 7492 public: | |
| 7493 using token_type = typename lexer_base<BasicJsonType>::token_type; | |
| 7494 | |
| 7495 explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept | |
| 7496 : ia(std::move(adapter)) | |
| 7497 , ignore_comments(ignore_comments_) | |
| 7498 , decimal_point_char(static_cast<char_int_type>(get_decimal_point())) | |
| 7499 {} | |
| 7500 | |
| 7501 // delete because of pointer members | |
| 7502 lexer(const lexer&) = delete; | |
| 7503 lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 7504 lexer& operator=(lexer&) = delete; | |
| 7505 lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 7506 ~lexer() = default; | |
| 7507 | |
| 7508 private: | |
| 7509 ///////////////////// | |
| 7510 // locales | |
| 7511 ///////////////////// | |
| 7512 | |
| 7513 /// return the locale-dependent decimal point | |
| 7514 JSON_HEDLEY_PURE | |
| 7515 static char get_decimal_point() noexcept | |
| 7516 { | |
| 7517 const auto* loc = localeconv(); | |
| 7518 JSON_ASSERT(loc != nullptr); | |
| 7519 return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point); | |
| 7520 } | |
| 7521 | |
| 7522 ///////////////////// | |
| 7523 // scan functions | |
| 7524 ///////////////////// | |
| 7525 | |
| 7526 /*! | |
| 7527 @brief get codepoint from 4 hex characters following `\u` | |
| 7528 | |
| 7529 For input "\u c1 c2 c3 c4" the codepoint is: | |
| 7530 (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4 | |
| 7531 = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0) | |
| 7532 | |
| 7533 Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f' | |
| 7534 must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The | |
| 7535 conversion is done by subtracting the offset (0x30, 0x37, and 0x57) | |
| 7536 between the ASCII value of the character and the desired integer value. | |
| 7537 | |
| 7538 @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or | |
| 7539 non-hex character) | |
| 7540 */ | |
| 7541 int get_codepoint() | |
| 7542 { | |
| 7543 // this function only makes sense after reading `\u` | |
| 7544 JSON_ASSERT(current == 'u'); | |
| 7545 int codepoint = 0; | |
| 7546 | |
| 7547 const auto factors = { 12u, 8u, 4u, 0u }; | |
| 7548 for (const auto factor : factors) | |
| 7549 { | |
| 7550 get(); | |
| 7551 | |
| 7552 if (current >= '0' && current <= '9') | |
| 7553 { | |
| 7554 codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor); | |
| 7555 } | |
| 7556 else if (current >= 'A' && current <= 'F') | |
| 7557 { | |
| 7558 codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor); | |
| 7559 } | |
| 7560 else if (current >= 'a' && current <= 'f') | |
| 7561 { | |
| 7562 codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor); | |
| 7563 } | |
| 7564 else | |
| 7565 { | |
| 7566 return -1; | |
| 7567 } | |
| 7568 } | |
| 7569 | |
| 7570 JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF); | |
| 7571 return codepoint; | |
| 7572 } | |
| 7573 | |
| 7574 /*! | |
| 7575 @brief check if the next byte(s) are inside a given range | |
| 7576 | |
| 7577 Adds the current byte and, for each passed range, reads a new byte and | |
| 7578 checks if it is inside the range. If a violation was detected, set up an | |
| 7579 error message and return false. Otherwise, return true. | |
| 7580 | |
| 7581 @param[in] ranges list of integers; interpreted as list of pairs of | |
| 7582 inclusive lower and upper bound, respectively | |
| 7583 | |
| 7584 @pre The passed list @a ranges must have 2, 4, or 6 elements; that is, | |
| 7585 1, 2, or 3 pairs. This precondition is enforced by an assertion. | |
| 7586 | |
| 7587 @return true if and only if no range violation was detected | |
| 7588 */ | |
| 7589 bool next_byte_in_range(std::initializer_list<char_int_type> ranges) | |
| 7590 { | |
| 7591 JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6); | |
| 7592 add(current); | |
| 7593 | |
| 7594 for (auto range = ranges.begin(); range != ranges.end(); ++range) | |
| 7595 { | |
| 7596 get(); | |
| 7597 if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions) | |
| 7598 { | |
| 7599 add(current); | |
| 7600 } | |
| 7601 else | |
| 7602 { | |
| 7603 error_message = "invalid string: ill-formed UTF-8 byte"; | |
| 7604 return false; | |
| 7605 } | |
| 7606 } | |
| 7607 | |
| 7608 return true; | |
| 7609 } | |
| 7610 | |
| 7611 /*! | |
| 7612 @brief scan a string literal | |
| 7613 | |
| 7614 This function scans a string according to Sect. 7 of RFC 8259. While | |
| 7615 scanning, bytes are escaped and copied into buffer token_buffer. Then the | |
| 7616 function returns successfully, token_buffer is *not* null-terminated (as it | |
| 7617 may contain \0 bytes), and token_buffer.size() is the number of bytes in the | |
| 7618 string. | |
| 7619 | |
| 7620 @return token_type::value_string if string could be successfully scanned, | |
| 7621 token_type::parse_error otherwise | |
| 7622 | |
| 7623 @note In case of errors, variable error_message contains a textual | |
| 7624 description. | |
| 7625 */ | |
| 7626 token_type scan_string() | |
| 7627 { | |
| 7628 // reset token_buffer (ignore opening quote) | |
| 7629 reset(); | |
| 7630 | |
| 7631 // we entered the function by reading an open quote | |
| 7632 JSON_ASSERT(current == '\"'); | |
| 7633 | |
| 7634 while (true) | |
| 7635 { | |
| 7636 // get next character | |
| 7637 switch (get()) | |
| 7638 { | |
| 7639 // end of file while parsing string | |
| 7640 case char_traits<char_type>::eof(): | |
| 7641 { | |
| 7642 error_message = "invalid string: missing closing quote"; | |
| 7643 return token_type::parse_error; | |
| 7644 } | |
| 7645 | |
| 7646 // closing quote | |
| 7647 case '\"': | |
| 7648 { | |
| 7649 return token_type::value_string; | |
| 7650 } | |
| 7651 | |
| 7652 // escapes | |
| 7653 case '\\': | |
| 7654 { | |
| 7655 switch (get()) | |
| 7656 { | |
| 7657 // quotation mark | |
| 7658 case '\"': | |
| 7659 add('\"'); | |
| 7660 break; | |
| 7661 // reverse solidus | |
| 7662 case '\\': | |
| 7663 add('\\'); | |
| 7664 break; | |
| 7665 // solidus | |
| 7666 case '/': | |
| 7667 add('/'); | |
| 7668 break; | |
| 7669 // backspace | |
| 7670 case 'b': | |
| 7671 add('\b'); | |
| 7672 break; | |
| 7673 // form feed | |
| 7674 case 'f': | |
| 7675 add('\f'); | |
| 7676 break; | |
| 7677 // line feed | |
| 7678 case 'n': | |
| 7679 add('\n'); | |
| 7680 break; | |
| 7681 // carriage return | |
| 7682 case 'r': | |
| 7683 add('\r'); | |
| 7684 break; | |
| 7685 // tab | |
| 7686 case 't': | |
| 7687 add('\t'); | |
| 7688 break; | |
| 7689 | |
| 7690 // unicode escapes | |
| 7691 case 'u': | |
| 7692 { | |
| 7693 const int codepoint1 = get_codepoint(); | |
| 7694 int codepoint = codepoint1; // start with codepoint1 | |
| 7695 | |
| 7696 if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1)) | |
| 7697 { | |
| 7698 error_message = "invalid string: '\\u' must be followed by 4 hex digits"; | |
| 7699 return token_type::parse_error; | |
| 7700 } | |
| 7701 | |
| 7702 // check if code point is a high surrogate | |
| 7703 if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF) | |
| 7704 { | |
| 7705 // expect next \uxxxx entry | |
| 7706 if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u')) | |
| 7707 { | |
| 7708 const int codepoint2 = get_codepoint(); | |
| 7709 | |
| 7710 if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1)) | |
| 7711 { | |
| 7712 error_message = "invalid string: '\\u' must be followed by 4 hex digits"; | |
| 7713 return token_type::parse_error; | |
| 7714 } | |
| 7715 | |
| 7716 // check if codepoint2 is a low surrogate | |
| 7717 if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF)) | |
| 7718 { | |
| 7719 // overwrite codepoint | |
| 7720 codepoint = static_cast<int>( | |
| 7721 // high surrogate occupies the most significant 22 bits | |
| 7722 (static_cast<unsigned int>(codepoint1) << 10u) | |
| 7723 // low surrogate occupies the least significant 15 bits | |
| 7724 + static_cast<unsigned int>(codepoint2) | |
| 7725 // there is still the 0xD800, 0xDC00 and 0x10000 noise | |
| 7726 // in the result, so we have to subtract with: | |
| 7727 // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00 | |
| 7728 - 0x35FDC00u); | |
| 7729 } | |
| 7730 else | |
| 7731 { | |
| 7732 error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"; | |
| 7733 return token_type::parse_error; | |
| 7734 } | |
| 7735 } | |
| 7736 else | |
| 7737 { | |
| 7738 error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"; | |
| 7739 return token_type::parse_error; | |
| 7740 } | |
| 7741 } | |
| 7742 else | |
| 7743 { | |
| 7744 if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF)) | |
| 7745 { | |
| 7746 error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF"; | |
| 7747 return token_type::parse_error; | |
| 7748 } | |
| 7749 } | |
| 7750 | |
| 7751 // result of the above calculation yields a proper codepoint | |
| 7752 JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF); | |
| 7753 | |
| 7754 // translate codepoint into bytes | |
| 7755 if (codepoint < 0x80) | |
| 7756 { | |
| 7757 // 1-byte characters: 0xxxxxxx (ASCII) | |
| 7758 add(static_cast<char_int_type>(codepoint)); | |
| 7759 } | |
| 7760 else if (codepoint <= 0x7FF) | |
| 7761 { | |
| 7762 // 2-byte characters: 110xxxxx 10xxxxxx | |
| 7763 add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u))); | |
| 7764 add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu))); | |
| 7765 } | |
| 7766 else if (codepoint <= 0xFFFF) | |
| 7767 { | |
| 7768 // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx | |
| 7769 add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u))); | |
| 7770 add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu))); | |
| 7771 add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu))); | |
| 7772 } | |
| 7773 else | |
| 7774 { | |
| 7775 // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx | |
| 7776 add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u))); | |
| 7777 add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu))); | |
| 7778 add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu))); | |
| 7779 add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu))); | |
| 7780 } | |
| 7781 | |
| 7782 break; | |
| 7783 } | |
| 7784 | |
| 7785 // other characters after escape | |
| 7786 default: | |
| 7787 error_message = "invalid string: forbidden character after backslash"; | |
| 7788 return token_type::parse_error; | |
| 7789 } | |
| 7790 | |
| 7791 break; | |
| 7792 } | |
| 7793 | |
| 7794 // invalid control characters | |
| 7795 case 0x00: | |
| 7796 { | |
| 7797 error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000"; | |
| 7798 return token_type::parse_error; | |
| 7799 } | |
| 7800 | |
| 7801 case 0x01: | |
| 7802 { | |
| 7803 error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001"; | |
| 7804 return token_type::parse_error; | |
| 7805 } | |
| 7806 | |
| 7807 case 0x02: | |
| 7808 { | |
| 7809 error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002"; | |
| 7810 return token_type::parse_error; | |
| 7811 } | |
| 7812 | |
| 7813 case 0x03: | |
| 7814 { | |
| 7815 error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003"; | |
| 7816 return token_type::parse_error; | |
| 7817 } | |
| 7818 | |
| 7819 case 0x04: | |
| 7820 { | |
| 7821 error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004"; | |
| 7822 return token_type::parse_error; | |
| 7823 } | |
| 7824 | |
| 7825 case 0x05: | |
| 7826 { | |
| 7827 error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005"; | |
| 7828 return token_type::parse_error; | |
| 7829 } | |
| 7830 | |
| 7831 case 0x06: | |
| 7832 { | |
| 7833 error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006"; | |
| 7834 return token_type::parse_error; | |
| 7835 } | |
| 7836 | |
| 7837 case 0x07: | |
| 7838 { | |
| 7839 error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007"; | |
| 7840 return token_type::parse_error; | |
| 7841 } | |
| 7842 | |
| 7843 case 0x08: | |
| 7844 { | |
| 7845 error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b"; | |
| 7846 return token_type::parse_error; | |
| 7847 } | |
| 7848 | |
| 7849 case 0x09: | |
| 7850 { | |
| 7851 error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t"; | |
| 7852 return token_type::parse_error; | |
| 7853 } | |
| 7854 | |
| 7855 case 0x0A: | |
| 7856 { | |
| 7857 error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n"; | |
| 7858 return token_type::parse_error; | |
| 7859 } | |
| 7860 | |
| 7861 case 0x0B: | |
| 7862 { | |
| 7863 error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B"; | |
| 7864 return token_type::parse_error; | |
| 7865 } | |
| 7866 | |
| 7867 case 0x0C: | |
| 7868 { | |
| 7869 error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f"; | |
| 7870 return token_type::parse_error; | |
| 7871 } | |
| 7872 | |
| 7873 case 0x0D: | |
| 7874 { | |
| 7875 error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r"; | |
| 7876 return token_type::parse_error; | |
| 7877 } | |
| 7878 | |
| 7879 case 0x0E: | |
| 7880 { | |
| 7881 error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E"; | |
| 7882 return token_type::parse_error; | |
| 7883 } | |
| 7884 | |
| 7885 case 0x0F: | |
| 7886 { | |
| 7887 error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F"; | |
| 7888 return token_type::parse_error; | |
| 7889 } | |
| 7890 | |
| 7891 case 0x10: | |
| 7892 { | |
| 7893 error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010"; | |
| 7894 return token_type::parse_error; | |
| 7895 } | |
| 7896 | |
| 7897 case 0x11: | |
| 7898 { | |
| 7899 error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011"; | |
| 7900 return token_type::parse_error; | |
| 7901 } | |
| 7902 | |
| 7903 case 0x12: | |
| 7904 { | |
| 7905 error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012"; | |
| 7906 return token_type::parse_error; | |
| 7907 } | |
| 7908 | |
| 7909 case 0x13: | |
| 7910 { | |
| 7911 error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013"; | |
| 7912 return token_type::parse_error; | |
| 7913 } | |
| 7914 | |
| 7915 case 0x14: | |
| 7916 { | |
| 7917 error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014"; | |
| 7918 return token_type::parse_error; | |
| 7919 } | |
| 7920 | |
| 7921 case 0x15: | |
| 7922 { | |
| 7923 error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015"; | |
| 7924 return token_type::parse_error; | |
| 7925 } | |
| 7926 | |
| 7927 case 0x16: | |
| 7928 { | |
| 7929 error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016"; | |
| 7930 return token_type::parse_error; | |
| 7931 } | |
| 7932 | |
| 7933 case 0x17: | |
| 7934 { | |
| 7935 error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017"; | |
| 7936 return token_type::parse_error; | |
| 7937 } | |
| 7938 | |
| 7939 case 0x18: | |
| 7940 { | |
| 7941 error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018"; | |
| 7942 return token_type::parse_error; | |
| 7943 } | |
| 7944 | |
| 7945 case 0x19: | |
| 7946 { | |
| 7947 error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019"; | |
| 7948 return token_type::parse_error; | |
| 7949 } | |
| 7950 | |
| 7951 case 0x1A: | |
| 7952 { | |
| 7953 error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A"; | |
| 7954 return token_type::parse_error; | |
| 7955 } | |
| 7956 | |
| 7957 case 0x1B: | |
| 7958 { | |
| 7959 error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B"; | |
| 7960 return token_type::parse_error; | |
| 7961 } | |
| 7962 | |
| 7963 case 0x1C: | |
| 7964 { | |
| 7965 error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C"; | |
| 7966 return token_type::parse_error; | |
| 7967 } | |
| 7968 | |
| 7969 case 0x1D: | |
| 7970 { | |
| 7971 error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D"; | |
| 7972 return token_type::parse_error; | |
| 7973 } | |
| 7974 | |
| 7975 case 0x1E: | |
| 7976 { | |
| 7977 error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E"; | |
| 7978 return token_type::parse_error; | |
| 7979 } | |
| 7980 | |
| 7981 case 0x1F: | |
| 7982 { | |
| 7983 error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F"; | |
| 7984 return token_type::parse_error; | |
| 7985 } | |
| 7986 | |
| 7987 // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace)) | |
| 7988 case 0x20: | |
| 7989 case 0x21: | |
| 7990 case 0x23: | |
| 7991 case 0x24: | |
| 7992 case 0x25: | |
| 7993 case 0x26: | |
| 7994 case 0x27: | |
| 7995 case 0x28: | |
| 7996 case 0x29: | |
| 7997 case 0x2A: | |
| 7998 case 0x2B: | |
| 7999 case 0x2C: | |
| 8000 case 0x2D: | |
| 8001 case 0x2E: | |
| 8002 case 0x2F: | |
| 8003 case 0x30: | |
| 8004 case 0x31: | |
| 8005 case 0x32: | |
| 8006 case 0x33: | |
| 8007 case 0x34: | |
| 8008 case 0x35: | |
| 8009 case 0x36: | |
| 8010 case 0x37: | |
| 8011 case 0x38: | |
| 8012 case 0x39: | |
| 8013 case 0x3A: | |
| 8014 case 0x3B: | |
| 8015 case 0x3C: | |
| 8016 case 0x3D: | |
| 8017 case 0x3E: | |
| 8018 case 0x3F: | |
| 8019 case 0x40: | |
| 8020 case 0x41: | |
| 8021 case 0x42: | |
| 8022 case 0x43: | |
| 8023 case 0x44: | |
| 8024 case 0x45: | |
| 8025 case 0x46: | |
| 8026 case 0x47: | |
| 8027 case 0x48: | |
| 8028 case 0x49: | |
| 8029 case 0x4A: | |
| 8030 case 0x4B: | |
| 8031 case 0x4C: | |
| 8032 case 0x4D: | |
| 8033 case 0x4E: | |
| 8034 case 0x4F: | |
| 8035 case 0x50: | |
| 8036 case 0x51: | |
| 8037 case 0x52: | |
| 8038 case 0x53: | |
| 8039 case 0x54: | |
| 8040 case 0x55: | |
| 8041 case 0x56: | |
| 8042 case 0x57: | |
| 8043 case 0x58: | |
| 8044 case 0x59: | |
| 8045 case 0x5A: | |
| 8046 case 0x5B: | |
| 8047 case 0x5D: | |
| 8048 case 0x5E: | |
| 8049 case 0x5F: | |
| 8050 case 0x60: | |
| 8051 case 0x61: | |
| 8052 case 0x62: | |
| 8053 case 0x63: | |
| 8054 case 0x64: | |
| 8055 case 0x65: | |
| 8056 case 0x66: | |
| 8057 case 0x67: | |
| 8058 case 0x68: | |
| 8059 case 0x69: | |
| 8060 case 0x6A: | |
| 8061 case 0x6B: | |
| 8062 case 0x6C: | |
| 8063 case 0x6D: | |
| 8064 case 0x6E: | |
| 8065 case 0x6F: | |
| 8066 case 0x70: | |
| 8067 case 0x71: | |
| 8068 case 0x72: | |
| 8069 case 0x73: | |
| 8070 case 0x74: | |
| 8071 case 0x75: | |
| 8072 case 0x76: | |
| 8073 case 0x77: | |
| 8074 case 0x78: | |
| 8075 case 0x79: | |
| 8076 case 0x7A: | |
| 8077 case 0x7B: | |
| 8078 case 0x7C: | |
| 8079 case 0x7D: | |
| 8080 case 0x7E: | |
| 8081 case 0x7F: | |
| 8082 { | |
| 8083 add(current); | |
| 8084 break; | |
| 8085 } | |
| 8086 | |
| 8087 // U+0080..U+07FF: bytes C2..DF 80..BF | |
| 8088 case 0xC2: | |
| 8089 case 0xC3: | |
| 8090 case 0xC4: | |
| 8091 case 0xC5: | |
| 8092 case 0xC6: | |
| 8093 case 0xC7: | |
| 8094 case 0xC8: | |
| 8095 case 0xC9: | |
| 8096 case 0xCA: | |
| 8097 case 0xCB: | |
| 8098 case 0xCC: | |
| 8099 case 0xCD: | |
| 8100 case 0xCE: | |
| 8101 case 0xCF: | |
| 8102 case 0xD0: | |
| 8103 case 0xD1: | |
| 8104 case 0xD2: | |
| 8105 case 0xD3: | |
| 8106 case 0xD4: | |
| 8107 case 0xD5: | |
| 8108 case 0xD6: | |
| 8109 case 0xD7: | |
| 8110 case 0xD8: | |
| 8111 case 0xD9: | |
| 8112 case 0xDA: | |
| 8113 case 0xDB: | |
| 8114 case 0xDC: | |
| 8115 case 0xDD: | |
| 8116 case 0xDE: | |
| 8117 case 0xDF: | |
| 8118 { | |
| 8119 if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF}))) | |
| 8120 { | |
| 8121 return token_type::parse_error; | |
| 8122 } | |
| 8123 break; | |
| 8124 } | |
| 8125 | |
| 8126 // U+0800..U+0FFF: bytes E0 A0..BF 80..BF | |
| 8127 case 0xE0: | |
| 8128 { | |
| 8129 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF})))) | |
| 8130 { | |
| 8131 return token_type::parse_error; | |
| 8132 } | |
| 8133 break; | |
| 8134 } | |
| 8135 | |
| 8136 // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF | |
| 8137 // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF | |
| 8138 case 0xE1: | |
| 8139 case 0xE2: | |
| 8140 case 0xE3: | |
| 8141 case 0xE4: | |
| 8142 case 0xE5: | |
| 8143 case 0xE6: | |
| 8144 case 0xE7: | |
| 8145 case 0xE8: | |
| 8146 case 0xE9: | |
| 8147 case 0xEA: | |
| 8148 case 0xEB: | |
| 8149 case 0xEC: | |
| 8150 case 0xEE: | |
| 8151 case 0xEF: | |
| 8152 { | |
| 8153 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF})))) | |
| 8154 { | |
| 8155 return token_type::parse_error; | |
| 8156 } | |
| 8157 break; | |
| 8158 } | |
| 8159 | |
| 8160 // U+D000..U+D7FF: bytes ED 80..9F 80..BF | |
| 8161 case 0xED: | |
| 8162 { | |
| 8163 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF})))) | |
| 8164 { | |
| 8165 return token_type::parse_error; | |
| 8166 } | |
| 8167 break; | |
| 8168 } | |
| 8169 | |
| 8170 // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF | |
| 8171 case 0xF0: | |
| 8172 { | |
| 8173 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) | |
| 8174 { | |
| 8175 return token_type::parse_error; | |
| 8176 } | |
| 8177 break; | |
| 8178 } | |
| 8179 | |
| 8180 // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF | |
| 8181 case 0xF1: | |
| 8182 case 0xF2: | |
| 8183 case 0xF3: | |
| 8184 { | |
| 8185 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) | |
| 8186 { | |
| 8187 return token_type::parse_error; | |
| 8188 } | |
| 8189 break; | |
| 8190 } | |
| 8191 | |
| 8192 // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF | |
| 8193 case 0xF4: | |
| 8194 { | |
| 8195 if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF})))) | |
| 8196 { | |
| 8197 return token_type::parse_error; | |
| 8198 } | |
| 8199 break; | |
| 8200 } | |
| 8201 | |
| 8202 // remaining bytes (80..C1 and F5..FF) are ill-formed | |
| 8203 default: | |
| 8204 { | |
| 8205 error_message = "invalid string: ill-formed UTF-8 byte"; | |
| 8206 return token_type::parse_error; | |
| 8207 } | |
| 8208 } | |
| 8209 } | |
| 8210 } | |
| 8211 | |
| 8212 /*! | |
| 8213 * @brief scan a comment | |
| 8214 * @return whether comment could be scanned successfully | |
| 8215 */ | |
| 8216 bool scan_comment() | |
| 8217 { | |
| 8218 switch (get()) | |
| 8219 { | |
| 8220 // single-line comments skip input until a newline or EOF is read | |
| 8221 case '/': | |
| 8222 { | |
| 8223 while (true) | |
| 8224 { | |
| 8225 switch (get()) | |
| 8226 { | |
| 8227 case '\n': | |
| 8228 case '\r': | |
| 8229 case char_traits<char_type>::eof(): | |
| 8230 case '\0': | |
| 8231 return true; | |
| 8232 | |
| 8233 default: | |
| 8234 break; | |
| 8235 } | |
| 8236 } | |
| 8237 } | |
| 8238 | |
| 8239 // multi-line comments skip input until */ is read | |
| 8240 case '*': | |
| 8241 { | |
| 8242 while (true) | |
| 8243 { | |
| 8244 switch (get()) | |
| 8245 { | |
| 8246 case char_traits<char_type>::eof(): | |
| 8247 case '\0': | |
| 8248 { | |
| 8249 error_message = "invalid comment; missing closing '*/'"; | |
| 8250 return false; | |
| 8251 } | |
| 8252 | |
| 8253 case '*': | |
| 8254 { | |
| 8255 switch (get()) | |
| 8256 { | |
| 8257 case '/': | |
| 8258 return true; | |
| 8259 | |
| 8260 default: | |
| 8261 { | |
| 8262 unget(); | |
| 8263 continue; | |
| 8264 } | |
| 8265 } | |
| 8266 } | |
| 8267 | |
| 8268 default: | |
| 8269 continue; | |
| 8270 } | |
| 8271 } | |
| 8272 } | |
| 8273 | |
| 8274 // unexpected character after reading '/' | |
| 8275 default: | |
| 8276 { | |
| 8277 error_message = "invalid comment; expecting '/' or '*' after '/'"; | |
| 8278 return false; | |
| 8279 } | |
| 8280 } | |
| 8281 } | |
| 8282 | |
| 8283 JSON_HEDLEY_NON_NULL(2) | |
| 8284 static void strtof(float& f, const char* str, char** endptr) noexcept | |
| 8285 { | |
| 8286 f = std::strtof(str, endptr); | |
| 8287 } | |
| 8288 | |
| 8289 JSON_HEDLEY_NON_NULL(2) | |
| 8290 static void strtof(double& f, const char* str, char** endptr) noexcept | |
| 8291 { | |
| 8292 f = std::strtod(str, endptr); | |
| 8293 } | |
| 8294 | |
| 8295 JSON_HEDLEY_NON_NULL(2) | |
| 8296 static void strtof(long double& f, const char* str, char** endptr) noexcept | |
| 8297 { | |
| 8298 f = std::strtold(str, endptr); | |
| 8299 } | |
| 8300 | |
| 8301 /*! | |
| 8302 @brief scan a number literal | |
| 8303 | |
| 8304 This function scans a string according to Sect. 6 of RFC 8259. | |
| 8305 | |
| 8306 The function is realized with a deterministic finite state machine derived | |
| 8307 from the grammar described in RFC 8259. Starting in state "init", the | |
| 8308 input is read and used to determined the next state. Only state "done" | |
| 8309 accepts the number. State "error" is a trap state to model errors. In the | |
| 8310 table below, "anything" means any character but the ones listed before. | |
| 8311 | |
| 8312 state | 0 | 1-9 | e E | + | - | . | anything | |
| 8313 ---------|----------|----------|----------|---------|---------|----------|----------- | |
| 8314 init | zero | any1 | [error] | [error] | minus | [error] | [error] | |
| 8315 minus | zero | any1 | [error] | [error] | [error] | [error] | [error] | |
| 8316 zero | done | done | exponent | done | done | decimal1 | done | |
| 8317 any1 | any1 | any1 | exponent | done | done | decimal1 | done | |
| 8318 decimal1 | decimal2 | decimal2 | [error] | [error] | [error] | [error] | [error] | |
| 8319 decimal2 | decimal2 | decimal2 | exponent | done | done | done | done | |
| 8320 exponent | any2 | any2 | [error] | sign | sign | [error] | [error] | |
| 8321 sign | any2 | any2 | [error] | [error] | [error] | [error] | [error] | |
| 8322 any2 | any2 | any2 | done | done | done | done | done | |
| 8323 | |
| 8324 The state machine is realized with one label per state (prefixed with | |
| 8325 "scan_number_") and `goto` statements between them. The state machine | |
| 8326 contains cycles, but any cycle can be left when EOF is read. Therefore, | |
| 8327 the function is guaranteed to terminate. | |
| 8328 | |
| 8329 During scanning, the read bytes are stored in token_buffer. This string is | |
| 8330 then converted to a signed integer, an unsigned integer, or a | |
| 8331 floating-point number. | |
| 8332 | |
| 8333 @return token_type::value_unsigned, token_type::value_integer, or | |
| 8334 token_type::value_float if number could be successfully scanned, | |
| 8335 token_type::parse_error otherwise | |
| 8336 | |
| 8337 @note The scanner is independent of the current locale. Internally, the | |
| 8338 locale's decimal point is used instead of `.` to work with the | |
| 8339 locale-dependent converters. | |
| 8340 */ | |
| 8341 token_type scan_number() // lgtm [cpp/use-of-goto] | |
| 8342 { | |
| 8343 // reset token_buffer to store the number's bytes | |
| 8344 reset(); | |
| 8345 | |
| 8346 // the type of the parsed number; initially set to unsigned; will be | |
| 8347 // changed if minus sign, decimal point or exponent is read | |
| 8348 token_type number_type = token_type::value_unsigned; | |
| 8349 | |
| 8350 // state (init): we just found out we need to scan a number | |
| 8351 switch (current) | |
| 8352 { | |
| 8353 case '-': | |
| 8354 { | |
| 8355 add(current); | |
| 8356 goto scan_number_minus; | |
| 8357 } | |
| 8358 | |
| 8359 case '0': | |
| 8360 { | |
| 8361 add(current); | |
| 8362 goto scan_number_zero; | |
| 8363 } | |
| 8364 | |
| 8365 case '1': | |
| 8366 case '2': | |
| 8367 case '3': | |
| 8368 case '4': | |
| 8369 case '5': | |
| 8370 case '6': | |
| 8371 case '7': | |
| 8372 case '8': | |
| 8373 case '9': | |
| 8374 { | |
| 8375 add(current); | |
| 8376 goto scan_number_any1; | |
| 8377 } | |
| 8378 | |
| 8379 // all other characters are rejected outside scan_number() | |
| 8380 default: // LCOV_EXCL_LINE | |
| 8381 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 8382 } | |
| 8383 | |
| 8384 scan_number_minus: | |
| 8385 // state: we just parsed a leading minus sign | |
| 8386 number_type = token_type::value_integer; | |
| 8387 switch (get()) | |
| 8388 { | |
| 8389 case '0': | |
| 8390 { | |
| 8391 add(current); | |
| 8392 goto scan_number_zero; | |
| 8393 } | |
| 8394 | |
| 8395 case '1': | |
| 8396 case '2': | |
| 8397 case '3': | |
| 8398 case '4': | |
| 8399 case '5': | |
| 8400 case '6': | |
| 8401 case '7': | |
| 8402 case '8': | |
| 8403 case '9': | |
| 8404 { | |
| 8405 add(current); | |
| 8406 goto scan_number_any1; | |
| 8407 } | |
| 8408 | |
| 8409 default: | |
| 8410 { | |
| 8411 error_message = "invalid number; expected digit after '-'"; | |
| 8412 return token_type::parse_error; | |
| 8413 } | |
| 8414 } | |
| 8415 | |
| 8416 scan_number_zero: | |
| 8417 // state: we just parse a zero (maybe with a leading minus sign) | |
| 8418 switch (get()) | |
| 8419 { | |
| 8420 case '.': | |
| 8421 { | |
| 8422 add(decimal_point_char); | |
| 8423 goto scan_number_decimal1; | |
| 8424 } | |
| 8425 | |
| 8426 case 'e': | |
| 8427 case 'E': | |
| 8428 { | |
| 8429 add(current); | |
| 8430 goto scan_number_exponent; | |
| 8431 } | |
| 8432 | |
| 8433 default: | |
| 8434 goto scan_number_done; | |
| 8435 } | |
| 8436 | |
| 8437 scan_number_any1: | |
| 8438 // state: we just parsed a number 0-9 (maybe with a leading minus sign) | |
| 8439 switch (get()) | |
| 8440 { | |
| 8441 case '0': | |
| 8442 case '1': | |
| 8443 case '2': | |
| 8444 case '3': | |
| 8445 case '4': | |
| 8446 case '5': | |
| 8447 case '6': | |
| 8448 case '7': | |
| 8449 case '8': | |
| 8450 case '9': | |
| 8451 { | |
| 8452 add(current); | |
| 8453 goto scan_number_any1; | |
| 8454 } | |
| 8455 | |
| 8456 case '.': | |
| 8457 { | |
| 8458 add(decimal_point_char); | |
| 8459 goto scan_number_decimal1; | |
| 8460 } | |
| 8461 | |
| 8462 case 'e': | |
| 8463 case 'E': | |
| 8464 { | |
| 8465 add(current); | |
| 8466 goto scan_number_exponent; | |
| 8467 } | |
| 8468 | |
| 8469 default: | |
| 8470 goto scan_number_done; | |
| 8471 } | |
| 8472 | |
| 8473 scan_number_decimal1: | |
| 8474 // state: we just parsed a decimal point | |
| 8475 number_type = token_type::value_float; | |
| 8476 switch (get()) | |
| 8477 { | |
| 8478 case '0': | |
| 8479 case '1': | |
| 8480 case '2': | |
| 8481 case '3': | |
| 8482 case '4': | |
| 8483 case '5': | |
| 8484 case '6': | |
| 8485 case '7': | |
| 8486 case '8': | |
| 8487 case '9': | |
| 8488 { | |
| 8489 add(current); | |
| 8490 goto scan_number_decimal2; | |
| 8491 } | |
| 8492 | |
| 8493 default: | |
| 8494 { | |
| 8495 error_message = "invalid number; expected digit after '.'"; | |
| 8496 return token_type::parse_error; | |
| 8497 } | |
| 8498 } | |
| 8499 | |
| 8500 scan_number_decimal2: | |
| 8501 // we just parsed at least one number after a decimal point | |
| 8502 switch (get()) | |
| 8503 { | |
| 8504 case '0': | |
| 8505 case '1': | |
| 8506 case '2': | |
| 8507 case '3': | |
| 8508 case '4': | |
| 8509 case '5': | |
| 8510 case '6': | |
| 8511 case '7': | |
| 8512 case '8': | |
| 8513 case '9': | |
| 8514 { | |
| 8515 add(current); | |
| 8516 goto scan_number_decimal2; | |
| 8517 } | |
| 8518 | |
| 8519 case 'e': | |
| 8520 case 'E': | |
| 8521 { | |
| 8522 add(current); | |
| 8523 goto scan_number_exponent; | |
| 8524 } | |
| 8525 | |
| 8526 default: | |
| 8527 goto scan_number_done; | |
| 8528 } | |
| 8529 | |
| 8530 scan_number_exponent: | |
| 8531 // we just parsed an exponent | |
| 8532 number_type = token_type::value_float; | |
| 8533 switch (get()) | |
| 8534 { | |
| 8535 case '+': | |
| 8536 case '-': | |
| 8537 { | |
| 8538 add(current); | |
| 8539 goto scan_number_sign; | |
| 8540 } | |
| 8541 | |
| 8542 case '0': | |
| 8543 case '1': | |
| 8544 case '2': | |
| 8545 case '3': | |
| 8546 case '4': | |
| 8547 case '5': | |
| 8548 case '6': | |
| 8549 case '7': | |
| 8550 case '8': | |
| 8551 case '9': | |
| 8552 { | |
| 8553 add(current); | |
| 8554 goto scan_number_any2; | |
| 8555 } | |
| 8556 | |
| 8557 default: | |
| 8558 { | |
| 8559 error_message = | |
| 8560 "invalid number; expected '+', '-', or digit after exponent"; | |
| 8561 return token_type::parse_error; | |
| 8562 } | |
| 8563 } | |
| 8564 | |
| 8565 scan_number_sign: | |
| 8566 // we just parsed an exponent sign | |
| 8567 switch (get()) | |
| 8568 { | |
| 8569 case '0': | |
| 8570 case '1': | |
| 8571 case '2': | |
| 8572 case '3': | |
| 8573 case '4': | |
| 8574 case '5': | |
| 8575 case '6': | |
| 8576 case '7': | |
| 8577 case '8': | |
| 8578 case '9': | |
| 8579 { | |
| 8580 add(current); | |
| 8581 goto scan_number_any2; | |
| 8582 } | |
| 8583 | |
| 8584 default: | |
| 8585 { | |
| 8586 error_message = "invalid number; expected digit after exponent sign"; | |
| 8587 return token_type::parse_error; | |
| 8588 } | |
| 8589 } | |
| 8590 | |
| 8591 scan_number_any2: | |
| 8592 // we just parsed a number after the exponent or exponent sign | |
| 8593 switch (get()) | |
| 8594 { | |
| 8595 case '0': | |
| 8596 case '1': | |
| 8597 case '2': | |
| 8598 case '3': | |
| 8599 case '4': | |
| 8600 case '5': | |
| 8601 case '6': | |
| 8602 case '7': | |
| 8603 case '8': | |
| 8604 case '9': | |
| 8605 { | |
| 8606 add(current); | |
| 8607 goto scan_number_any2; | |
| 8608 } | |
| 8609 | |
| 8610 default: | |
| 8611 goto scan_number_done; | |
| 8612 } | |
| 8613 | |
| 8614 scan_number_done: | |
| 8615 // unget the character after the number (we only read it to know that | |
| 8616 // we are done scanning a number) | |
| 8617 unget(); | |
| 8618 | |
| 8619 char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 8620 errno = 0; | |
| 8621 | |
| 8622 // try to parse integers first and fall back to floats | |
| 8623 if (number_type == token_type::value_unsigned) | |
| 8624 { | |
| 8625 const auto x = std::strtoull(token_buffer.data(), &endptr, 10); | |
| 8626 | |
| 8627 // we checked the number format before | |
| 8628 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); | |
| 8629 | |
| 8630 if (errno == 0) | |
| 8631 { | |
| 8632 value_unsigned = static_cast<number_unsigned_t>(x); | |
| 8633 if (value_unsigned == x) | |
| 8634 { | |
| 8635 return token_type::value_unsigned; | |
| 8636 } | |
| 8637 } | |
| 8638 } | |
| 8639 else if (number_type == token_type::value_integer) | |
| 8640 { | |
| 8641 const auto x = std::strtoll(token_buffer.data(), &endptr, 10); | |
| 8642 | |
| 8643 // we checked the number format before | |
| 8644 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); | |
| 8645 | |
| 8646 if (errno == 0) | |
| 8647 { | |
| 8648 value_integer = static_cast<number_integer_t>(x); | |
| 8649 if (value_integer == x) | |
| 8650 { | |
| 8651 return token_type::value_integer; | |
| 8652 } | |
| 8653 } | |
| 8654 } | |
| 8655 | |
| 8656 // this code is reached if we parse a floating-point number or if an | |
| 8657 // integer conversion above failed | |
| 8658 strtof(value_float, token_buffer.data(), &endptr); | |
| 8659 | |
| 8660 // we checked the number format before | |
| 8661 JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); | |
| 8662 | |
| 8663 return token_type::value_float; | |
| 8664 } | |
| 8665 | |
| 8666 /*! | |
| 8667 @param[in] literal_text the literal text to expect | |
| 8668 @param[in] length the length of the passed literal text | |
| 8669 @param[in] return_type the token type to return on success | |
| 8670 */ | |
| 8671 JSON_HEDLEY_NON_NULL(2) | |
| 8672 token_type scan_literal(const char_type* literal_text, const std::size_t length, | |
| 8673 token_type return_type) | |
| 8674 { | |
| 8675 JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]); | |
| 8676 for (std::size_t i = 1; i < length; ++i) | |
| 8677 { | |
| 8678 if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i])) | |
| 8679 { | |
| 8680 error_message = "invalid literal"; | |
| 8681 return token_type::parse_error; | |
| 8682 } | |
| 8683 } | |
| 8684 return return_type; | |
| 8685 } | |
| 8686 | |
| 8687 ///////////////////// | |
| 8688 // input management | |
| 8689 ///////////////////// | |
| 8690 | |
| 8691 /// reset token_buffer; current character is beginning of token | |
| 8692 void reset() noexcept | |
| 8693 { | |
| 8694 token_buffer.clear(); | |
| 8695 token_string.clear(); | |
| 8696 token_string.push_back(char_traits<char_type>::to_char_type(current)); | |
| 8697 } | |
| 8698 | |
| 8699 /* | |
| 8700 @brief get next character from the input | |
| 8701 | |
| 8702 This function provides the interface to the used input adapter. It does | |
| 8703 not throw in case the input reached EOF, but returns a | |
| 8704 `char_traits<char>::eof()` in that case. Stores the scanned characters | |
| 8705 for use in error messages. | |
| 8706 | |
| 8707 @return character read from the input | |
| 8708 */ | |
| 8709 char_int_type get() | |
| 8710 { | |
| 8711 ++position.chars_read_total; | |
| 8712 ++position.chars_read_current_line; | |
| 8713 | |
| 8714 if (next_unget) | |
| 8715 { | |
| 8716 // just reset the next_unget variable and work with current | |
| 8717 next_unget = false; | |
| 8718 } | |
| 8719 else | |
| 8720 { | |
| 8721 current = ia.get_character(); | |
| 8722 } | |
| 8723 | |
| 8724 if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof())) | |
| 8725 { | |
| 8726 token_string.push_back(char_traits<char_type>::to_char_type(current)); | |
| 8727 } | |
| 8728 | |
| 8729 if (current == '\n') | |
| 8730 { | |
| 8731 ++position.lines_read; | |
| 8732 position.chars_read_current_line = 0; | |
| 8733 } | |
| 8734 | |
| 8735 return current; | |
| 8736 } | |
| 8737 | |
| 8738 /*! | |
| 8739 @brief unget current character (read it again on next get) | |
| 8740 | |
| 8741 We implement unget by setting variable next_unget to true. The input is not | |
| 8742 changed - we just simulate ungetting by modifying chars_read_total, | |
| 8743 chars_read_current_line, and token_string. The next call to get() will | |
| 8744 behave as if the unget character is read again. | |
| 8745 */ | |
| 8746 void unget() | |
| 8747 { | |
| 8748 next_unget = true; | |
| 8749 | |
| 8750 --position.chars_read_total; | |
| 8751 | |
| 8752 // in case we "unget" a newline, we have to also decrement the lines_read | |
| 8753 if (position.chars_read_current_line == 0) | |
| 8754 { | |
| 8755 if (position.lines_read > 0) | |
| 8756 { | |
| 8757 --position.lines_read; | |
| 8758 } | |
| 8759 } | |
| 8760 else | |
| 8761 { | |
| 8762 --position.chars_read_current_line; | |
| 8763 } | |
| 8764 | |
| 8765 if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof())) | |
| 8766 { | |
| 8767 JSON_ASSERT(!token_string.empty()); | |
| 8768 token_string.pop_back(); | |
| 8769 } | |
| 8770 } | |
| 8771 | |
| 8772 /// add a character to token_buffer | |
| 8773 void add(char_int_type c) | |
| 8774 { | |
| 8775 token_buffer.push_back(static_cast<typename string_t::value_type>(c)); | |
| 8776 } | |
| 8777 | |
| 8778 public: | |
| 8779 ///////////////////// | |
| 8780 // value getters | |
| 8781 ///////////////////// | |
| 8782 | |
| 8783 /// return integer value | |
| 8784 constexpr number_integer_t get_number_integer() const noexcept | |
| 8785 { | |
| 8786 return value_integer; | |
| 8787 } | |
| 8788 | |
| 8789 /// return unsigned integer value | |
| 8790 constexpr number_unsigned_t get_number_unsigned() const noexcept | |
| 8791 { | |
| 8792 return value_unsigned; | |
| 8793 } | |
| 8794 | |
| 8795 /// return floating-point value | |
| 8796 constexpr number_float_t get_number_float() const noexcept | |
| 8797 { | |
| 8798 return value_float; | |
| 8799 } | |
| 8800 | |
| 8801 /// return current string value (implicitly resets the token; useful only once) | |
| 8802 string_t& get_string() | |
| 8803 { | |
| 8804 return token_buffer; | |
| 8805 } | |
| 8806 | |
| 8807 ///////////////////// | |
| 8808 // diagnostics | |
| 8809 ///////////////////// | |
| 8810 | |
| 8811 /// return position of last read token | |
| 8812 constexpr position_t get_position() const noexcept | |
| 8813 { | |
| 8814 return position; | |
| 8815 } | |
| 8816 | |
| 8817 /// return the last read token (for errors only). Will never contain EOF | |
| 8818 /// (an arbitrary value that is not a valid char value, often -1), because | |
| 8819 /// 255 may legitimately occur. May contain NUL, which should be escaped. | |
| 8820 std::string get_token_string() const | |
| 8821 { | |
| 8822 // escape control characters | |
| 8823 std::string result; | |
| 8824 for (const auto c : token_string) | |
| 8825 { | |
| 8826 if (static_cast<unsigned char>(c) <= '\x1F') | |
| 8827 { | |
| 8828 // escape control characters | |
| 8829 std::array<char, 9> cs{{}}; | |
| 8830 static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 8831 result += cs.data(); | |
| 8832 } | |
| 8833 else | |
| 8834 { | |
| 8835 // add character as is | |
| 8836 result.push_back(static_cast<std::string::value_type>(c)); | |
| 8837 } | |
| 8838 } | |
| 8839 | |
| 8840 return result; | |
| 8841 } | |
| 8842 | |
| 8843 /// return syntax error message | |
| 8844 JSON_HEDLEY_RETURNS_NON_NULL | |
| 8845 constexpr const char* get_error_message() const noexcept | |
| 8846 { | |
| 8847 return error_message; | |
| 8848 } | |
| 8849 | |
| 8850 ///////////////////// | |
| 8851 // actual scanner | |
| 8852 ///////////////////// | |
| 8853 | |
| 8854 /*! | |
| 8855 @brief skip the UTF-8 byte order mark | |
| 8856 @return true iff there is no BOM or the correct BOM has been skipped | |
| 8857 */ | |
| 8858 bool skip_bom() | |
| 8859 { | |
| 8860 if (get() == 0xEF) | |
| 8861 { | |
| 8862 // check if we completely parse the BOM | |
| 8863 return get() == 0xBB && get() == 0xBF; | |
| 8864 } | |
| 8865 | |
| 8866 // the first character is not the beginning of the BOM; unget it to | |
| 8867 // process is later | |
| 8868 unget(); | |
| 8869 return true; | |
| 8870 } | |
| 8871 | |
| 8872 void skip_whitespace() | |
| 8873 { | |
| 8874 do | |
| 8875 { | |
| 8876 get(); | |
| 8877 } | |
| 8878 while (current == ' ' || current == '\t' || current == '\n' || current == '\r'); | |
| 8879 } | |
| 8880 | |
| 8881 token_type scan() | |
| 8882 { | |
| 8883 // initially, skip the BOM | |
| 8884 if (position.chars_read_total == 0 && !skip_bom()) | |
| 8885 { | |
| 8886 error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given"; | |
| 8887 return token_type::parse_error; | |
| 8888 } | |
| 8889 | |
| 8890 // read next character and ignore whitespace | |
| 8891 skip_whitespace(); | |
| 8892 | |
| 8893 // ignore comments | |
| 8894 while (ignore_comments && current == '/') | |
| 8895 { | |
| 8896 if (!scan_comment()) | |
| 8897 { | |
| 8898 return token_type::parse_error; | |
| 8899 } | |
| 8900 | |
| 8901 // skip following whitespace | |
| 8902 skip_whitespace(); | |
| 8903 } | |
| 8904 | |
| 8905 switch (current) | |
| 8906 { | |
| 8907 // structural characters | |
| 8908 case '[': | |
| 8909 return token_type::begin_array; | |
| 8910 case ']': | |
| 8911 return token_type::end_array; | |
| 8912 case '{': | |
| 8913 return token_type::begin_object; | |
| 8914 case '}': | |
| 8915 return token_type::end_object; | |
| 8916 case ':': | |
| 8917 return token_type::name_separator; | |
| 8918 case ',': | |
| 8919 return token_type::value_separator; | |
| 8920 | |
| 8921 // literals | |
| 8922 case 't': | |
| 8923 { | |
| 8924 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')}}; | |
| 8925 return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true); | |
| 8926 } | |
| 8927 case 'f': | |
| 8928 { | |
| 8929 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')}}; | |
| 8930 return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false); | |
| 8931 } | |
| 8932 case 'n': | |
| 8933 { | |
| 8934 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')}}; | |
| 8935 return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null); | |
| 8936 } | |
| 8937 | |
| 8938 // string | |
| 8939 case '\"': | |
| 8940 return scan_string(); | |
| 8941 | |
| 8942 // number | |
| 8943 case '-': | |
| 8944 case '0': | |
| 8945 case '1': | |
| 8946 case '2': | |
| 8947 case '3': | |
| 8948 case '4': | |
| 8949 case '5': | |
| 8950 case '6': | |
| 8951 case '7': | |
| 8952 case '8': | |
| 8953 case '9': | |
| 8954 return scan_number(); | |
| 8955 | |
| 8956 // end of input (the null byte is needed when parsing from | |
| 8957 // string literals) | |
| 8958 case '\0': | |
| 8959 case char_traits<char_type>::eof(): | |
| 8960 return token_type::end_of_input; | |
| 8961 | |
| 8962 // error | |
| 8963 default: | |
| 8964 error_message = "invalid literal"; | |
| 8965 return token_type::parse_error; | |
| 8966 } | |
| 8967 } | |
| 8968 | |
| 8969 private: | |
| 8970 /// input adapter | |
| 8971 InputAdapterType ia; | |
| 8972 | |
| 8973 /// whether comments should be ignored (true) or signaled as errors (false) | |
| 8974 const bool ignore_comments = false; | |
| 8975 | |
| 8976 /// the current character | |
| 8977 char_int_type current = char_traits<char_type>::eof(); | |
| 8978 | |
| 8979 /// whether the next get() call should just return current | |
| 8980 bool next_unget = false; | |
| 8981 | |
| 8982 /// the start position of the current token | |
| 8983 position_t position {}; | |
| 8984 | |
| 8985 /// raw input token string (for error messages) | |
| 8986 std::vector<char_type> token_string {}; | |
| 8987 | |
| 8988 /// buffer for variable-length tokens (numbers, strings) | |
| 8989 string_t token_buffer {}; | |
| 8990 | |
| 8991 /// a description of occurred lexer errors | |
| 8992 const char* error_message = ""; | |
| 8993 | |
| 8994 // number values | |
| 8995 number_integer_t value_integer = 0; | |
| 8996 number_unsigned_t value_unsigned = 0; | |
| 8997 number_float_t value_float = 0; | |
| 8998 | |
| 8999 /// the decimal point | |
| 9000 const char_int_type decimal_point_char = '.'; | |
| 9001 }; | |
| 9002 | |
| 9003 } // namespace detail | |
| 9004 NLOHMANN_JSON_NAMESPACE_END | |
| 9005 | |
| 9006 // #include <nlohmann/detail/macro_scope.hpp> | |
| 9007 | |
| 9008 // #include <nlohmann/detail/meta/is_sax.hpp> | |
| 9009 // __ _____ _____ _____ | |
| 9010 // __| | __| | | | JSON for Modern C++ | |
| 9011 // | | |__ | | | | | | version 3.11.3 | |
| 9012 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 9013 // | |
| 9014 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 9015 // SPDX-License-Identifier: MIT | |
| 9016 | |
| 9017 | |
| 9018 | |
| 9019 #include <cstdint> // size_t | |
| 9020 #include <utility> // declval | |
| 9021 #include <string> // string | |
| 9022 | |
| 9023 // #include <nlohmann/detail/abi_macros.hpp> | |
| 9024 | |
| 9025 // #include <nlohmann/detail/meta/detected.hpp> | |
| 9026 | |
| 9027 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 9028 | |
| 9029 | |
| 9030 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 9031 namespace detail | |
| 9032 { | |
| 9033 | |
| 9034 template<typename T> | |
| 9035 using null_function_t = decltype(std::declval<T&>().null()); | |
| 9036 | |
| 9037 template<typename T> | |
| 9038 using boolean_function_t = | |
| 9039 decltype(std::declval<T&>().boolean(std::declval<bool>())); | |
| 9040 | |
| 9041 template<typename T, typename Integer> | |
| 9042 using number_integer_function_t = | |
| 9043 decltype(std::declval<T&>().number_integer(std::declval<Integer>())); | |
| 9044 | |
| 9045 template<typename T, typename Unsigned> | |
| 9046 using number_unsigned_function_t = | |
| 9047 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>())); | |
| 9048 | |
| 9049 template<typename T, typename Float, typename String> | |
| 9050 using number_float_function_t = decltype(std::declval<T&>().number_float( | |
| 9051 std::declval<Float>(), std::declval<const String&>())); | |
| 9052 | |
| 9053 template<typename T, typename String> | |
| 9054 using string_function_t = | |
| 9055 decltype(std::declval<T&>().string(std::declval<String&>())); | |
| 9056 | |
| 9057 template<typename T, typename Binary> | |
| 9058 using binary_function_t = | |
| 9059 decltype(std::declval<T&>().binary(std::declval<Binary&>())); | |
| 9060 | |
| 9061 template<typename T> | |
| 9062 using start_object_function_t = | |
| 9063 decltype(std::declval<T&>().start_object(std::declval<std::size_t>())); | |
| 9064 | |
| 9065 template<typename T, typename String> | |
| 9066 using key_function_t = | |
| 9067 decltype(std::declval<T&>().key(std::declval<String&>())); | |
| 9068 | |
| 9069 template<typename T> | |
| 9070 using end_object_function_t = decltype(std::declval<T&>().end_object()); | |
| 9071 | |
| 9072 template<typename T> | |
| 9073 using start_array_function_t = | |
| 9074 decltype(std::declval<T&>().start_array(std::declval<std::size_t>())); | |
| 9075 | |
| 9076 template<typename T> | |
| 9077 using end_array_function_t = decltype(std::declval<T&>().end_array()); | |
| 9078 | |
| 9079 template<typename T, typename Exception> | |
| 9080 using parse_error_function_t = decltype(std::declval<T&>().parse_error( | |
| 9081 std::declval<std::size_t>(), std::declval<const std::string&>(), | |
| 9082 std::declval<const Exception&>())); | |
| 9083 | |
| 9084 template<typename SAX, typename BasicJsonType> | |
| 9085 struct is_sax | |
| 9086 { | |
| 9087 private: | |
| 9088 static_assert(is_basic_json<BasicJsonType>::value, | |
| 9089 "BasicJsonType must be of type basic_json<...>"); | |
| 9090 | |
| 9091 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 9092 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 9093 using number_float_t = typename BasicJsonType::number_float_t; | |
| 9094 using string_t = typename BasicJsonType::string_t; | |
| 9095 using binary_t = typename BasicJsonType::binary_t; | |
| 9096 using exception_t = typename BasicJsonType::exception; | |
| 9097 | |
| 9098 public: | |
| 9099 static constexpr bool value = | |
| 9100 is_detected_exact<bool, null_function_t, SAX>::value && | |
| 9101 is_detected_exact<bool, boolean_function_t, SAX>::value && | |
| 9102 is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value && | |
| 9103 is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value && | |
| 9104 is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value && | |
| 9105 is_detected_exact<bool, string_function_t, SAX, string_t>::value && | |
| 9106 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value && | |
| 9107 is_detected_exact<bool, start_object_function_t, SAX>::value && | |
| 9108 is_detected_exact<bool, key_function_t, SAX, string_t>::value && | |
| 9109 is_detected_exact<bool, end_object_function_t, SAX>::value && | |
| 9110 is_detected_exact<bool, start_array_function_t, SAX>::value && | |
| 9111 is_detected_exact<bool, end_array_function_t, SAX>::value && | |
| 9112 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value; | |
| 9113 }; | |
| 9114 | |
| 9115 template<typename SAX, typename BasicJsonType> | |
| 9116 struct is_sax_static_asserts | |
| 9117 { | |
| 9118 private: | |
| 9119 static_assert(is_basic_json<BasicJsonType>::value, | |
| 9120 "BasicJsonType must be of type basic_json<...>"); | |
| 9121 | |
| 9122 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 9123 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 9124 using number_float_t = typename BasicJsonType::number_float_t; | |
| 9125 using string_t = typename BasicJsonType::string_t; | |
| 9126 using binary_t = typename BasicJsonType::binary_t; | |
| 9127 using exception_t = typename BasicJsonType::exception; | |
| 9128 | |
| 9129 public: | |
| 9130 static_assert(is_detected_exact<bool, null_function_t, SAX>::value, | |
| 9131 "Missing/invalid function: bool null()"); | |
| 9132 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value, | |
| 9133 "Missing/invalid function: bool boolean(bool)"); | |
| 9134 static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value, | |
| 9135 "Missing/invalid function: bool boolean(bool)"); | |
| 9136 static_assert( | |
| 9137 is_detected_exact<bool, number_integer_function_t, SAX, | |
| 9138 number_integer_t>::value, | |
| 9139 "Missing/invalid function: bool number_integer(number_integer_t)"); | |
| 9140 static_assert( | |
| 9141 is_detected_exact<bool, number_unsigned_function_t, SAX, | |
| 9142 number_unsigned_t>::value, | |
| 9143 "Missing/invalid function: bool number_unsigned(number_unsigned_t)"); | |
| 9144 static_assert(is_detected_exact<bool, number_float_function_t, SAX, | |
| 9145 number_float_t, string_t>::value, | |
| 9146 "Missing/invalid function: bool number_float(number_float_t, const string_t&)"); | |
| 9147 static_assert( | |
| 9148 is_detected_exact<bool, string_function_t, SAX, string_t>::value, | |
| 9149 "Missing/invalid function: bool string(string_t&)"); | |
| 9150 static_assert( | |
| 9151 is_detected_exact<bool, binary_function_t, SAX, binary_t>::value, | |
| 9152 "Missing/invalid function: bool binary(binary_t&)"); | |
| 9153 static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value, | |
| 9154 "Missing/invalid function: bool start_object(std::size_t)"); | |
| 9155 static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value, | |
| 9156 "Missing/invalid function: bool key(string_t&)"); | |
| 9157 static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value, | |
| 9158 "Missing/invalid function: bool end_object()"); | |
| 9159 static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value, | |
| 9160 "Missing/invalid function: bool start_array(std::size_t)"); | |
| 9161 static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value, | |
| 9162 "Missing/invalid function: bool end_array()"); | |
| 9163 static_assert( | |
| 9164 is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value, | |
| 9165 "Missing/invalid function: bool parse_error(std::size_t, const " | |
| 9166 "std::string&, const exception&)"); | |
| 9167 }; | |
| 9168 | |
| 9169 } // namespace detail | |
| 9170 NLOHMANN_JSON_NAMESPACE_END | |
| 9171 | |
| 9172 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 9173 | |
| 9174 // #include <nlohmann/detail/string_concat.hpp> | |
| 9175 | |
| 9176 // #include <nlohmann/detail/value_t.hpp> | |
| 9177 | |
| 9178 | |
| 9179 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 9180 namespace detail | |
| 9181 { | |
| 9182 | |
| 9183 /// how to treat CBOR tags | |
| 9184 enum class cbor_tag_handler_t | |
| 9185 { | |
| 9186 error, ///< throw a parse_error exception in case of a tag | |
| 9187 ignore, ///< ignore tags | |
| 9188 store ///< store tags as binary type | |
| 9189 }; | |
| 9190 | |
| 9191 /*! | |
| 9192 @brief determine system byte order | |
| 9193 | |
| 9194 @return true if and only if system's byte order is little endian | |
| 9195 | |
| 9196 @note from https://stackoverflow.com/a/1001328/266378 | |
| 9197 */ | |
| 9198 static inline bool little_endianness(int num = 1) noexcept | |
| 9199 { | |
| 9200 return *reinterpret_cast<char*>(&num) == 1; | |
| 9201 } | |
| 9202 | |
| 9203 /////////////////// | |
| 9204 // binary reader // | |
| 9205 /////////////////// | |
| 9206 | |
| 9207 /*! | |
| 9208 @brief deserialization of CBOR, MessagePack, and UBJSON values | |
| 9209 */ | |
| 9210 template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>> | |
| 9211 class binary_reader | |
| 9212 { | |
| 9213 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 9214 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 9215 using number_float_t = typename BasicJsonType::number_float_t; | |
| 9216 using string_t = typename BasicJsonType::string_t; | |
| 9217 using binary_t = typename BasicJsonType::binary_t; | |
| 9218 using json_sax_t = SAX; | |
| 9219 using char_type = typename InputAdapterType::char_type; | |
| 9220 using char_int_type = typename char_traits<char_type>::int_type; | |
| 9221 | |
| 9222 public: | |
| 9223 /*! | |
| 9224 @brief create a binary reader | |
| 9225 | |
| 9226 @param[in] adapter input adapter to read from | |
| 9227 */ | |
| 9228 explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format) | |
| 9229 { | |
| 9230 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {}; | |
| 9231 } | |
| 9232 | |
| 9233 // make class move-only | |
| 9234 binary_reader(const binary_reader&) = delete; | |
| 9235 binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 9236 binary_reader& operator=(const binary_reader&) = delete; | |
| 9237 binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor) | |
| 9238 ~binary_reader() = default; | |
| 9239 | |
| 9240 /*! | |
| 9241 @param[in] format the binary format to parse | |
| 9242 @param[in] sax_ a SAX event processor | |
| 9243 @param[in] strict whether to expect the input to be consumed completed | |
| 9244 @param[in] tag_handler how to treat CBOR tags | |
| 9245 | |
| 9246 @return whether parsing was successful | |
| 9247 */ | |
| 9248 JSON_HEDLEY_NON_NULL(3) | |
| 9249 bool sax_parse(const input_format_t format, | |
| 9250 json_sax_t* sax_, | |
| 9251 const bool strict = true, | |
| 9252 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) | |
| 9253 { | |
| 9254 sax = sax_; | |
| 9255 bool result = false; | |
| 9256 | |
| 9257 switch (format) | |
| 9258 { | |
| 9259 case input_format_t::bson: | |
| 9260 result = parse_bson_internal(); | |
| 9261 break; | |
| 9262 | |
| 9263 case input_format_t::cbor: | |
| 9264 result = parse_cbor_internal(true, tag_handler); | |
| 9265 break; | |
| 9266 | |
| 9267 case input_format_t::msgpack: | |
| 9268 result = parse_msgpack_internal(); | |
| 9269 break; | |
| 9270 | |
| 9271 case input_format_t::ubjson: | |
| 9272 case input_format_t::bjdata: | |
| 9273 result = parse_ubjson_internal(); | |
| 9274 break; | |
| 9275 | |
| 9276 case input_format_t::json: // LCOV_EXCL_LINE | |
| 9277 default: // LCOV_EXCL_LINE | |
| 9278 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 9279 } | |
| 9280 | |
| 9281 // strict mode: next byte must be EOF | |
| 9282 if (result && strict) | |
| 9283 { | |
| 9284 if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata) | |
| 9285 { | |
| 9286 get_ignore_noop(); | |
| 9287 } | |
| 9288 else | |
| 9289 { | |
| 9290 get(); | |
| 9291 } | |
| 9292 | |
| 9293 if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof())) | |
| 9294 { | |
| 9295 return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read, | |
| 9296 exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr)); | |
| 9297 } | |
| 9298 } | |
| 9299 | |
| 9300 return result; | |
| 9301 } | |
| 9302 | |
| 9303 private: | |
| 9304 ////////// | |
| 9305 // BSON // | |
| 9306 ////////// | |
| 9307 | |
| 9308 /*! | |
| 9309 @brief Reads in a BSON-object and passes it to the SAX-parser. | |
| 9310 @return whether a valid BSON-value was passed to the SAX parser | |
| 9311 */ | |
| 9312 bool parse_bson_internal() | |
| 9313 { | |
| 9314 std::int32_t document_size{}; | |
| 9315 get_number<std::int32_t, true>(input_format_t::bson, document_size); | |
| 9316 | |
| 9317 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1)))) | |
| 9318 { | |
| 9319 return false; | |
| 9320 } | |
| 9321 | |
| 9322 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false))) | |
| 9323 { | |
| 9324 return false; | |
| 9325 } | |
| 9326 | |
| 9327 return sax->end_object(); | |
| 9328 } | |
| 9329 | |
| 9330 /*! | |
| 9331 @brief Parses a C-style string from the BSON input. | |
| 9332 @param[in,out] result A reference to the string variable where the read | |
| 9333 string is to be stored. | |
| 9334 @return `true` if the \x00-byte indicating the end of the string was | |
| 9335 encountered before the EOF; false` indicates an unexpected EOF. | |
| 9336 */ | |
| 9337 bool get_bson_cstr(string_t& result) | |
| 9338 { | |
| 9339 auto out = std::back_inserter(result); | |
| 9340 while (true) | |
| 9341 { | |
| 9342 get(); | |
| 9343 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring"))) | |
| 9344 { | |
| 9345 return false; | |
| 9346 } | |
| 9347 if (current == 0x00) | |
| 9348 { | |
| 9349 return true; | |
| 9350 } | |
| 9351 *out++ = static_cast<typename string_t::value_type>(current); | |
| 9352 } | |
| 9353 } | |
| 9354 | |
| 9355 /*! | |
| 9356 @brief Parses a zero-terminated string of length @a len from the BSON | |
| 9357 input. | |
| 9358 @param[in] len The length (including the zero-byte at the end) of the | |
| 9359 string to be read. | |
| 9360 @param[in,out] result A reference to the string variable where the read | |
| 9361 string is to be stored. | |
| 9362 @tparam NumberType The type of the length @a len | |
| 9363 @pre len >= 1 | |
| 9364 @return `true` if the string was successfully parsed | |
| 9365 */ | |
| 9366 template<typename NumberType> | |
| 9367 bool get_bson_string(const NumberType len, string_t& result) | |
| 9368 { | |
| 9369 if (JSON_HEDLEY_UNLIKELY(len < 1)) | |
| 9370 { | |
| 9371 auto last_token = get_token_string(); | |
| 9372 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 9373 exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr)); | |
| 9374 } | |
| 9375 | |
| 9376 return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof(); | |
| 9377 } | |
| 9378 | |
| 9379 /*! | |
| 9380 @brief Parses a byte array input of length @a len from the BSON input. | |
| 9381 @param[in] len The length of the byte array to be read. | |
| 9382 @param[in,out] result A reference to the binary variable where the read | |
| 9383 array is to be stored. | |
| 9384 @tparam NumberType The type of the length @a len | |
| 9385 @pre len >= 0 | |
| 9386 @return `true` if the byte array was successfully parsed | |
| 9387 */ | |
| 9388 template<typename NumberType> | |
| 9389 bool get_bson_binary(const NumberType len, binary_t& result) | |
| 9390 { | |
| 9391 if (JSON_HEDLEY_UNLIKELY(len < 0)) | |
| 9392 { | |
| 9393 auto last_token = get_token_string(); | |
| 9394 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 9395 exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr)); | |
| 9396 } | |
| 9397 | |
| 9398 // All BSON binary values have a subtype | |
| 9399 std::uint8_t subtype{}; | |
| 9400 get_number<std::uint8_t>(input_format_t::bson, subtype); | |
| 9401 result.set_subtype(subtype); | |
| 9402 | |
| 9403 return get_binary(input_format_t::bson, len, result); | |
| 9404 } | |
| 9405 | |
| 9406 /*! | |
| 9407 @brief Read a BSON document element of the given @a element_type. | |
| 9408 @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html | |
| 9409 @param[in] element_type_parse_position The position in the input stream, | |
| 9410 where the `element_type` was read. | |
| 9411 @warning Not all BSON element types are supported yet. An unsupported | |
| 9412 @a element_type will give rise to a parse_error.114: | |
| 9413 Unsupported BSON record type 0x... | |
| 9414 @return whether a valid BSON-object/array was passed to the SAX parser | |
| 9415 */ | |
| 9416 bool parse_bson_element_internal(const char_int_type element_type, | |
| 9417 const std::size_t element_type_parse_position) | |
| 9418 { | |
| 9419 switch (element_type) | |
| 9420 { | |
| 9421 case 0x01: // double | |
| 9422 { | |
| 9423 double number{}; | |
| 9424 return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 9425 } | |
| 9426 | |
| 9427 case 0x02: // string | |
| 9428 { | |
| 9429 std::int32_t len{}; | |
| 9430 string_t value; | |
| 9431 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value); | |
| 9432 } | |
| 9433 | |
| 9434 case 0x03: // object | |
| 9435 { | |
| 9436 return parse_bson_internal(); | |
| 9437 } | |
| 9438 | |
| 9439 case 0x04: // array | |
| 9440 { | |
| 9441 return parse_bson_array(); | |
| 9442 } | |
| 9443 | |
| 9444 case 0x05: // binary | |
| 9445 { | |
| 9446 std::int32_t len{}; | |
| 9447 binary_t value; | |
| 9448 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value); | |
| 9449 } | |
| 9450 | |
| 9451 case 0x08: // boolean | |
| 9452 { | |
| 9453 return sax->boolean(get() != 0); | |
| 9454 } | |
| 9455 | |
| 9456 case 0x0A: // null | |
| 9457 { | |
| 9458 return sax->null(); | |
| 9459 } | |
| 9460 | |
| 9461 case 0x10: // int32 | |
| 9462 { | |
| 9463 std::int32_t value{}; | |
| 9464 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value); | |
| 9465 } | |
| 9466 | |
| 9467 case 0x12: // int64 | |
| 9468 { | |
| 9469 std::int64_t value{}; | |
| 9470 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value); | |
| 9471 } | |
| 9472 | |
| 9473 default: // anything else not supported (yet) | |
| 9474 { | |
| 9475 std::array<char, 3> cr{{}}; | |
| 9476 static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 9477 const std::string cr_str{cr.data()}; | |
| 9478 return sax->parse_error(element_type_parse_position, cr_str, | |
| 9479 parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr)); | |
| 9480 } | |
| 9481 } | |
| 9482 } | |
| 9483 | |
| 9484 /*! | |
| 9485 @brief Read a BSON element list (as specified in the BSON-spec) | |
| 9486 | |
| 9487 The same binary layout is used for objects and arrays, hence it must be | |
| 9488 indicated with the argument @a is_array which one is expected | |
| 9489 (true --> array, false --> object). | |
| 9490 | |
| 9491 @param[in] is_array Determines if the element list being read is to be | |
| 9492 treated as an object (@a is_array == false), or as an | |
| 9493 array (@a is_array == true). | |
| 9494 @return whether a valid BSON-object/array was passed to the SAX parser | |
| 9495 */ | |
| 9496 bool parse_bson_element_list(const bool is_array) | |
| 9497 { | |
| 9498 string_t key; | |
| 9499 | |
| 9500 while (auto element_type = get()) | |
| 9501 { | |
| 9502 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list"))) | |
| 9503 { | |
| 9504 return false; | |
| 9505 } | |
| 9506 | |
| 9507 const std::size_t element_type_parse_position = chars_read; | |
| 9508 if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key))) | |
| 9509 { | |
| 9510 return false; | |
| 9511 } | |
| 9512 | |
| 9513 if (!is_array && !sax->key(key)) | |
| 9514 { | |
| 9515 return false; | |
| 9516 } | |
| 9517 | |
| 9518 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position))) | |
| 9519 { | |
| 9520 return false; | |
| 9521 } | |
| 9522 | |
| 9523 // get_bson_cstr only appends | |
| 9524 key.clear(); | |
| 9525 } | |
| 9526 | |
| 9527 return true; | |
| 9528 } | |
| 9529 | |
| 9530 /*! | |
| 9531 @brief Reads an array from the BSON input and passes it to the SAX-parser. | |
| 9532 @return whether a valid BSON-array was passed to the SAX parser | |
| 9533 */ | |
| 9534 bool parse_bson_array() | |
| 9535 { | |
| 9536 std::int32_t document_size{}; | |
| 9537 get_number<std::int32_t, true>(input_format_t::bson, document_size); | |
| 9538 | |
| 9539 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1)))) | |
| 9540 { | |
| 9541 return false; | |
| 9542 } | |
| 9543 | |
| 9544 if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true))) | |
| 9545 { | |
| 9546 return false; | |
| 9547 } | |
| 9548 | |
| 9549 return sax->end_array(); | |
| 9550 } | |
| 9551 | |
| 9552 ////////// | |
| 9553 // CBOR // | |
| 9554 ////////// | |
| 9555 | |
| 9556 /*! | |
| 9557 @param[in] get_char whether a new character should be retrieved from the | |
| 9558 input (true) or whether the last read character should | |
| 9559 be considered instead (false) | |
| 9560 @param[in] tag_handler how CBOR tags should be treated | |
| 9561 | |
| 9562 @return whether a valid CBOR value was passed to the SAX parser | |
| 9563 */ | |
| 9564 bool parse_cbor_internal(const bool get_char, | |
| 9565 const cbor_tag_handler_t tag_handler) | |
| 9566 { | |
| 9567 switch (get_char ? get() : current) | |
| 9568 { | |
| 9569 // EOF | |
| 9570 case char_traits<char_type>::eof(): | |
| 9571 return unexpect_eof(input_format_t::cbor, "value"); | |
| 9572 | |
| 9573 // Integer 0x00..0x17 (0..23) | |
| 9574 case 0x00: | |
| 9575 case 0x01: | |
| 9576 case 0x02: | |
| 9577 case 0x03: | |
| 9578 case 0x04: | |
| 9579 case 0x05: | |
| 9580 case 0x06: | |
| 9581 case 0x07: | |
| 9582 case 0x08: | |
| 9583 case 0x09: | |
| 9584 case 0x0A: | |
| 9585 case 0x0B: | |
| 9586 case 0x0C: | |
| 9587 case 0x0D: | |
| 9588 case 0x0E: | |
| 9589 case 0x0F: | |
| 9590 case 0x10: | |
| 9591 case 0x11: | |
| 9592 case 0x12: | |
| 9593 case 0x13: | |
| 9594 case 0x14: | |
| 9595 case 0x15: | |
| 9596 case 0x16: | |
| 9597 case 0x17: | |
| 9598 return sax->number_unsigned(static_cast<number_unsigned_t>(current)); | |
| 9599 | |
| 9600 case 0x18: // Unsigned integer (one-byte uint8_t follows) | |
| 9601 { | |
| 9602 std::uint8_t number{}; | |
| 9603 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); | |
| 9604 } | |
| 9605 | |
| 9606 case 0x19: // Unsigned integer (two-byte uint16_t follows) | |
| 9607 { | |
| 9608 std::uint16_t number{}; | |
| 9609 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); | |
| 9610 } | |
| 9611 | |
| 9612 case 0x1A: // Unsigned integer (four-byte uint32_t follows) | |
| 9613 { | |
| 9614 std::uint32_t number{}; | |
| 9615 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); | |
| 9616 } | |
| 9617 | |
| 9618 case 0x1B: // Unsigned integer (eight-byte uint64_t follows) | |
| 9619 { | |
| 9620 std::uint64_t number{}; | |
| 9621 return get_number(input_format_t::cbor, number) && sax->number_unsigned(number); | |
| 9622 } | |
| 9623 | |
| 9624 // Negative integer -1-0x00..-1-0x17 (-1..-24) | |
| 9625 case 0x20: | |
| 9626 case 0x21: | |
| 9627 case 0x22: | |
| 9628 case 0x23: | |
| 9629 case 0x24: | |
| 9630 case 0x25: | |
| 9631 case 0x26: | |
| 9632 case 0x27: | |
| 9633 case 0x28: | |
| 9634 case 0x29: | |
| 9635 case 0x2A: | |
| 9636 case 0x2B: | |
| 9637 case 0x2C: | |
| 9638 case 0x2D: | |
| 9639 case 0x2E: | |
| 9640 case 0x2F: | |
| 9641 case 0x30: | |
| 9642 case 0x31: | |
| 9643 case 0x32: | |
| 9644 case 0x33: | |
| 9645 case 0x34: | |
| 9646 case 0x35: | |
| 9647 case 0x36: | |
| 9648 case 0x37: | |
| 9649 return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current)); | |
| 9650 | |
| 9651 case 0x38: // Negative integer (one-byte uint8_t follows) | |
| 9652 { | |
| 9653 std::uint8_t number{}; | |
| 9654 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number); | |
| 9655 } | |
| 9656 | |
| 9657 case 0x39: // Negative integer -1-n (two-byte uint16_t follows) | |
| 9658 { | |
| 9659 std::uint16_t number{}; | |
| 9660 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number); | |
| 9661 } | |
| 9662 | |
| 9663 case 0x3A: // Negative integer -1-n (four-byte uint32_t follows) | |
| 9664 { | |
| 9665 std::uint32_t number{}; | |
| 9666 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number); | |
| 9667 } | |
| 9668 | |
| 9669 case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows) | |
| 9670 { | |
| 9671 std::uint64_t number{}; | |
| 9672 return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) | |
| 9673 - static_cast<number_integer_t>(number)); | |
| 9674 } | |
| 9675 | |
| 9676 // Binary data (0x00..0x17 bytes follow) | |
| 9677 case 0x40: | |
| 9678 case 0x41: | |
| 9679 case 0x42: | |
| 9680 case 0x43: | |
| 9681 case 0x44: | |
| 9682 case 0x45: | |
| 9683 case 0x46: | |
| 9684 case 0x47: | |
| 9685 case 0x48: | |
| 9686 case 0x49: | |
| 9687 case 0x4A: | |
| 9688 case 0x4B: | |
| 9689 case 0x4C: | |
| 9690 case 0x4D: | |
| 9691 case 0x4E: | |
| 9692 case 0x4F: | |
| 9693 case 0x50: | |
| 9694 case 0x51: | |
| 9695 case 0x52: | |
| 9696 case 0x53: | |
| 9697 case 0x54: | |
| 9698 case 0x55: | |
| 9699 case 0x56: | |
| 9700 case 0x57: | |
| 9701 case 0x58: // Binary data (one-byte uint8_t for n follows) | |
| 9702 case 0x59: // Binary data (two-byte uint16_t for n follow) | |
| 9703 case 0x5A: // Binary data (four-byte uint32_t for n follow) | |
| 9704 case 0x5B: // Binary data (eight-byte uint64_t for n follow) | |
| 9705 case 0x5F: // Binary data (indefinite length) | |
| 9706 { | |
| 9707 binary_t b; | |
| 9708 return get_cbor_binary(b) && sax->binary(b); | |
| 9709 } | |
| 9710 | |
| 9711 // UTF-8 string (0x00..0x17 bytes follow) | |
| 9712 case 0x60: | |
| 9713 case 0x61: | |
| 9714 case 0x62: | |
| 9715 case 0x63: | |
| 9716 case 0x64: | |
| 9717 case 0x65: | |
| 9718 case 0x66: | |
| 9719 case 0x67: | |
| 9720 case 0x68: | |
| 9721 case 0x69: | |
| 9722 case 0x6A: | |
| 9723 case 0x6B: | |
| 9724 case 0x6C: | |
| 9725 case 0x6D: | |
| 9726 case 0x6E: | |
| 9727 case 0x6F: | |
| 9728 case 0x70: | |
| 9729 case 0x71: | |
| 9730 case 0x72: | |
| 9731 case 0x73: | |
| 9732 case 0x74: | |
| 9733 case 0x75: | |
| 9734 case 0x76: | |
| 9735 case 0x77: | |
| 9736 case 0x78: // UTF-8 string (one-byte uint8_t for n follows) | |
| 9737 case 0x79: // UTF-8 string (two-byte uint16_t for n follow) | |
| 9738 case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) | |
| 9739 case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) | |
| 9740 case 0x7F: // UTF-8 string (indefinite length) | |
| 9741 { | |
| 9742 string_t s; | |
| 9743 return get_cbor_string(s) && sax->string(s); | |
| 9744 } | |
| 9745 | |
| 9746 // array (0x00..0x17 data items follow) | |
| 9747 case 0x80: | |
| 9748 case 0x81: | |
| 9749 case 0x82: | |
| 9750 case 0x83: | |
| 9751 case 0x84: | |
| 9752 case 0x85: | |
| 9753 case 0x86: | |
| 9754 case 0x87: | |
| 9755 case 0x88: | |
| 9756 case 0x89: | |
| 9757 case 0x8A: | |
| 9758 case 0x8B: | |
| 9759 case 0x8C: | |
| 9760 case 0x8D: | |
| 9761 case 0x8E: | |
| 9762 case 0x8F: | |
| 9763 case 0x90: | |
| 9764 case 0x91: | |
| 9765 case 0x92: | |
| 9766 case 0x93: | |
| 9767 case 0x94: | |
| 9768 case 0x95: | |
| 9769 case 0x96: | |
| 9770 case 0x97: | |
| 9771 return get_cbor_array( | |
| 9772 conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler); | |
| 9773 | |
| 9774 case 0x98: // array (one-byte uint8_t for n follows) | |
| 9775 { | |
| 9776 std::uint8_t len{}; | |
| 9777 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler); | |
| 9778 } | |
| 9779 | |
| 9780 case 0x99: // array (two-byte uint16_t for n follow) | |
| 9781 { | |
| 9782 std::uint16_t len{}; | |
| 9783 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler); | |
| 9784 } | |
| 9785 | |
| 9786 case 0x9A: // array (four-byte uint32_t for n follow) | |
| 9787 { | |
| 9788 std::uint32_t len{}; | |
| 9789 return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler); | |
| 9790 } | |
| 9791 | |
| 9792 case 0x9B: // array (eight-byte uint64_t for n follow) | |
| 9793 { | |
| 9794 std::uint64_t len{}; | |
| 9795 return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler); | |
| 9796 } | |
| 9797 | |
| 9798 case 0x9F: // array (indefinite length) | |
| 9799 return get_cbor_array(static_cast<std::size_t>(-1), tag_handler); | |
| 9800 | |
| 9801 // map (0x00..0x17 pairs of data items follow) | |
| 9802 case 0xA0: | |
| 9803 case 0xA1: | |
| 9804 case 0xA2: | |
| 9805 case 0xA3: | |
| 9806 case 0xA4: | |
| 9807 case 0xA5: | |
| 9808 case 0xA6: | |
| 9809 case 0xA7: | |
| 9810 case 0xA8: | |
| 9811 case 0xA9: | |
| 9812 case 0xAA: | |
| 9813 case 0xAB: | |
| 9814 case 0xAC: | |
| 9815 case 0xAD: | |
| 9816 case 0xAE: | |
| 9817 case 0xAF: | |
| 9818 case 0xB0: | |
| 9819 case 0xB1: | |
| 9820 case 0xB2: | |
| 9821 case 0xB3: | |
| 9822 case 0xB4: | |
| 9823 case 0xB5: | |
| 9824 case 0xB6: | |
| 9825 case 0xB7: | |
| 9826 return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler); | |
| 9827 | |
| 9828 case 0xB8: // map (one-byte uint8_t for n follows) | |
| 9829 { | |
| 9830 std::uint8_t len{}; | |
| 9831 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler); | |
| 9832 } | |
| 9833 | |
| 9834 case 0xB9: // map (two-byte uint16_t for n follow) | |
| 9835 { | |
| 9836 std::uint16_t len{}; | |
| 9837 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler); | |
| 9838 } | |
| 9839 | |
| 9840 case 0xBA: // map (four-byte uint32_t for n follow) | |
| 9841 { | |
| 9842 std::uint32_t len{}; | |
| 9843 return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler); | |
| 9844 } | |
| 9845 | |
| 9846 case 0xBB: // map (eight-byte uint64_t for n follow) | |
| 9847 { | |
| 9848 std::uint64_t len{}; | |
| 9849 return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler); | |
| 9850 } | |
| 9851 | |
| 9852 case 0xBF: // map (indefinite length) | |
| 9853 return get_cbor_object(static_cast<std::size_t>(-1), tag_handler); | |
| 9854 | |
| 9855 case 0xC6: // tagged item | |
| 9856 case 0xC7: | |
| 9857 case 0xC8: | |
| 9858 case 0xC9: | |
| 9859 case 0xCA: | |
| 9860 case 0xCB: | |
| 9861 case 0xCC: | |
| 9862 case 0xCD: | |
| 9863 case 0xCE: | |
| 9864 case 0xCF: | |
| 9865 case 0xD0: | |
| 9866 case 0xD1: | |
| 9867 case 0xD2: | |
| 9868 case 0xD3: | |
| 9869 case 0xD4: | |
| 9870 case 0xD8: // tagged item (1 bytes follow) | |
| 9871 case 0xD9: // tagged item (2 bytes follow) | |
| 9872 case 0xDA: // tagged item (4 bytes follow) | |
| 9873 case 0xDB: // tagged item (8 bytes follow) | |
| 9874 { | |
| 9875 switch (tag_handler) | |
| 9876 { | |
| 9877 case cbor_tag_handler_t::error: | |
| 9878 { | |
| 9879 auto last_token = get_token_string(); | |
| 9880 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 9881 exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); | |
| 9882 } | |
| 9883 | |
| 9884 case cbor_tag_handler_t::ignore: | |
| 9885 { | |
| 9886 // ignore binary subtype | |
| 9887 switch (current) | |
| 9888 { | |
| 9889 case 0xD8: | |
| 9890 { | |
| 9891 std::uint8_t subtype_to_ignore{}; | |
| 9892 get_number(input_format_t::cbor, subtype_to_ignore); | |
| 9893 break; | |
| 9894 } | |
| 9895 case 0xD9: | |
| 9896 { | |
| 9897 std::uint16_t subtype_to_ignore{}; | |
| 9898 get_number(input_format_t::cbor, subtype_to_ignore); | |
| 9899 break; | |
| 9900 } | |
| 9901 case 0xDA: | |
| 9902 { | |
| 9903 std::uint32_t subtype_to_ignore{}; | |
| 9904 get_number(input_format_t::cbor, subtype_to_ignore); | |
| 9905 break; | |
| 9906 } | |
| 9907 case 0xDB: | |
| 9908 { | |
| 9909 std::uint64_t subtype_to_ignore{}; | |
| 9910 get_number(input_format_t::cbor, subtype_to_ignore); | |
| 9911 break; | |
| 9912 } | |
| 9913 default: | |
| 9914 break; | |
| 9915 } | |
| 9916 return parse_cbor_internal(true, tag_handler); | |
| 9917 } | |
| 9918 | |
| 9919 case cbor_tag_handler_t::store: | |
| 9920 { | |
| 9921 binary_t b; | |
| 9922 // use binary subtype and store in binary container | |
| 9923 switch (current) | |
| 9924 { | |
| 9925 case 0xD8: | |
| 9926 { | |
| 9927 std::uint8_t subtype{}; | |
| 9928 get_number(input_format_t::cbor, subtype); | |
| 9929 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype)); | |
| 9930 break; | |
| 9931 } | |
| 9932 case 0xD9: | |
| 9933 { | |
| 9934 std::uint16_t subtype{}; | |
| 9935 get_number(input_format_t::cbor, subtype); | |
| 9936 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype)); | |
| 9937 break; | |
| 9938 } | |
| 9939 case 0xDA: | |
| 9940 { | |
| 9941 std::uint32_t subtype{}; | |
| 9942 get_number(input_format_t::cbor, subtype); | |
| 9943 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype)); | |
| 9944 break; | |
| 9945 } | |
| 9946 case 0xDB: | |
| 9947 { | |
| 9948 std::uint64_t subtype{}; | |
| 9949 get_number(input_format_t::cbor, subtype); | |
| 9950 b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype)); | |
| 9951 break; | |
| 9952 } | |
| 9953 default: | |
| 9954 return parse_cbor_internal(true, tag_handler); | |
| 9955 } | |
| 9956 get(); | |
| 9957 return get_cbor_binary(b) && sax->binary(b); | |
| 9958 } | |
| 9959 | |
| 9960 default: // LCOV_EXCL_LINE | |
| 9961 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 9962 return false; // LCOV_EXCL_LINE | |
| 9963 } | |
| 9964 } | |
| 9965 | |
| 9966 case 0xF4: // false | |
| 9967 return sax->boolean(false); | |
| 9968 | |
| 9969 case 0xF5: // true | |
| 9970 return sax->boolean(true); | |
| 9971 | |
| 9972 case 0xF6: // null | |
| 9973 return sax->null(); | |
| 9974 | |
| 9975 case 0xF9: // Half-Precision Float (two-byte IEEE 754) | |
| 9976 { | |
| 9977 const auto byte1_raw = get(); | |
| 9978 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) | |
| 9979 { | |
| 9980 return false; | |
| 9981 } | |
| 9982 const auto byte2_raw = get(); | |
| 9983 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number"))) | |
| 9984 { | |
| 9985 return false; | |
| 9986 } | |
| 9987 | |
| 9988 const auto byte1 = static_cast<unsigned char>(byte1_raw); | |
| 9989 const auto byte2 = static_cast<unsigned char>(byte2_raw); | |
| 9990 | |
| 9991 // code from RFC 7049, Appendix D, Figure 3: | |
| 9992 // As half-precision floating-point numbers were only added | |
| 9993 // to IEEE 754 in 2008, today's programming platforms often | |
| 9994 // still only have limited support for them. It is very | |
| 9995 // easy to include at least decoding support for them even | |
| 9996 // without such support. An example of a small decoder for | |
| 9997 // half-precision floating-point numbers in the C language | |
| 9998 // is shown in Fig. 3. | |
| 9999 const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2); | |
| 10000 const double val = [&half] | |
| 10001 { | |
| 10002 const int exp = (half >> 10u) & 0x1Fu; | |
| 10003 const unsigned int mant = half & 0x3FFu; | |
| 10004 JSON_ASSERT(0 <= exp&& exp <= 32); | |
| 10005 JSON_ASSERT(mant <= 1024); | |
| 10006 switch (exp) | |
| 10007 { | |
| 10008 case 0: | |
| 10009 return std::ldexp(mant, -24); | |
| 10010 case 31: | |
| 10011 return (mant == 0) | |
| 10012 ? std::numeric_limits<double>::infinity() | |
| 10013 : std::numeric_limits<double>::quiet_NaN(); | |
| 10014 default: | |
| 10015 return std::ldexp(mant + 1024, exp - 25); | |
| 10016 } | |
| 10017 }(); | |
| 10018 return sax->number_float((half & 0x8000u) != 0 | |
| 10019 ? static_cast<number_float_t>(-val) | |
| 10020 : static_cast<number_float_t>(val), ""); | |
| 10021 } | |
| 10022 | |
| 10023 case 0xFA: // Single-Precision Float (four-byte IEEE 754) | |
| 10024 { | |
| 10025 float number{}; | |
| 10026 return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 10027 } | |
| 10028 | |
| 10029 case 0xFB: // Double-Precision Float (eight-byte IEEE 754) | |
| 10030 { | |
| 10031 double number{}; | |
| 10032 return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 10033 } | |
| 10034 | |
| 10035 default: // anything else (0xFF is handled inside the other types) | |
| 10036 { | |
| 10037 auto last_token = get_token_string(); | |
| 10038 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 10039 exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr)); | |
| 10040 } | |
| 10041 } | |
| 10042 } | |
| 10043 | |
| 10044 /*! | |
| 10045 @brief reads a CBOR string | |
| 10046 | |
| 10047 This function first reads starting bytes to determine the expected | |
| 10048 string length and then copies this number of bytes into a string. | |
| 10049 Additionally, CBOR's strings with indefinite lengths are supported. | |
| 10050 | |
| 10051 @param[out] result created string | |
| 10052 | |
| 10053 @return whether string creation completed | |
| 10054 */ | |
| 10055 bool get_cbor_string(string_t& result) | |
| 10056 { | |
| 10057 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string"))) | |
| 10058 { | |
| 10059 return false; | |
| 10060 } | |
| 10061 | |
| 10062 switch (current) | |
| 10063 { | |
| 10064 // UTF-8 string (0x00..0x17 bytes follow) | |
| 10065 case 0x60: | |
| 10066 case 0x61: | |
| 10067 case 0x62: | |
| 10068 case 0x63: | |
| 10069 case 0x64: | |
| 10070 case 0x65: | |
| 10071 case 0x66: | |
| 10072 case 0x67: | |
| 10073 case 0x68: | |
| 10074 case 0x69: | |
| 10075 case 0x6A: | |
| 10076 case 0x6B: | |
| 10077 case 0x6C: | |
| 10078 case 0x6D: | |
| 10079 case 0x6E: | |
| 10080 case 0x6F: | |
| 10081 case 0x70: | |
| 10082 case 0x71: | |
| 10083 case 0x72: | |
| 10084 case 0x73: | |
| 10085 case 0x74: | |
| 10086 case 0x75: | |
| 10087 case 0x76: | |
| 10088 case 0x77: | |
| 10089 { | |
| 10090 return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result); | |
| 10091 } | |
| 10092 | |
| 10093 case 0x78: // UTF-8 string (one-byte uint8_t for n follows) | |
| 10094 { | |
| 10095 std::uint8_t len{}; | |
| 10096 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); | |
| 10097 } | |
| 10098 | |
| 10099 case 0x79: // UTF-8 string (two-byte uint16_t for n follow) | |
| 10100 { | |
| 10101 std::uint16_t len{}; | |
| 10102 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); | |
| 10103 } | |
| 10104 | |
| 10105 case 0x7A: // UTF-8 string (four-byte uint32_t for n follow) | |
| 10106 { | |
| 10107 std::uint32_t len{}; | |
| 10108 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); | |
| 10109 } | |
| 10110 | |
| 10111 case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow) | |
| 10112 { | |
| 10113 std::uint64_t len{}; | |
| 10114 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result); | |
| 10115 } | |
| 10116 | |
| 10117 case 0x7F: // UTF-8 string (indefinite length) | |
| 10118 { | |
| 10119 while (get() != 0xFF) | |
| 10120 { | |
| 10121 string_t chunk; | |
| 10122 if (!get_cbor_string(chunk)) | |
| 10123 { | |
| 10124 return false; | |
| 10125 } | |
| 10126 result.append(chunk); | |
| 10127 } | |
| 10128 return true; | |
| 10129 } | |
| 10130 | |
| 10131 default: | |
| 10132 { | |
| 10133 auto last_token = get_token_string(); | |
| 10134 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, | |
| 10135 exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr)); | |
| 10136 } | |
| 10137 } | |
| 10138 } | |
| 10139 | |
| 10140 /*! | |
| 10141 @brief reads a CBOR byte array | |
| 10142 | |
| 10143 This function first reads starting bytes to determine the expected | |
| 10144 byte array length and then copies this number of bytes into the byte array. | |
| 10145 Additionally, CBOR's byte arrays with indefinite lengths are supported. | |
| 10146 | |
| 10147 @param[out] result created byte array | |
| 10148 | |
| 10149 @return whether byte array creation completed | |
| 10150 */ | |
| 10151 bool get_cbor_binary(binary_t& result) | |
| 10152 { | |
| 10153 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary"))) | |
| 10154 { | |
| 10155 return false; | |
| 10156 } | |
| 10157 | |
| 10158 switch (current) | |
| 10159 { | |
| 10160 // Binary data (0x00..0x17 bytes follow) | |
| 10161 case 0x40: | |
| 10162 case 0x41: | |
| 10163 case 0x42: | |
| 10164 case 0x43: | |
| 10165 case 0x44: | |
| 10166 case 0x45: | |
| 10167 case 0x46: | |
| 10168 case 0x47: | |
| 10169 case 0x48: | |
| 10170 case 0x49: | |
| 10171 case 0x4A: | |
| 10172 case 0x4B: | |
| 10173 case 0x4C: | |
| 10174 case 0x4D: | |
| 10175 case 0x4E: | |
| 10176 case 0x4F: | |
| 10177 case 0x50: | |
| 10178 case 0x51: | |
| 10179 case 0x52: | |
| 10180 case 0x53: | |
| 10181 case 0x54: | |
| 10182 case 0x55: | |
| 10183 case 0x56: | |
| 10184 case 0x57: | |
| 10185 { | |
| 10186 return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result); | |
| 10187 } | |
| 10188 | |
| 10189 case 0x58: // Binary data (one-byte uint8_t for n follows) | |
| 10190 { | |
| 10191 std::uint8_t len{}; | |
| 10192 return get_number(input_format_t::cbor, len) && | |
| 10193 get_binary(input_format_t::cbor, len, result); | |
| 10194 } | |
| 10195 | |
| 10196 case 0x59: // Binary data (two-byte uint16_t for n follow) | |
| 10197 { | |
| 10198 std::uint16_t len{}; | |
| 10199 return get_number(input_format_t::cbor, len) && | |
| 10200 get_binary(input_format_t::cbor, len, result); | |
| 10201 } | |
| 10202 | |
| 10203 case 0x5A: // Binary data (four-byte uint32_t for n follow) | |
| 10204 { | |
| 10205 std::uint32_t len{}; | |
| 10206 return get_number(input_format_t::cbor, len) && | |
| 10207 get_binary(input_format_t::cbor, len, result); | |
| 10208 } | |
| 10209 | |
| 10210 case 0x5B: // Binary data (eight-byte uint64_t for n follow) | |
| 10211 { | |
| 10212 std::uint64_t len{}; | |
| 10213 return get_number(input_format_t::cbor, len) && | |
| 10214 get_binary(input_format_t::cbor, len, result); | |
| 10215 } | |
| 10216 | |
| 10217 case 0x5F: // Binary data (indefinite length) | |
| 10218 { | |
| 10219 while (get() != 0xFF) | |
| 10220 { | |
| 10221 binary_t chunk; | |
| 10222 if (!get_cbor_binary(chunk)) | |
| 10223 { | |
| 10224 return false; | |
| 10225 } | |
| 10226 result.insert(result.end(), chunk.begin(), chunk.end()); | |
| 10227 } | |
| 10228 return true; | |
| 10229 } | |
| 10230 | |
| 10231 default: | |
| 10232 { | |
| 10233 auto last_token = get_token_string(); | |
| 10234 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, | |
| 10235 exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr)); | |
| 10236 } | |
| 10237 } | |
| 10238 } | |
| 10239 | |
| 10240 /*! | |
| 10241 @param[in] len the length of the array or static_cast<std::size_t>(-1) for an | |
| 10242 array of indefinite size | |
| 10243 @param[in] tag_handler how CBOR tags should be treated | |
| 10244 @return whether array creation completed | |
| 10245 */ | |
| 10246 bool get_cbor_array(const std::size_t len, | |
| 10247 const cbor_tag_handler_t tag_handler) | |
| 10248 { | |
| 10249 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len))) | |
| 10250 { | |
| 10251 return false; | |
| 10252 } | |
| 10253 | |
| 10254 if (len != static_cast<std::size_t>(-1)) | |
| 10255 { | |
| 10256 for (std::size_t i = 0; i < len; ++i) | |
| 10257 { | |
| 10258 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) | |
| 10259 { | |
| 10260 return false; | |
| 10261 } | |
| 10262 } | |
| 10263 } | |
| 10264 else | |
| 10265 { | |
| 10266 while (get() != 0xFF) | |
| 10267 { | |
| 10268 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler))) | |
| 10269 { | |
| 10270 return false; | |
| 10271 } | |
| 10272 } | |
| 10273 } | |
| 10274 | |
| 10275 return sax->end_array(); | |
| 10276 } | |
| 10277 | |
| 10278 /*! | |
| 10279 @param[in] len the length of the object or static_cast<std::size_t>(-1) for an | |
| 10280 object of indefinite size | |
| 10281 @param[in] tag_handler how CBOR tags should be treated | |
| 10282 @return whether object creation completed | |
| 10283 */ | |
| 10284 bool get_cbor_object(const std::size_t len, | |
| 10285 const cbor_tag_handler_t tag_handler) | |
| 10286 { | |
| 10287 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len))) | |
| 10288 { | |
| 10289 return false; | |
| 10290 } | |
| 10291 | |
| 10292 if (len != 0) | |
| 10293 { | |
| 10294 string_t key; | |
| 10295 if (len != static_cast<std::size_t>(-1)) | |
| 10296 { | |
| 10297 for (std::size_t i = 0; i < len; ++i) | |
| 10298 { | |
| 10299 get(); | |
| 10300 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key))) | |
| 10301 { | |
| 10302 return false; | |
| 10303 } | |
| 10304 | |
| 10305 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) | |
| 10306 { | |
| 10307 return false; | |
| 10308 } | |
| 10309 key.clear(); | |
| 10310 } | |
| 10311 } | |
| 10312 else | |
| 10313 { | |
| 10314 while (get() != 0xFF) | |
| 10315 { | |
| 10316 if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key))) | |
| 10317 { | |
| 10318 return false; | |
| 10319 } | |
| 10320 | |
| 10321 if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler))) | |
| 10322 { | |
| 10323 return false; | |
| 10324 } | |
| 10325 key.clear(); | |
| 10326 } | |
| 10327 } | |
| 10328 } | |
| 10329 | |
| 10330 return sax->end_object(); | |
| 10331 } | |
| 10332 | |
| 10333 ///////////// | |
| 10334 // MsgPack // | |
| 10335 ///////////// | |
| 10336 | |
| 10337 /*! | |
| 10338 @return whether a valid MessagePack value was passed to the SAX parser | |
| 10339 */ | |
| 10340 bool parse_msgpack_internal() | |
| 10341 { | |
| 10342 switch (get()) | |
| 10343 { | |
| 10344 // EOF | |
| 10345 case char_traits<char_type>::eof(): | |
| 10346 return unexpect_eof(input_format_t::msgpack, "value"); | |
| 10347 | |
| 10348 // positive fixint | |
| 10349 case 0x00: | |
| 10350 case 0x01: | |
| 10351 case 0x02: | |
| 10352 case 0x03: | |
| 10353 case 0x04: | |
| 10354 case 0x05: | |
| 10355 case 0x06: | |
| 10356 case 0x07: | |
| 10357 case 0x08: | |
| 10358 case 0x09: | |
| 10359 case 0x0A: | |
| 10360 case 0x0B: | |
| 10361 case 0x0C: | |
| 10362 case 0x0D: | |
| 10363 case 0x0E: | |
| 10364 case 0x0F: | |
| 10365 case 0x10: | |
| 10366 case 0x11: | |
| 10367 case 0x12: | |
| 10368 case 0x13: | |
| 10369 case 0x14: | |
| 10370 case 0x15: | |
| 10371 case 0x16: | |
| 10372 case 0x17: | |
| 10373 case 0x18: | |
| 10374 case 0x19: | |
| 10375 case 0x1A: | |
| 10376 case 0x1B: | |
| 10377 case 0x1C: | |
| 10378 case 0x1D: | |
| 10379 case 0x1E: | |
| 10380 case 0x1F: | |
| 10381 case 0x20: | |
| 10382 case 0x21: | |
| 10383 case 0x22: | |
| 10384 case 0x23: | |
| 10385 case 0x24: | |
| 10386 case 0x25: | |
| 10387 case 0x26: | |
| 10388 case 0x27: | |
| 10389 case 0x28: | |
| 10390 case 0x29: | |
| 10391 case 0x2A: | |
| 10392 case 0x2B: | |
| 10393 case 0x2C: | |
| 10394 case 0x2D: | |
| 10395 case 0x2E: | |
| 10396 case 0x2F: | |
| 10397 case 0x30: | |
| 10398 case 0x31: | |
| 10399 case 0x32: | |
| 10400 case 0x33: | |
| 10401 case 0x34: | |
| 10402 case 0x35: | |
| 10403 case 0x36: | |
| 10404 case 0x37: | |
| 10405 case 0x38: | |
| 10406 case 0x39: | |
| 10407 case 0x3A: | |
| 10408 case 0x3B: | |
| 10409 case 0x3C: | |
| 10410 case 0x3D: | |
| 10411 case 0x3E: | |
| 10412 case 0x3F: | |
| 10413 case 0x40: | |
| 10414 case 0x41: | |
| 10415 case 0x42: | |
| 10416 case 0x43: | |
| 10417 case 0x44: | |
| 10418 case 0x45: | |
| 10419 case 0x46: | |
| 10420 case 0x47: | |
| 10421 case 0x48: | |
| 10422 case 0x49: | |
| 10423 case 0x4A: | |
| 10424 case 0x4B: | |
| 10425 case 0x4C: | |
| 10426 case 0x4D: | |
| 10427 case 0x4E: | |
| 10428 case 0x4F: | |
| 10429 case 0x50: | |
| 10430 case 0x51: | |
| 10431 case 0x52: | |
| 10432 case 0x53: | |
| 10433 case 0x54: | |
| 10434 case 0x55: | |
| 10435 case 0x56: | |
| 10436 case 0x57: | |
| 10437 case 0x58: | |
| 10438 case 0x59: | |
| 10439 case 0x5A: | |
| 10440 case 0x5B: | |
| 10441 case 0x5C: | |
| 10442 case 0x5D: | |
| 10443 case 0x5E: | |
| 10444 case 0x5F: | |
| 10445 case 0x60: | |
| 10446 case 0x61: | |
| 10447 case 0x62: | |
| 10448 case 0x63: | |
| 10449 case 0x64: | |
| 10450 case 0x65: | |
| 10451 case 0x66: | |
| 10452 case 0x67: | |
| 10453 case 0x68: | |
| 10454 case 0x69: | |
| 10455 case 0x6A: | |
| 10456 case 0x6B: | |
| 10457 case 0x6C: | |
| 10458 case 0x6D: | |
| 10459 case 0x6E: | |
| 10460 case 0x6F: | |
| 10461 case 0x70: | |
| 10462 case 0x71: | |
| 10463 case 0x72: | |
| 10464 case 0x73: | |
| 10465 case 0x74: | |
| 10466 case 0x75: | |
| 10467 case 0x76: | |
| 10468 case 0x77: | |
| 10469 case 0x78: | |
| 10470 case 0x79: | |
| 10471 case 0x7A: | |
| 10472 case 0x7B: | |
| 10473 case 0x7C: | |
| 10474 case 0x7D: | |
| 10475 case 0x7E: | |
| 10476 case 0x7F: | |
| 10477 return sax->number_unsigned(static_cast<number_unsigned_t>(current)); | |
| 10478 | |
| 10479 // fixmap | |
| 10480 case 0x80: | |
| 10481 case 0x81: | |
| 10482 case 0x82: | |
| 10483 case 0x83: | |
| 10484 case 0x84: | |
| 10485 case 0x85: | |
| 10486 case 0x86: | |
| 10487 case 0x87: | |
| 10488 case 0x88: | |
| 10489 case 0x89: | |
| 10490 case 0x8A: | |
| 10491 case 0x8B: | |
| 10492 case 0x8C: | |
| 10493 case 0x8D: | |
| 10494 case 0x8E: | |
| 10495 case 0x8F: | |
| 10496 return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu)); | |
| 10497 | |
| 10498 // fixarray | |
| 10499 case 0x90: | |
| 10500 case 0x91: | |
| 10501 case 0x92: | |
| 10502 case 0x93: | |
| 10503 case 0x94: | |
| 10504 case 0x95: | |
| 10505 case 0x96: | |
| 10506 case 0x97: | |
| 10507 case 0x98: | |
| 10508 case 0x99: | |
| 10509 case 0x9A: | |
| 10510 case 0x9B: | |
| 10511 case 0x9C: | |
| 10512 case 0x9D: | |
| 10513 case 0x9E: | |
| 10514 case 0x9F: | |
| 10515 return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu)); | |
| 10516 | |
| 10517 // fixstr | |
| 10518 case 0xA0: | |
| 10519 case 0xA1: | |
| 10520 case 0xA2: | |
| 10521 case 0xA3: | |
| 10522 case 0xA4: | |
| 10523 case 0xA5: | |
| 10524 case 0xA6: | |
| 10525 case 0xA7: | |
| 10526 case 0xA8: | |
| 10527 case 0xA9: | |
| 10528 case 0xAA: | |
| 10529 case 0xAB: | |
| 10530 case 0xAC: | |
| 10531 case 0xAD: | |
| 10532 case 0xAE: | |
| 10533 case 0xAF: | |
| 10534 case 0xB0: | |
| 10535 case 0xB1: | |
| 10536 case 0xB2: | |
| 10537 case 0xB3: | |
| 10538 case 0xB4: | |
| 10539 case 0xB5: | |
| 10540 case 0xB6: | |
| 10541 case 0xB7: | |
| 10542 case 0xB8: | |
| 10543 case 0xB9: | |
| 10544 case 0xBA: | |
| 10545 case 0xBB: | |
| 10546 case 0xBC: | |
| 10547 case 0xBD: | |
| 10548 case 0xBE: | |
| 10549 case 0xBF: | |
| 10550 case 0xD9: // str 8 | |
| 10551 case 0xDA: // str 16 | |
| 10552 case 0xDB: // str 32 | |
| 10553 { | |
| 10554 string_t s; | |
| 10555 return get_msgpack_string(s) && sax->string(s); | |
| 10556 } | |
| 10557 | |
| 10558 case 0xC0: // nil | |
| 10559 return sax->null(); | |
| 10560 | |
| 10561 case 0xC2: // false | |
| 10562 return sax->boolean(false); | |
| 10563 | |
| 10564 case 0xC3: // true | |
| 10565 return sax->boolean(true); | |
| 10566 | |
| 10567 case 0xC4: // bin 8 | |
| 10568 case 0xC5: // bin 16 | |
| 10569 case 0xC6: // bin 32 | |
| 10570 case 0xC7: // ext 8 | |
| 10571 case 0xC8: // ext 16 | |
| 10572 case 0xC9: // ext 32 | |
| 10573 case 0xD4: // fixext 1 | |
| 10574 case 0xD5: // fixext 2 | |
| 10575 case 0xD6: // fixext 4 | |
| 10576 case 0xD7: // fixext 8 | |
| 10577 case 0xD8: // fixext 16 | |
| 10578 { | |
| 10579 binary_t b; | |
| 10580 return get_msgpack_binary(b) && sax->binary(b); | |
| 10581 } | |
| 10582 | |
| 10583 case 0xCA: // float 32 | |
| 10584 { | |
| 10585 float number{}; | |
| 10586 return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 10587 } | |
| 10588 | |
| 10589 case 0xCB: // float 64 | |
| 10590 { | |
| 10591 double number{}; | |
| 10592 return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 10593 } | |
| 10594 | |
| 10595 case 0xCC: // uint 8 | |
| 10596 { | |
| 10597 std::uint8_t number{}; | |
| 10598 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); | |
| 10599 } | |
| 10600 | |
| 10601 case 0xCD: // uint 16 | |
| 10602 { | |
| 10603 std::uint16_t number{}; | |
| 10604 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); | |
| 10605 } | |
| 10606 | |
| 10607 case 0xCE: // uint 32 | |
| 10608 { | |
| 10609 std::uint32_t number{}; | |
| 10610 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); | |
| 10611 } | |
| 10612 | |
| 10613 case 0xCF: // uint 64 | |
| 10614 { | |
| 10615 std::uint64_t number{}; | |
| 10616 return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number); | |
| 10617 } | |
| 10618 | |
| 10619 case 0xD0: // int 8 | |
| 10620 { | |
| 10621 std::int8_t number{}; | |
| 10622 return get_number(input_format_t::msgpack, number) && sax->number_integer(number); | |
| 10623 } | |
| 10624 | |
| 10625 case 0xD1: // int 16 | |
| 10626 { | |
| 10627 std::int16_t number{}; | |
| 10628 return get_number(input_format_t::msgpack, number) && sax->number_integer(number); | |
| 10629 } | |
| 10630 | |
| 10631 case 0xD2: // int 32 | |
| 10632 { | |
| 10633 std::int32_t number{}; | |
| 10634 return get_number(input_format_t::msgpack, number) && sax->number_integer(number); | |
| 10635 } | |
| 10636 | |
| 10637 case 0xD3: // int 64 | |
| 10638 { | |
| 10639 std::int64_t number{}; | |
| 10640 return get_number(input_format_t::msgpack, number) && sax->number_integer(number); | |
| 10641 } | |
| 10642 | |
| 10643 case 0xDC: // array 16 | |
| 10644 { | |
| 10645 std::uint16_t len{}; | |
| 10646 return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len)); | |
| 10647 } | |
| 10648 | |
| 10649 case 0xDD: // array 32 | |
| 10650 { | |
| 10651 std::uint32_t len{}; | |
| 10652 return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len)); | |
| 10653 } | |
| 10654 | |
| 10655 case 0xDE: // map 16 | |
| 10656 { | |
| 10657 std::uint16_t len{}; | |
| 10658 return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len)); | |
| 10659 } | |
| 10660 | |
| 10661 case 0xDF: // map 32 | |
| 10662 { | |
| 10663 std::uint32_t len{}; | |
| 10664 return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len)); | |
| 10665 } | |
| 10666 | |
| 10667 // negative fixint | |
| 10668 case 0xE0: | |
| 10669 case 0xE1: | |
| 10670 case 0xE2: | |
| 10671 case 0xE3: | |
| 10672 case 0xE4: | |
| 10673 case 0xE5: | |
| 10674 case 0xE6: | |
| 10675 case 0xE7: | |
| 10676 case 0xE8: | |
| 10677 case 0xE9: | |
| 10678 case 0xEA: | |
| 10679 case 0xEB: | |
| 10680 case 0xEC: | |
| 10681 case 0xED: | |
| 10682 case 0xEE: | |
| 10683 case 0xEF: | |
| 10684 case 0xF0: | |
| 10685 case 0xF1: | |
| 10686 case 0xF2: | |
| 10687 case 0xF3: | |
| 10688 case 0xF4: | |
| 10689 case 0xF5: | |
| 10690 case 0xF6: | |
| 10691 case 0xF7: | |
| 10692 case 0xF8: | |
| 10693 case 0xF9: | |
| 10694 case 0xFA: | |
| 10695 case 0xFB: | |
| 10696 case 0xFC: | |
| 10697 case 0xFD: | |
| 10698 case 0xFE: | |
| 10699 case 0xFF: | |
| 10700 return sax->number_integer(static_cast<std::int8_t>(current)); | |
| 10701 | |
| 10702 default: // anything else | |
| 10703 { | |
| 10704 auto last_token = get_token_string(); | |
| 10705 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 10706 exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr)); | |
| 10707 } | |
| 10708 } | |
| 10709 } | |
| 10710 | |
| 10711 /*! | |
| 10712 @brief reads a MessagePack string | |
| 10713 | |
| 10714 This function first reads starting bytes to determine the expected | |
| 10715 string length and then copies this number of bytes into a string. | |
| 10716 | |
| 10717 @param[out] result created string | |
| 10718 | |
| 10719 @return whether string creation completed | |
| 10720 */ | |
| 10721 bool get_msgpack_string(string_t& result) | |
| 10722 { | |
| 10723 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string"))) | |
| 10724 { | |
| 10725 return false; | |
| 10726 } | |
| 10727 | |
| 10728 switch (current) | |
| 10729 { | |
| 10730 // fixstr | |
| 10731 case 0xA0: | |
| 10732 case 0xA1: | |
| 10733 case 0xA2: | |
| 10734 case 0xA3: | |
| 10735 case 0xA4: | |
| 10736 case 0xA5: | |
| 10737 case 0xA6: | |
| 10738 case 0xA7: | |
| 10739 case 0xA8: | |
| 10740 case 0xA9: | |
| 10741 case 0xAA: | |
| 10742 case 0xAB: | |
| 10743 case 0xAC: | |
| 10744 case 0xAD: | |
| 10745 case 0xAE: | |
| 10746 case 0xAF: | |
| 10747 case 0xB0: | |
| 10748 case 0xB1: | |
| 10749 case 0xB2: | |
| 10750 case 0xB3: | |
| 10751 case 0xB4: | |
| 10752 case 0xB5: | |
| 10753 case 0xB6: | |
| 10754 case 0xB7: | |
| 10755 case 0xB8: | |
| 10756 case 0xB9: | |
| 10757 case 0xBA: | |
| 10758 case 0xBB: | |
| 10759 case 0xBC: | |
| 10760 case 0xBD: | |
| 10761 case 0xBE: | |
| 10762 case 0xBF: | |
| 10763 { | |
| 10764 return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result); | |
| 10765 } | |
| 10766 | |
| 10767 case 0xD9: // str 8 | |
| 10768 { | |
| 10769 std::uint8_t len{}; | |
| 10770 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); | |
| 10771 } | |
| 10772 | |
| 10773 case 0xDA: // str 16 | |
| 10774 { | |
| 10775 std::uint16_t len{}; | |
| 10776 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); | |
| 10777 } | |
| 10778 | |
| 10779 case 0xDB: // str 32 | |
| 10780 { | |
| 10781 std::uint32_t len{}; | |
| 10782 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result); | |
| 10783 } | |
| 10784 | |
| 10785 default: | |
| 10786 { | |
| 10787 auto last_token = get_token_string(); | |
| 10788 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, | |
| 10789 exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr)); | |
| 10790 } | |
| 10791 } | |
| 10792 } | |
| 10793 | |
| 10794 /*! | |
| 10795 @brief reads a MessagePack byte array | |
| 10796 | |
| 10797 This function first reads starting bytes to determine the expected | |
| 10798 byte array length and then copies this number of bytes into a byte array. | |
| 10799 | |
| 10800 @param[out] result created byte array | |
| 10801 | |
| 10802 @return whether byte array creation completed | |
| 10803 */ | |
| 10804 bool get_msgpack_binary(binary_t& result) | |
| 10805 { | |
| 10806 // helper function to set the subtype | |
| 10807 auto assign_and_return_true = [&result](std::int8_t subtype) | |
| 10808 { | |
| 10809 result.set_subtype(static_cast<std::uint8_t>(subtype)); | |
| 10810 return true; | |
| 10811 }; | |
| 10812 | |
| 10813 switch (current) | |
| 10814 { | |
| 10815 case 0xC4: // bin 8 | |
| 10816 { | |
| 10817 std::uint8_t len{}; | |
| 10818 return get_number(input_format_t::msgpack, len) && | |
| 10819 get_binary(input_format_t::msgpack, len, result); | |
| 10820 } | |
| 10821 | |
| 10822 case 0xC5: // bin 16 | |
| 10823 { | |
| 10824 std::uint16_t len{}; | |
| 10825 return get_number(input_format_t::msgpack, len) && | |
| 10826 get_binary(input_format_t::msgpack, len, result); | |
| 10827 } | |
| 10828 | |
| 10829 case 0xC6: // bin 32 | |
| 10830 { | |
| 10831 std::uint32_t len{}; | |
| 10832 return get_number(input_format_t::msgpack, len) && | |
| 10833 get_binary(input_format_t::msgpack, len, result); | |
| 10834 } | |
| 10835 | |
| 10836 case 0xC7: // ext 8 | |
| 10837 { | |
| 10838 std::uint8_t len{}; | |
| 10839 std::int8_t subtype{}; | |
| 10840 return get_number(input_format_t::msgpack, len) && | |
| 10841 get_number(input_format_t::msgpack, subtype) && | |
| 10842 get_binary(input_format_t::msgpack, len, result) && | |
| 10843 assign_and_return_true(subtype); | |
| 10844 } | |
| 10845 | |
| 10846 case 0xC8: // ext 16 | |
| 10847 { | |
| 10848 std::uint16_t len{}; | |
| 10849 std::int8_t subtype{}; | |
| 10850 return get_number(input_format_t::msgpack, len) && | |
| 10851 get_number(input_format_t::msgpack, subtype) && | |
| 10852 get_binary(input_format_t::msgpack, len, result) && | |
| 10853 assign_and_return_true(subtype); | |
| 10854 } | |
| 10855 | |
| 10856 case 0xC9: // ext 32 | |
| 10857 { | |
| 10858 std::uint32_t len{}; | |
| 10859 std::int8_t subtype{}; | |
| 10860 return get_number(input_format_t::msgpack, len) && | |
| 10861 get_number(input_format_t::msgpack, subtype) && | |
| 10862 get_binary(input_format_t::msgpack, len, result) && | |
| 10863 assign_and_return_true(subtype); | |
| 10864 } | |
| 10865 | |
| 10866 case 0xD4: // fixext 1 | |
| 10867 { | |
| 10868 std::int8_t subtype{}; | |
| 10869 return get_number(input_format_t::msgpack, subtype) && | |
| 10870 get_binary(input_format_t::msgpack, 1, result) && | |
| 10871 assign_and_return_true(subtype); | |
| 10872 } | |
| 10873 | |
| 10874 case 0xD5: // fixext 2 | |
| 10875 { | |
| 10876 std::int8_t subtype{}; | |
| 10877 return get_number(input_format_t::msgpack, subtype) && | |
| 10878 get_binary(input_format_t::msgpack, 2, result) && | |
| 10879 assign_and_return_true(subtype); | |
| 10880 } | |
| 10881 | |
| 10882 case 0xD6: // fixext 4 | |
| 10883 { | |
| 10884 std::int8_t subtype{}; | |
| 10885 return get_number(input_format_t::msgpack, subtype) && | |
| 10886 get_binary(input_format_t::msgpack, 4, result) && | |
| 10887 assign_and_return_true(subtype); | |
| 10888 } | |
| 10889 | |
| 10890 case 0xD7: // fixext 8 | |
| 10891 { | |
| 10892 std::int8_t subtype{}; | |
| 10893 return get_number(input_format_t::msgpack, subtype) && | |
| 10894 get_binary(input_format_t::msgpack, 8, result) && | |
| 10895 assign_and_return_true(subtype); | |
| 10896 } | |
| 10897 | |
| 10898 case 0xD8: // fixext 16 | |
| 10899 { | |
| 10900 std::int8_t subtype{}; | |
| 10901 return get_number(input_format_t::msgpack, subtype) && | |
| 10902 get_binary(input_format_t::msgpack, 16, result) && | |
| 10903 assign_and_return_true(subtype); | |
| 10904 } | |
| 10905 | |
| 10906 default: // LCOV_EXCL_LINE | |
| 10907 return false; // LCOV_EXCL_LINE | |
| 10908 } | |
| 10909 } | |
| 10910 | |
| 10911 /*! | |
| 10912 @param[in] len the length of the array | |
| 10913 @return whether array creation completed | |
| 10914 */ | |
| 10915 bool get_msgpack_array(const std::size_t len) | |
| 10916 { | |
| 10917 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len))) | |
| 10918 { | |
| 10919 return false; | |
| 10920 } | |
| 10921 | |
| 10922 for (std::size_t i = 0; i < len; ++i) | |
| 10923 { | |
| 10924 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal())) | |
| 10925 { | |
| 10926 return false; | |
| 10927 } | |
| 10928 } | |
| 10929 | |
| 10930 return sax->end_array(); | |
| 10931 } | |
| 10932 | |
| 10933 /*! | |
| 10934 @param[in] len the length of the object | |
| 10935 @return whether object creation completed | |
| 10936 */ | |
| 10937 bool get_msgpack_object(const std::size_t len) | |
| 10938 { | |
| 10939 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len))) | |
| 10940 { | |
| 10941 return false; | |
| 10942 } | |
| 10943 | |
| 10944 string_t key; | |
| 10945 for (std::size_t i = 0; i < len; ++i) | |
| 10946 { | |
| 10947 get(); | |
| 10948 if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key))) | |
| 10949 { | |
| 10950 return false; | |
| 10951 } | |
| 10952 | |
| 10953 if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal())) | |
| 10954 { | |
| 10955 return false; | |
| 10956 } | |
| 10957 key.clear(); | |
| 10958 } | |
| 10959 | |
| 10960 return sax->end_object(); | |
| 10961 } | |
| 10962 | |
| 10963 //////////// | |
| 10964 // UBJSON // | |
| 10965 //////////// | |
| 10966 | |
| 10967 /*! | |
| 10968 @param[in] get_char whether a new character should be retrieved from the | |
| 10969 input (true, default) or whether the last read | |
| 10970 character should be considered instead | |
| 10971 | |
| 10972 @return whether a valid UBJSON value was passed to the SAX parser | |
| 10973 */ | |
| 10974 bool parse_ubjson_internal(const bool get_char = true) | |
| 10975 { | |
| 10976 return get_ubjson_value(get_char ? get_ignore_noop() : current); | |
| 10977 } | |
| 10978 | |
| 10979 /*! | |
| 10980 @brief reads a UBJSON string | |
| 10981 | |
| 10982 This function is either called after reading the 'S' byte explicitly | |
| 10983 indicating a string, or in case of an object key where the 'S' byte can be | |
| 10984 left out. | |
| 10985 | |
| 10986 @param[out] result created string | |
| 10987 @param[in] get_char whether a new character should be retrieved from the | |
| 10988 input (true, default) or whether the last read | |
| 10989 character should be considered instead | |
| 10990 | |
| 10991 @return whether string creation completed | |
| 10992 */ | |
| 10993 bool get_ubjson_string(string_t& result, const bool get_char = true) | |
| 10994 { | |
| 10995 if (get_char) | |
| 10996 { | |
| 10997 get(); // TODO(niels): may we ignore N here? | |
| 10998 } | |
| 10999 | |
| 11000 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) | |
| 11001 { | |
| 11002 return false; | |
| 11003 } | |
| 11004 | |
| 11005 switch (current) | |
| 11006 { | |
| 11007 case 'U': | |
| 11008 { | |
| 11009 std::uint8_t len{}; | |
| 11010 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11011 } | |
| 11012 | |
| 11013 case 'i': | |
| 11014 { | |
| 11015 std::int8_t len{}; | |
| 11016 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11017 } | |
| 11018 | |
| 11019 case 'I': | |
| 11020 { | |
| 11021 std::int16_t len{}; | |
| 11022 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11023 } | |
| 11024 | |
| 11025 case 'l': | |
| 11026 { | |
| 11027 std::int32_t len{}; | |
| 11028 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11029 } | |
| 11030 | |
| 11031 case 'L': | |
| 11032 { | |
| 11033 std::int64_t len{}; | |
| 11034 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11035 } | |
| 11036 | |
| 11037 case 'u': | |
| 11038 { | |
| 11039 if (input_format != input_format_t::bjdata) | |
| 11040 { | |
| 11041 break; | |
| 11042 } | |
| 11043 std::uint16_t len{}; | |
| 11044 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11045 } | |
| 11046 | |
| 11047 case 'm': | |
| 11048 { | |
| 11049 if (input_format != input_format_t::bjdata) | |
| 11050 { | |
| 11051 break; | |
| 11052 } | |
| 11053 std::uint32_t len{}; | |
| 11054 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11055 } | |
| 11056 | |
| 11057 case 'M': | |
| 11058 { | |
| 11059 if (input_format != input_format_t::bjdata) | |
| 11060 { | |
| 11061 break; | |
| 11062 } | |
| 11063 std::uint64_t len{}; | |
| 11064 return get_number(input_format, len) && get_string(input_format, len, result); | |
| 11065 } | |
| 11066 | |
| 11067 default: | |
| 11068 break; | |
| 11069 } | |
| 11070 auto last_token = get_token_string(); | |
| 11071 std::string message; | |
| 11072 | |
| 11073 if (input_format != input_format_t::bjdata) | |
| 11074 { | |
| 11075 message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token; | |
| 11076 } | |
| 11077 else | |
| 11078 { | |
| 11079 message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token; | |
| 11080 } | |
| 11081 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr)); | |
| 11082 } | |
| 11083 | |
| 11084 /*! | |
| 11085 @param[out] dim an integer vector storing the ND array dimensions | |
| 11086 @return whether reading ND array size vector is successful | |
| 11087 */ | |
| 11088 bool get_ubjson_ndarray_size(std::vector<size_t>& dim) | |
| 11089 { | |
| 11090 std::pair<std::size_t, char_int_type> size_and_type; | |
| 11091 size_t dimlen = 0; | |
| 11092 bool no_ndarray = true; | |
| 11093 | |
| 11094 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray))) | |
| 11095 { | |
| 11096 return false; | |
| 11097 } | |
| 11098 | |
| 11099 if (size_and_type.first != npos) | |
| 11100 { | |
| 11101 if (size_and_type.second != 0) | |
| 11102 { | |
| 11103 if (size_and_type.second != 'N') | |
| 11104 { | |
| 11105 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11106 { | |
| 11107 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second))) | |
| 11108 { | |
| 11109 return false; | |
| 11110 } | |
| 11111 dim.push_back(dimlen); | |
| 11112 } | |
| 11113 } | |
| 11114 } | |
| 11115 else | |
| 11116 { | |
| 11117 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11118 { | |
| 11119 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray))) | |
| 11120 { | |
| 11121 return false; | |
| 11122 } | |
| 11123 dim.push_back(dimlen); | |
| 11124 } | |
| 11125 } | |
| 11126 } | |
| 11127 else | |
| 11128 { | |
| 11129 while (current != ']') | |
| 11130 { | |
| 11131 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current))) | |
| 11132 { | |
| 11133 return false; | |
| 11134 } | |
| 11135 dim.push_back(dimlen); | |
| 11136 get_ignore_noop(); | |
| 11137 } | |
| 11138 } | |
| 11139 return true; | |
| 11140 } | |
| 11141 | |
| 11142 /*! | |
| 11143 @param[out] result determined size | |
| 11144 @param[in,out] is_ndarray for input, `true` means already inside an ndarray vector | |
| 11145 or ndarray dimension is not allowed; `false` means ndarray | |
| 11146 is allowed; for output, `true` means an ndarray is found; | |
| 11147 is_ndarray can only return `true` when its initial value | |
| 11148 is `false` | |
| 11149 @param[in] prefix type marker if already read, otherwise set to 0 | |
| 11150 | |
| 11151 @return whether size determination completed | |
| 11152 */ | |
| 11153 bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0) | |
| 11154 { | |
| 11155 if (prefix == 0) | |
| 11156 { | |
| 11157 prefix = get_ignore_noop(); | |
| 11158 } | |
| 11159 | |
| 11160 switch (prefix) | |
| 11161 { | |
| 11162 case 'U': | |
| 11163 { | |
| 11164 std::uint8_t number{}; | |
| 11165 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11166 { | |
| 11167 return false; | |
| 11168 } | |
| 11169 result = static_cast<std::size_t>(number); | |
| 11170 return true; | |
| 11171 } | |
| 11172 | |
| 11173 case 'i': | |
| 11174 { | |
| 11175 std::int8_t number{}; | |
| 11176 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11177 { | |
| 11178 return false; | |
| 11179 } | |
| 11180 if (number < 0) | |
| 11181 { | |
| 11182 return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, | |
| 11183 exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); | |
| 11184 } | |
| 11185 result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char | |
| 11186 return true; | |
| 11187 } | |
| 11188 | |
| 11189 case 'I': | |
| 11190 { | |
| 11191 std::int16_t number{}; | |
| 11192 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11193 { | |
| 11194 return false; | |
| 11195 } | |
| 11196 if (number < 0) | |
| 11197 { | |
| 11198 return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, | |
| 11199 exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); | |
| 11200 } | |
| 11201 result = static_cast<std::size_t>(number); | |
| 11202 return true; | |
| 11203 } | |
| 11204 | |
| 11205 case 'l': | |
| 11206 { | |
| 11207 std::int32_t number{}; | |
| 11208 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11209 { | |
| 11210 return false; | |
| 11211 } | |
| 11212 if (number < 0) | |
| 11213 { | |
| 11214 return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, | |
| 11215 exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); | |
| 11216 } | |
| 11217 result = static_cast<std::size_t>(number); | |
| 11218 return true; | |
| 11219 } | |
| 11220 | |
| 11221 case 'L': | |
| 11222 { | |
| 11223 std::int64_t number{}; | |
| 11224 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11225 { | |
| 11226 return false; | |
| 11227 } | |
| 11228 if (number < 0) | |
| 11229 { | |
| 11230 return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, | |
| 11231 exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr)); | |
| 11232 } | |
| 11233 if (!value_in_range_of<std::size_t>(number)) | |
| 11234 { | |
| 11235 return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, | |
| 11236 exception_message(input_format, "integer value overflow", "size"), nullptr)); | |
| 11237 } | |
| 11238 result = static_cast<std::size_t>(number); | |
| 11239 return true; | |
| 11240 } | |
| 11241 | |
| 11242 case 'u': | |
| 11243 { | |
| 11244 if (input_format != input_format_t::bjdata) | |
| 11245 { | |
| 11246 break; | |
| 11247 } | |
| 11248 std::uint16_t number{}; | |
| 11249 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11250 { | |
| 11251 return false; | |
| 11252 } | |
| 11253 result = static_cast<std::size_t>(number); | |
| 11254 return true; | |
| 11255 } | |
| 11256 | |
| 11257 case 'm': | |
| 11258 { | |
| 11259 if (input_format != input_format_t::bjdata) | |
| 11260 { | |
| 11261 break; | |
| 11262 } | |
| 11263 std::uint32_t number{}; | |
| 11264 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11265 { | |
| 11266 return false; | |
| 11267 } | |
| 11268 result = conditional_static_cast<std::size_t>(number); | |
| 11269 return true; | |
| 11270 } | |
| 11271 | |
| 11272 case 'M': | |
| 11273 { | |
| 11274 if (input_format != input_format_t::bjdata) | |
| 11275 { | |
| 11276 break; | |
| 11277 } | |
| 11278 std::uint64_t number{}; | |
| 11279 if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number))) | |
| 11280 { | |
| 11281 return false; | |
| 11282 } | |
| 11283 if (!value_in_range_of<std::size_t>(number)) | |
| 11284 { | |
| 11285 return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, | |
| 11286 exception_message(input_format, "integer value overflow", "size"), nullptr)); | |
| 11287 } | |
| 11288 result = detail::conditional_static_cast<std::size_t>(number); | |
| 11289 return true; | |
| 11290 } | |
| 11291 | |
| 11292 case '[': | |
| 11293 { | |
| 11294 if (input_format != input_format_t::bjdata) | |
| 11295 { | |
| 11296 break; | |
| 11297 } | |
| 11298 if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array | |
| 11299 { | |
| 11300 return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr)); | |
| 11301 } | |
| 11302 std::vector<size_t> dim; | |
| 11303 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim))) | |
| 11304 { | |
| 11305 return false; | |
| 11306 } | |
| 11307 if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector | |
| 11308 { | |
| 11309 result = dim.at(dim.size() - 1); | |
| 11310 return true; | |
| 11311 } | |
| 11312 if (!dim.empty()) // if ndarray, convert to an object in JData annotated array format | |
| 11313 { | |
| 11314 for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container | |
| 11315 { | |
| 11316 if ( i == 0 ) | |
| 11317 { | |
| 11318 result = 0; | |
| 11319 return true; | |
| 11320 } | |
| 11321 } | |
| 11322 | |
| 11323 string_t key = "_ArraySize_"; | |
| 11324 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size()))) | |
| 11325 { | |
| 11326 return false; | |
| 11327 } | |
| 11328 result = 1; | |
| 11329 for (auto i : dim) | |
| 11330 { | |
| 11331 result *= i; | |
| 11332 if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type() | |
| 11333 { | |
| 11334 return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr)); | |
| 11335 } | |
| 11336 if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i)))) | |
| 11337 { | |
| 11338 return false; | |
| 11339 } | |
| 11340 } | |
| 11341 is_ndarray = true; | |
| 11342 return sax->end_array(); | |
| 11343 } | |
| 11344 result = 0; | |
| 11345 return true; | |
| 11346 } | |
| 11347 | |
| 11348 default: | |
| 11349 break; | |
| 11350 } | |
| 11351 auto last_token = get_token_string(); | |
| 11352 std::string message; | |
| 11353 | |
| 11354 if (input_format != input_format_t::bjdata) | |
| 11355 { | |
| 11356 message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token; | |
| 11357 } | |
| 11358 else | |
| 11359 { | |
| 11360 message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token; | |
| 11361 } | |
| 11362 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr)); | |
| 11363 } | |
| 11364 | |
| 11365 /*! | |
| 11366 @brief determine the type and size for a container | |
| 11367 | |
| 11368 In the optimized UBJSON format, a type and a size can be provided to allow | |
| 11369 for a more compact representation. | |
| 11370 | |
| 11371 @param[out] result pair of the size and the type | |
| 11372 @param[in] inside_ndarray whether the parser is parsing an ND array dimensional vector | |
| 11373 | |
| 11374 @return whether pair creation completed | |
| 11375 */ | |
| 11376 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false) | |
| 11377 { | |
| 11378 result.first = npos; // size | |
| 11379 result.second = 0; // type | |
| 11380 bool is_ndarray = false; | |
| 11381 | |
| 11382 get_ignore_noop(); | |
| 11383 | |
| 11384 if (current == '$') | |
| 11385 { | |
| 11386 result.second = get(); // must not ignore 'N', because 'N' maybe the type | |
| 11387 if (input_format == input_format_t::bjdata | |
| 11388 && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second))) | |
| 11389 { | |
| 11390 auto last_token = get_token_string(); | |
| 11391 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 11392 exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr)); | |
| 11393 } | |
| 11394 | |
| 11395 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type"))) | |
| 11396 { | |
| 11397 return false; | |
| 11398 } | |
| 11399 | |
| 11400 get_ignore_noop(); | |
| 11401 if (JSON_HEDLEY_UNLIKELY(current != '#')) | |
| 11402 { | |
| 11403 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value"))) | |
| 11404 { | |
| 11405 return false; | |
| 11406 } | |
| 11407 auto last_token = get_token_string(); | |
| 11408 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 11409 exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr)); | |
| 11410 } | |
| 11411 | |
| 11412 const bool is_error = get_ubjson_size_value(result.first, is_ndarray); | |
| 11413 if (input_format == input_format_t::bjdata && is_ndarray) | |
| 11414 { | |
| 11415 if (inside_ndarray) | |
| 11416 { | |
| 11417 return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, | |
| 11418 exception_message(input_format, "ndarray can not be recursive", "size"), nullptr)); | |
| 11419 } | |
| 11420 result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters | |
| 11421 } | |
| 11422 return is_error; | |
| 11423 } | |
| 11424 | |
| 11425 if (current == '#') | |
| 11426 { | |
| 11427 const bool is_error = get_ubjson_size_value(result.first, is_ndarray); | |
| 11428 if (input_format == input_format_t::bjdata && is_ndarray) | |
| 11429 { | |
| 11430 return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read, | |
| 11431 exception_message(input_format, "ndarray requires both type and size", "size"), nullptr)); | |
| 11432 } | |
| 11433 return is_error; | |
| 11434 } | |
| 11435 | |
| 11436 return true; | |
| 11437 } | |
| 11438 | |
| 11439 /*! | |
| 11440 @param prefix the previously read or set type prefix | |
| 11441 @return whether value creation completed | |
| 11442 */ | |
| 11443 bool get_ubjson_value(const char_int_type prefix) | |
| 11444 { | |
| 11445 switch (prefix) | |
| 11446 { | |
| 11447 case char_traits<char_type>::eof(): // EOF | |
| 11448 return unexpect_eof(input_format, "value"); | |
| 11449 | |
| 11450 case 'T': // true | |
| 11451 return sax->boolean(true); | |
| 11452 case 'F': // false | |
| 11453 return sax->boolean(false); | |
| 11454 | |
| 11455 case 'Z': // null | |
| 11456 return sax->null(); | |
| 11457 | |
| 11458 case 'U': | |
| 11459 { | |
| 11460 std::uint8_t number{}; | |
| 11461 return get_number(input_format, number) && sax->number_unsigned(number); | |
| 11462 } | |
| 11463 | |
| 11464 case 'i': | |
| 11465 { | |
| 11466 std::int8_t number{}; | |
| 11467 return get_number(input_format, number) && sax->number_integer(number); | |
| 11468 } | |
| 11469 | |
| 11470 case 'I': | |
| 11471 { | |
| 11472 std::int16_t number{}; | |
| 11473 return get_number(input_format, number) && sax->number_integer(number); | |
| 11474 } | |
| 11475 | |
| 11476 case 'l': | |
| 11477 { | |
| 11478 std::int32_t number{}; | |
| 11479 return get_number(input_format, number) && sax->number_integer(number); | |
| 11480 } | |
| 11481 | |
| 11482 case 'L': | |
| 11483 { | |
| 11484 std::int64_t number{}; | |
| 11485 return get_number(input_format, number) && sax->number_integer(number); | |
| 11486 } | |
| 11487 | |
| 11488 case 'u': | |
| 11489 { | |
| 11490 if (input_format != input_format_t::bjdata) | |
| 11491 { | |
| 11492 break; | |
| 11493 } | |
| 11494 std::uint16_t number{}; | |
| 11495 return get_number(input_format, number) && sax->number_unsigned(number); | |
| 11496 } | |
| 11497 | |
| 11498 case 'm': | |
| 11499 { | |
| 11500 if (input_format != input_format_t::bjdata) | |
| 11501 { | |
| 11502 break; | |
| 11503 } | |
| 11504 std::uint32_t number{}; | |
| 11505 return get_number(input_format, number) && sax->number_unsigned(number); | |
| 11506 } | |
| 11507 | |
| 11508 case 'M': | |
| 11509 { | |
| 11510 if (input_format != input_format_t::bjdata) | |
| 11511 { | |
| 11512 break; | |
| 11513 } | |
| 11514 std::uint64_t number{}; | |
| 11515 return get_number(input_format, number) && sax->number_unsigned(number); | |
| 11516 } | |
| 11517 | |
| 11518 case 'h': | |
| 11519 { | |
| 11520 if (input_format != input_format_t::bjdata) | |
| 11521 { | |
| 11522 break; | |
| 11523 } | |
| 11524 const auto byte1_raw = get(); | |
| 11525 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) | |
| 11526 { | |
| 11527 return false; | |
| 11528 } | |
| 11529 const auto byte2_raw = get(); | |
| 11530 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) | |
| 11531 { | |
| 11532 return false; | |
| 11533 } | |
| 11534 | |
| 11535 const auto byte1 = static_cast<unsigned char>(byte1_raw); | |
| 11536 const auto byte2 = static_cast<unsigned char>(byte2_raw); | |
| 11537 | |
| 11538 // code from RFC 7049, Appendix D, Figure 3: | |
| 11539 // As half-precision floating-point numbers were only added | |
| 11540 // to IEEE 754 in 2008, today's programming platforms often | |
| 11541 // still only have limited support for them. It is very | |
| 11542 // easy to include at least decoding support for them even | |
| 11543 // without such support. An example of a small decoder for | |
| 11544 // half-precision floating-point numbers in the C language | |
| 11545 // is shown in Fig. 3. | |
| 11546 const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1); | |
| 11547 const double val = [&half] | |
| 11548 { | |
| 11549 const int exp = (half >> 10u) & 0x1Fu; | |
| 11550 const unsigned int mant = half & 0x3FFu; | |
| 11551 JSON_ASSERT(0 <= exp&& exp <= 32); | |
| 11552 JSON_ASSERT(mant <= 1024); | |
| 11553 switch (exp) | |
| 11554 { | |
| 11555 case 0: | |
| 11556 return std::ldexp(mant, -24); | |
| 11557 case 31: | |
| 11558 return (mant == 0) | |
| 11559 ? std::numeric_limits<double>::infinity() | |
| 11560 : std::numeric_limits<double>::quiet_NaN(); | |
| 11561 default: | |
| 11562 return std::ldexp(mant + 1024, exp - 25); | |
| 11563 } | |
| 11564 }(); | |
| 11565 return sax->number_float((half & 0x8000u) != 0 | |
| 11566 ? static_cast<number_float_t>(-val) | |
| 11567 : static_cast<number_float_t>(val), ""); | |
| 11568 } | |
| 11569 | |
| 11570 case 'd': | |
| 11571 { | |
| 11572 float number{}; | |
| 11573 return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 11574 } | |
| 11575 | |
| 11576 case 'D': | |
| 11577 { | |
| 11578 double number{}; | |
| 11579 return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), ""); | |
| 11580 } | |
| 11581 | |
| 11582 case 'H': | |
| 11583 { | |
| 11584 return get_ubjson_high_precision_number(); | |
| 11585 } | |
| 11586 | |
| 11587 case 'C': // char | |
| 11588 { | |
| 11589 get(); | |
| 11590 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char"))) | |
| 11591 { | |
| 11592 return false; | |
| 11593 } | |
| 11594 if (JSON_HEDLEY_UNLIKELY(current > 127)) | |
| 11595 { | |
| 11596 auto last_token = get_token_string(); | |
| 11597 return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, | |
| 11598 exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr)); | |
| 11599 } | |
| 11600 string_t s(1, static_cast<typename string_t::value_type>(current)); | |
| 11601 return sax->string(s); | |
| 11602 } | |
| 11603 | |
| 11604 case 'S': // string | |
| 11605 { | |
| 11606 string_t s; | |
| 11607 return get_ubjson_string(s) && sax->string(s); | |
| 11608 } | |
| 11609 | |
| 11610 case '[': // array | |
| 11611 return get_ubjson_array(); | |
| 11612 | |
| 11613 case '{': // object | |
| 11614 return get_ubjson_object(); | |
| 11615 | |
| 11616 default: // anything else | |
| 11617 break; | |
| 11618 } | |
| 11619 auto last_token = get_token_string(); | |
| 11620 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr)); | |
| 11621 } | |
| 11622 | |
| 11623 /*! | |
| 11624 @return whether array creation completed | |
| 11625 */ | |
| 11626 bool get_ubjson_array() | |
| 11627 { | |
| 11628 std::pair<std::size_t, char_int_type> size_and_type; | |
| 11629 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type))) | |
| 11630 { | |
| 11631 return false; | |
| 11632 } | |
| 11633 | |
| 11634 // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata): | |
| 11635 // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]} | |
| 11636 | |
| 11637 if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0) | |
| 11638 { | |
| 11639 size_and_type.second &= ~(static_cast<char_int_type>(1) << 8); // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker | |
| 11640 auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t) | |
| 11641 { | |
| 11642 return p.first < t; | |
| 11643 }); | |
| 11644 string_t key = "_ArrayType_"; | |
| 11645 if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second)) | |
| 11646 { | |
| 11647 auto last_token = get_token_string(); | |
| 11648 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 11649 exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr)); | |
| 11650 } | |
| 11651 | |
| 11652 string_t type = it->second; // sax->string() takes a reference | |
| 11653 if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type))) | |
| 11654 { | |
| 11655 return false; | |
| 11656 } | |
| 11657 | |
| 11658 if (size_and_type.second == 'C') | |
| 11659 { | |
| 11660 size_and_type.second = 'U'; | |
| 11661 } | |
| 11662 | |
| 11663 key = "_ArrayData_"; | |
| 11664 if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) )) | |
| 11665 { | |
| 11666 return false; | |
| 11667 } | |
| 11668 | |
| 11669 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11670 { | |
| 11671 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) | |
| 11672 { | |
| 11673 return false; | |
| 11674 } | |
| 11675 } | |
| 11676 | |
| 11677 return (sax->end_array() && sax->end_object()); | |
| 11678 } | |
| 11679 | |
| 11680 if (size_and_type.first != npos) | |
| 11681 { | |
| 11682 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first))) | |
| 11683 { | |
| 11684 return false; | |
| 11685 } | |
| 11686 | |
| 11687 if (size_and_type.second != 0) | |
| 11688 { | |
| 11689 if (size_and_type.second != 'N') | |
| 11690 { | |
| 11691 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11692 { | |
| 11693 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) | |
| 11694 { | |
| 11695 return false; | |
| 11696 } | |
| 11697 } | |
| 11698 } | |
| 11699 } | |
| 11700 else | |
| 11701 { | |
| 11702 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11703 { | |
| 11704 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) | |
| 11705 { | |
| 11706 return false; | |
| 11707 } | |
| 11708 } | |
| 11709 } | |
| 11710 } | |
| 11711 else | |
| 11712 { | |
| 11713 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1)))) | |
| 11714 { | |
| 11715 return false; | |
| 11716 } | |
| 11717 | |
| 11718 while (current != ']') | |
| 11719 { | |
| 11720 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false))) | |
| 11721 { | |
| 11722 return false; | |
| 11723 } | |
| 11724 get_ignore_noop(); | |
| 11725 } | |
| 11726 } | |
| 11727 | |
| 11728 return sax->end_array(); | |
| 11729 } | |
| 11730 | |
| 11731 /*! | |
| 11732 @return whether object creation completed | |
| 11733 */ | |
| 11734 bool get_ubjson_object() | |
| 11735 { | |
| 11736 std::pair<std::size_t, char_int_type> size_and_type; | |
| 11737 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type))) | |
| 11738 { | |
| 11739 return false; | |
| 11740 } | |
| 11741 | |
| 11742 // do not accept ND-array size in objects in BJData | |
| 11743 if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0) | |
| 11744 { | |
| 11745 auto last_token = get_token_string(); | |
| 11746 return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, | |
| 11747 exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr)); | |
| 11748 } | |
| 11749 | |
| 11750 string_t key; | |
| 11751 if (size_and_type.first != npos) | |
| 11752 { | |
| 11753 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first))) | |
| 11754 { | |
| 11755 return false; | |
| 11756 } | |
| 11757 | |
| 11758 if (size_and_type.second != 0) | |
| 11759 { | |
| 11760 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11761 { | |
| 11762 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key))) | |
| 11763 { | |
| 11764 return false; | |
| 11765 } | |
| 11766 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second))) | |
| 11767 { | |
| 11768 return false; | |
| 11769 } | |
| 11770 key.clear(); | |
| 11771 } | |
| 11772 } | |
| 11773 else | |
| 11774 { | |
| 11775 for (std::size_t i = 0; i < size_and_type.first; ++i) | |
| 11776 { | |
| 11777 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key))) | |
| 11778 { | |
| 11779 return false; | |
| 11780 } | |
| 11781 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) | |
| 11782 { | |
| 11783 return false; | |
| 11784 } | |
| 11785 key.clear(); | |
| 11786 } | |
| 11787 } | |
| 11788 } | |
| 11789 else | |
| 11790 { | |
| 11791 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1)))) | |
| 11792 { | |
| 11793 return false; | |
| 11794 } | |
| 11795 | |
| 11796 while (current != '}') | |
| 11797 { | |
| 11798 if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key))) | |
| 11799 { | |
| 11800 return false; | |
| 11801 } | |
| 11802 if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal())) | |
| 11803 { | |
| 11804 return false; | |
| 11805 } | |
| 11806 get_ignore_noop(); | |
| 11807 key.clear(); | |
| 11808 } | |
| 11809 } | |
| 11810 | |
| 11811 return sax->end_object(); | |
| 11812 } | |
| 11813 | |
| 11814 // Note, no reader for UBJSON binary types is implemented because they do | |
| 11815 // not exist | |
| 11816 | |
| 11817 bool get_ubjson_high_precision_number() | |
| 11818 { | |
| 11819 // get size of following number string | |
| 11820 std::size_t size{}; | |
| 11821 bool no_ndarray = true; | |
| 11822 auto res = get_ubjson_size_value(size, no_ndarray); | |
| 11823 if (JSON_HEDLEY_UNLIKELY(!res)) | |
| 11824 { | |
| 11825 return res; | |
| 11826 } | |
| 11827 | |
| 11828 // get number string | |
| 11829 std::vector<char> number_vector; | |
| 11830 for (std::size_t i = 0; i < size; ++i) | |
| 11831 { | |
| 11832 get(); | |
| 11833 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number"))) | |
| 11834 { | |
| 11835 return false; | |
| 11836 } | |
| 11837 number_vector.push_back(static_cast<char>(current)); | |
| 11838 } | |
| 11839 | |
| 11840 // parse number string | |
| 11841 using ia_type = decltype(detail::input_adapter(number_vector)); | |
| 11842 auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false); | |
| 11843 const auto result_number = number_lexer.scan(); | |
| 11844 const auto number_string = number_lexer.get_token_string(); | |
| 11845 const auto result_remainder = number_lexer.scan(); | |
| 11846 | |
| 11847 using token_type = typename detail::lexer_base<BasicJsonType>::token_type; | |
| 11848 | |
| 11849 if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input)) | |
| 11850 { | |
| 11851 return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, | |
| 11852 exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); | |
| 11853 } | |
| 11854 | |
| 11855 switch (result_number) | |
| 11856 { | |
| 11857 case token_type::value_integer: | |
| 11858 return sax->number_integer(number_lexer.get_number_integer()); | |
| 11859 case token_type::value_unsigned: | |
| 11860 return sax->number_unsigned(number_lexer.get_number_unsigned()); | |
| 11861 case token_type::value_float: | |
| 11862 return sax->number_float(number_lexer.get_number_float(), std::move(number_string)); | |
| 11863 case token_type::uninitialized: | |
| 11864 case token_type::literal_true: | |
| 11865 case token_type::literal_false: | |
| 11866 case token_type::literal_null: | |
| 11867 case token_type::value_string: | |
| 11868 case token_type::begin_array: | |
| 11869 case token_type::begin_object: | |
| 11870 case token_type::end_array: | |
| 11871 case token_type::end_object: | |
| 11872 case token_type::name_separator: | |
| 11873 case token_type::value_separator: | |
| 11874 case token_type::parse_error: | |
| 11875 case token_type::end_of_input: | |
| 11876 case token_type::literal_or_value: | |
| 11877 default: | |
| 11878 return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, | |
| 11879 exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr)); | |
| 11880 } | |
| 11881 } | |
| 11882 | |
| 11883 /////////////////////// | |
| 11884 // Utility functions // | |
| 11885 /////////////////////// | |
| 11886 | |
| 11887 /*! | |
| 11888 @brief get next character from the input | |
| 11889 | |
| 11890 This function provides the interface to the used input adapter. It does | |
| 11891 not throw in case the input reached EOF, but returns a -'ve valued | |
| 11892 `char_traits<char_type>::eof()` in that case. | |
| 11893 | |
| 11894 @return character read from the input | |
| 11895 */ | |
| 11896 char_int_type get() | |
| 11897 { | |
| 11898 ++chars_read; | |
| 11899 return current = ia.get_character(); | |
| 11900 } | |
| 11901 | |
| 11902 /*! | |
| 11903 @return character read from the input after ignoring all 'N' entries | |
| 11904 */ | |
| 11905 char_int_type get_ignore_noop() | |
| 11906 { | |
| 11907 do | |
| 11908 { | |
| 11909 get(); | |
| 11910 } | |
| 11911 while (current == 'N'); | |
| 11912 | |
| 11913 return current; | |
| 11914 } | |
| 11915 | |
| 11916 /* | |
| 11917 @brief read a number from the input | |
| 11918 | |
| 11919 @tparam NumberType the type of the number | |
| 11920 @param[in] format the current format (for diagnostics) | |
| 11921 @param[out] result number of type @a NumberType | |
| 11922 | |
| 11923 @return whether conversion completed | |
| 11924 | |
| 11925 @note This function needs to respect the system's endianness, because | |
| 11926 bytes in CBOR, MessagePack, and UBJSON are stored in network order | |
| 11927 (big endian) and therefore need reordering on little endian systems. | |
| 11928 On the other hand, BSON and BJData use little endian and should reorder | |
| 11929 on big endian systems. | |
| 11930 */ | |
| 11931 template<typename NumberType, bool InputIsLittleEndian = false> | |
| 11932 bool get_number(const input_format_t format, NumberType& result) | |
| 11933 { | |
| 11934 // step 1: read input into array with system's byte order | |
| 11935 std::array<std::uint8_t, sizeof(NumberType)> vec{}; | |
| 11936 for (std::size_t i = 0; i < sizeof(NumberType); ++i) | |
| 11937 { | |
| 11938 get(); | |
| 11939 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number"))) | |
| 11940 { | |
| 11941 return false; | |
| 11942 } | |
| 11943 | |
| 11944 // reverse byte order prior to conversion if necessary | |
| 11945 if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata)) | |
| 11946 { | |
| 11947 vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current); | |
| 11948 } | |
| 11949 else | |
| 11950 { | |
| 11951 vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE | |
| 11952 } | |
| 11953 } | |
| 11954 | |
| 11955 // step 2: convert array into number of type T and return | |
| 11956 std::memcpy(&result, vec.data(), sizeof(NumberType)); | |
| 11957 return true; | |
| 11958 } | |
| 11959 | |
| 11960 /*! | |
| 11961 @brief create a string by reading characters from the input | |
| 11962 | |
| 11963 @tparam NumberType the type of the number | |
| 11964 @param[in] format the current format (for diagnostics) | |
| 11965 @param[in] len number of characters to read | |
| 11966 @param[out] result string created by reading @a len bytes | |
| 11967 | |
| 11968 @return whether string creation completed | |
| 11969 | |
| 11970 @note We can not reserve @a len bytes for the result, because @a len | |
| 11971 may be too large. Usually, @ref unexpect_eof() detects the end of | |
| 11972 the input before we run out of string memory. | |
| 11973 */ | |
| 11974 template<typename NumberType> | |
| 11975 bool get_string(const input_format_t format, | |
| 11976 const NumberType len, | |
| 11977 string_t& result) | |
| 11978 { | |
| 11979 bool success = true; | |
| 11980 for (NumberType i = 0; i < len; i++) | |
| 11981 { | |
| 11982 get(); | |
| 11983 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string"))) | |
| 11984 { | |
| 11985 success = false; | |
| 11986 break; | |
| 11987 } | |
| 11988 result.push_back(static_cast<typename string_t::value_type>(current)); | |
| 11989 } | |
| 11990 return success; | |
| 11991 } | |
| 11992 | |
| 11993 /*! | |
| 11994 @brief create a byte array by reading bytes from the input | |
| 11995 | |
| 11996 @tparam NumberType the type of the number | |
| 11997 @param[in] format the current format (for diagnostics) | |
| 11998 @param[in] len number of bytes to read | |
| 11999 @param[out] result byte array created by reading @a len bytes | |
| 12000 | |
| 12001 @return whether byte array creation completed | |
| 12002 | |
| 12003 @note We can not reserve @a len bytes for the result, because @a len | |
| 12004 may be too large. Usually, @ref unexpect_eof() detects the end of | |
| 12005 the input before we run out of memory. | |
| 12006 */ | |
| 12007 template<typename NumberType> | |
| 12008 bool get_binary(const input_format_t format, | |
| 12009 const NumberType len, | |
| 12010 binary_t& result) | |
| 12011 { | |
| 12012 bool success = true; | |
| 12013 for (NumberType i = 0; i < len; i++) | |
| 12014 { | |
| 12015 get(); | |
| 12016 if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary"))) | |
| 12017 { | |
| 12018 success = false; | |
| 12019 break; | |
| 12020 } | |
| 12021 result.push_back(static_cast<std::uint8_t>(current)); | |
| 12022 } | |
| 12023 return success; | |
| 12024 } | |
| 12025 | |
| 12026 /*! | |
| 12027 @param[in] format the current format (for diagnostics) | |
| 12028 @param[in] context further context information (for diagnostics) | |
| 12029 @return whether the last read character is not EOF | |
| 12030 */ | |
| 12031 JSON_HEDLEY_NON_NULL(3) | |
| 12032 bool unexpect_eof(const input_format_t format, const char* context) const | |
| 12033 { | |
| 12034 if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof())) | |
| 12035 { | |
| 12036 return sax->parse_error(chars_read, "<end of file>", | |
| 12037 parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr)); | |
| 12038 } | |
| 12039 return true; | |
| 12040 } | |
| 12041 | |
| 12042 /*! | |
| 12043 @return a string representation of the last read byte | |
| 12044 */ | |
| 12045 std::string get_token_string() const | |
| 12046 { | |
| 12047 std::array<char, 3> cr{{}}; | |
| 12048 static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 12049 return std::string{cr.data()}; | |
| 12050 } | |
| 12051 | |
| 12052 /*! | |
| 12053 @param[in] format the current format | |
| 12054 @param[in] detail a detailed error message | |
| 12055 @param[in] context further context information | |
| 12056 @return a message string to use in the parse_error exceptions | |
| 12057 */ | |
| 12058 std::string exception_message(const input_format_t format, | |
| 12059 const std::string& detail, | |
| 12060 const std::string& context) const | |
| 12061 { | |
| 12062 std::string error_msg = "syntax error while parsing "; | |
| 12063 | |
| 12064 switch (format) | |
| 12065 { | |
| 12066 case input_format_t::cbor: | |
| 12067 error_msg += "CBOR"; | |
| 12068 break; | |
| 12069 | |
| 12070 case input_format_t::msgpack: | |
| 12071 error_msg += "MessagePack"; | |
| 12072 break; | |
| 12073 | |
| 12074 case input_format_t::ubjson: | |
| 12075 error_msg += "UBJSON"; | |
| 12076 break; | |
| 12077 | |
| 12078 case input_format_t::bson: | |
| 12079 error_msg += "BSON"; | |
| 12080 break; | |
| 12081 | |
| 12082 case input_format_t::bjdata: | |
| 12083 error_msg += "BJData"; | |
| 12084 break; | |
| 12085 | |
| 12086 case input_format_t::json: // LCOV_EXCL_LINE | |
| 12087 default: // LCOV_EXCL_LINE | |
| 12088 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 12089 } | |
| 12090 | |
| 12091 return concat(error_msg, ' ', context, ": ", detail); | |
| 12092 } | |
| 12093 | |
| 12094 private: | |
| 12095 static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1); | |
| 12096 | |
| 12097 /// input adapter | |
| 12098 InputAdapterType ia; | |
| 12099 | |
| 12100 /// the current character | |
| 12101 char_int_type current = char_traits<char_type>::eof(); | |
| 12102 | |
| 12103 /// the number of characters read | |
| 12104 std::size_t chars_read = 0; | |
| 12105 | |
| 12106 /// whether we can assume little endianness | |
| 12107 const bool is_little_endian = little_endianness(); | |
| 12108 | |
| 12109 /// input format | |
| 12110 const input_format_t input_format = input_format_t::json; | |
| 12111 | |
| 12112 /// the SAX parser | |
| 12113 json_sax_t* sax = nullptr; | |
| 12114 | |
| 12115 // excluded markers in bjdata optimized type | |
| 12116 #define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \ | |
| 12117 make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{') | |
| 12118 | |
| 12119 #define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \ | |
| 12120 make_array<bjd_type>( \ | |
| 12121 bjd_type{'C', "char"}, \ | |
| 12122 bjd_type{'D', "double"}, \ | |
| 12123 bjd_type{'I', "int16"}, \ | |
| 12124 bjd_type{'L', "int64"}, \ | |
| 12125 bjd_type{'M', "uint64"}, \ | |
| 12126 bjd_type{'U', "uint8"}, \ | |
| 12127 bjd_type{'d', "single"}, \ | |
| 12128 bjd_type{'i', "int8"}, \ | |
| 12129 bjd_type{'l', "int32"}, \ | |
| 12130 bjd_type{'m', "uint32"}, \ | |
| 12131 bjd_type{'u', "uint16"}) | |
| 12132 | |
| 12133 JSON_PRIVATE_UNLESS_TESTED: | |
| 12134 // lookup tables | |
| 12135 // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes) | |
| 12136 const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers = | |
| 12137 JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_; | |
| 12138 | |
| 12139 using bjd_type = std::pair<char_int_type, string_t>; | |
| 12140 // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes) | |
| 12141 const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map = | |
| 12142 JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_; | |
| 12143 | |
| 12144 #undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ | |
| 12145 #undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ | |
| 12146 }; | |
| 12147 | |
| 12148 #ifndef JSON_HAS_CPP_17 | |
| 12149 template<typename BasicJsonType, typename InputAdapterType, typename SAX> | |
| 12150 constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos; | |
| 12151 #endif | |
| 12152 | |
| 12153 } // namespace detail | |
| 12154 NLOHMANN_JSON_NAMESPACE_END | |
| 12155 | |
| 12156 // #include <nlohmann/detail/input/input_adapters.hpp> | |
| 12157 | |
| 12158 // #include <nlohmann/detail/input/lexer.hpp> | |
| 12159 | |
| 12160 // #include <nlohmann/detail/input/parser.hpp> | |
| 12161 // __ _____ _____ _____ | |
| 12162 // __| | __| | | | JSON for Modern C++ | |
| 12163 // | | |__ | | | | | | version 3.11.3 | |
| 12164 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 12165 // | |
| 12166 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 12167 // SPDX-License-Identifier: MIT | |
| 12168 | |
| 12169 | |
| 12170 | |
| 12171 #include <cmath> // isfinite | |
| 12172 #include <cstdint> // uint8_t | |
| 12173 #include <functional> // function | |
| 12174 #include <string> // string | |
| 12175 #include <utility> // move | |
| 12176 #include <vector> // vector | |
| 12177 | |
| 12178 // #include <nlohmann/detail/exceptions.hpp> | |
| 12179 | |
| 12180 // #include <nlohmann/detail/input/input_adapters.hpp> | |
| 12181 | |
| 12182 // #include <nlohmann/detail/input/json_sax.hpp> | |
| 12183 | |
| 12184 // #include <nlohmann/detail/input/lexer.hpp> | |
| 12185 | |
| 12186 // #include <nlohmann/detail/macro_scope.hpp> | |
| 12187 | |
| 12188 // #include <nlohmann/detail/meta/is_sax.hpp> | |
| 12189 | |
| 12190 // #include <nlohmann/detail/string_concat.hpp> | |
| 12191 | |
| 12192 // #include <nlohmann/detail/value_t.hpp> | |
| 12193 | |
| 12194 | |
| 12195 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 12196 namespace detail | |
| 12197 { | |
| 12198 //////////// | |
| 12199 // parser // | |
| 12200 //////////// | |
| 12201 | |
| 12202 enum class parse_event_t : std::uint8_t | |
| 12203 { | |
| 12204 /// the parser read `{` and started to process a JSON object | |
| 12205 object_start, | |
| 12206 /// the parser read `}` and finished processing a JSON object | |
| 12207 object_end, | |
| 12208 /// the parser read `[` and started to process a JSON array | |
| 12209 array_start, | |
| 12210 /// the parser read `]` and finished processing a JSON array | |
| 12211 array_end, | |
| 12212 /// the parser read a key of a value in an object | |
| 12213 key, | |
| 12214 /// the parser finished reading a JSON value | |
| 12215 value | |
| 12216 }; | |
| 12217 | |
| 12218 template<typename BasicJsonType> | |
| 12219 using parser_callback_t = | |
| 12220 std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>; | |
| 12221 | |
| 12222 /*! | |
| 12223 @brief syntax analysis | |
| 12224 | |
| 12225 This class implements a recursive descent parser. | |
| 12226 */ | |
| 12227 template<typename BasicJsonType, typename InputAdapterType> | |
| 12228 class parser | |
| 12229 { | |
| 12230 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 12231 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 12232 using number_float_t = typename BasicJsonType::number_float_t; | |
| 12233 using string_t = typename BasicJsonType::string_t; | |
| 12234 using lexer_t = lexer<BasicJsonType, InputAdapterType>; | |
| 12235 using token_type = typename lexer_t::token_type; | |
| 12236 | |
| 12237 public: | |
| 12238 /// a parser reading from an input adapter | |
| 12239 explicit parser(InputAdapterType&& adapter, | |
| 12240 const parser_callback_t<BasicJsonType> cb = nullptr, | |
| 12241 const bool allow_exceptions_ = true, | |
| 12242 const bool skip_comments = false) | |
| 12243 : callback(cb) | |
| 12244 , m_lexer(std::move(adapter), skip_comments) | |
| 12245 , allow_exceptions(allow_exceptions_) | |
| 12246 { | |
| 12247 // read first token | |
| 12248 get_token(); | |
| 12249 } | |
| 12250 | |
| 12251 /*! | |
| 12252 @brief public parser interface | |
| 12253 | |
| 12254 @param[in] strict whether to expect the last token to be EOF | |
| 12255 @param[in,out] result parsed JSON value | |
| 12256 | |
| 12257 @throw parse_error.101 in case of an unexpected token | |
| 12258 @throw parse_error.102 if to_unicode fails or surrogate error | |
| 12259 @throw parse_error.103 if to_unicode fails | |
| 12260 */ | |
| 12261 void parse(const bool strict, BasicJsonType& result) | |
| 12262 { | |
| 12263 if (callback) | |
| 12264 { | |
| 12265 json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions); | |
| 12266 sax_parse_internal(&sdp); | |
| 12267 | |
| 12268 // in strict mode, input must be completely read | |
| 12269 if (strict && (get_token() != token_type::end_of_input)) | |
| 12270 { | |
| 12271 sdp.parse_error(m_lexer.get_position(), | |
| 12272 m_lexer.get_token_string(), | |
| 12273 parse_error::create(101, m_lexer.get_position(), | |
| 12274 exception_message(token_type::end_of_input, "value"), nullptr)); | |
| 12275 } | |
| 12276 | |
| 12277 // in case of an error, return discarded value | |
| 12278 if (sdp.is_errored()) | |
| 12279 { | |
| 12280 result = value_t::discarded; | |
| 12281 return; | |
| 12282 } | |
| 12283 | |
| 12284 // set top-level value to null if it was discarded by the callback | |
| 12285 // function | |
| 12286 if (result.is_discarded()) | |
| 12287 { | |
| 12288 result = nullptr; | |
| 12289 } | |
| 12290 } | |
| 12291 else | |
| 12292 { | |
| 12293 json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions); | |
| 12294 sax_parse_internal(&sdp); | |
| 12295 | |
| 12296 // in strict mode, input must be completely read | |
| 12297 if (strict && (get_token() != token_type::end_of_input)) | |
| 12298 { | |
| 12299 sdp.parse_error(m_lexer.get_position(), | |
| 12300 m_lexer.get_token_string(), | |
| 12301 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr)); | |
| 12302 } | |
| 12303 | |
| 12304 // in case of an error, return discarded value | |
| 12305 if (sdp.is_errored()) | |
| 12306 { | |
| 12307 result = value_t::discarded; | |
| 12308 return; | |
| 12309 } | |
| 12310 } | |
| 12311 | |
| 12312 result.assert_invariant(); | |
| 12313 } | |
| 12314 | |
| 12315 /*! | |
| 12316 @brief public accept interface | |
| 12317 | |
| 12318 @param[in] strict whether to expect the last token to be EOF | |
| 12319 @return whether the input is a proper JSON text | |
| 12320 */ | |
| 12321 bool accept(const bool strict = true) | |
| 12322 { | |
| 12323 json_sax_acceptor<BasicJsonType> sax_acceptor; | |
| 12324 return sax_parse(&sax_acceptor, strict); | |
| 12325 } | |
| 12326 | |
| 12327 template<typename SAX> | |
| 12328 JSON_HEDLEY_NON_NULL(2) | |
| 12329 bool sax_parse(SAX* sax, const bool strict = true) | |
| 12330 { | |
| 12331 (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {}; | |
| 12332 const bool result = sax_parse_internal(sax); | |
| 12333 | |
| 12334 // strict mode: next byte must be EOF | |
| 12335 if (result && strict && (get_token() != token_type::end_of_input)) | |
| 12336 { | |
| 12337 return sax->parse_error(m_lexer.get_position(), | |
| 12338 m_lexer.get_token_string(), | |
| 12339 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr)); | |
| 12340 } | |
| 12341 | |
| 12342 return result; | |
| 12343 } | |
| 12344 | |
| 12345 private: | |
| 12346 template<typename SAX> | |
| 12347 JSON_HEDLEY_NON_NULL(2) | |
| 12348 bool sax_parse_internal(SAX* sax) | |
| 12349 { | |
| 12350 // stack to remember the hierarchy of structured values we are parsing | |
| 12351 // true = array; false = object | |
| 12352 std::vector<bool> states; | |
| 12353 // value to avoid a goto (see comment where set to true) | |
| 12354 bool skip_to_state_evaluation = false; | |
| 12355 | |
| 12356 while (true) | |
| 12357 { | |
| 12358 if (!skip_to_state_evaluation) | |
| 12359 { | |
| 12360 // invariant: get_token() was called before each iteration | |
| 12361 switch (last_token) | |
| 12362 { | |
| 12363 case token_type::begin_object: | |
| 12364 { | |
| 12365 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1)))) | |
| 12366 { | |
| 12367 return false; | |
| 12368 } | |
| 12369 | |
| 12370 // closing } -> we are done | |
| 12371 if (get_token() == token_type::end_object) | |
| 12372 { | |
| 12373 if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) | |
| 12374 { | |
| 12375 return false; | |
| 12376 } | |
| 12377 break; | |
| 12378 } | |
| 12379 | |
| 12380 // parse key | |
| 12381 if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string)) | |
| 12382 { | |
| 12383 return sax->parse_error(m_lexer.get_position(), | |
| 12384 m_lexer.get_token_string(), | |
| 12385 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr)); | |
| 12386 } | |
| 12387 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) | |
| 12388 { | |
| 12389 return false; | |
| 12390 } | |
| 12391 | |
| 12392 // parse separator (:) | |
| 12393 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) | |
| 12394 { | |
| 12395 return sax->parse_error(m_lexer.get_position(), | |
| 12396 m_lexer.get_token_string(), | |
| 12397 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr)); | |
| 12398 } | |
| 12399 | |
| 12400 // remember we are now inside an object | |
| 12401 states.push_back(false); | |
| 12402 | |
| 12403 // parse values | |
| 12404 get_token(); | |
| 12405 continue; | |
| 12406 } | |
| 12407 | |
| 12408 case token_type::begin_array: | |
| 12409 { | |
| 12410 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1)))) | |
| 12411 { | |
| 12412 return false; | |
| 12413 } | |
| 12414 | |
| 12415 // closing ] -> we are done | |
| 12416 if (get_token() == token_type::end_array) | |
| 12417 { | |
| 12418 if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) | |
| 12419 { | |
| 12420 return false; | |
| 12421 } | |
| 12422 break; | |
| 12423 } | |
| 12424 | |
| 12425 // remember we are now inside an array | |
| 12426 states.push_back(true); | |
| 12427 | |
| 12428 // parse values (no need to call get_token) | |
| 12429 continue; | |
| 12430 } | |
| 12431 | |
| 12432 case token_type::value_float: | |
| 12433 { | |
| 12434 const auto res = m_lexer.get_number_float(); | |
| 12435 | |
| 12436 if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res))) | |
| 12437 { | |
| 12438 return sax->parse_error(m_lexer.get_position(), | |
| 12439 m_lexer.get_token_string(), | |
| 12440 out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr)); | |
| 12441 } | |
| 12442 | |
| 12443 if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string()))) | |
| 12444 { | |
| 12445 return false; | |
| 12446 } | |
| 12447 | |
| 12448 break; | |
| 12449 } | |
| 12450 | |
| 12451 case token_type::literal_false: | |
| 12452 { | |
| 12453 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false))) | |
| 12454 { | |
| 12455 return false; | |
| 12456 } | |
| 12457 break; | |
| 12458 } | |
| 12459 | |
| 12460 case token_type::literal_null: | |
| 12461 { | |
| 12462 if (JSON_HEDLEY_UNLIKELY(!sax->null())) | |
| 12463 { | |
| 12464 return false; | |
| 12465 } | |
| 12466 break; | |
| 12467 } | |
| 12468 | |
| 12469 case token_type::literal_true: | |
| 12470 { | |
| 12471 if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true))) | |
| 12472 { | |
| 12473 return false; | |
| 12474 } | |
| 12475 break; | |
| 12476 } | |
| 12477 | |
| 12478 case token_type::value_integer: | |
| 12479 { | |
| 12480 if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer()))) | |
| 12481 { | |
| 12482 return false; | |
| 12483 } | |
| 12484 break; | |
| 12485 } | |
| 12486 | |
| 12487 case token_type::value_string: | |
| 12488 { | |
| 12489 if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string()))) | |
| 12490 { | |
| 12491 return false; | |
| 12492 } | |
| 12493 break; | |
| 12494 } | |
| 12495 | |
| 12496 case token_type::value_unsigned: | |
| 12497 { | |
| 12498 if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned()))) | |
| 12499 { | |
| 12500 return false; | |
| 12501 } | |
| 12502 break; | |
| 12503 } | |
| 12504 | |
| 12505 case token_type::parse_error: | |
| 12506 { | |
| 12507 // using "uninitialized" to avoid "expected" message | |
| 12508 return sax->parse_error(m_lexer.get_position(), | |
| 12509 m_lexer.get_token_string(), | |
| 12510 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr)); | |
| 12511 } | |
| 12512 case token_type::end_of_input: | |
| 12513 { | |
| 12514 if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1)) | |
| 12515 { | |
| 12516 return sax->parse_error(m_lexer.get_position(), | |
| 12517 m_lexer.get_token_string(), | |
| 12518 parse_error::create(101, m_lexer.get_position(), | |
| 12519 "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr)); | |
| 12520 } | |
| 12521 | |
| 12522 return sax->parse_error(m_lexer.get_position(), | |
| 12523 m_lexer.get_token_string(), | |
| 12524 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr)); | |
| 12525 } | |
| 12526 case token_type::uninitialized: | |
| 12527 case token_type::end_array: | |
| 12528 case token_type::end_object: | |
| 12529 case token_type::name_separator: | |
| 12530 case token_type::value_separator: | |
| 12531 case token_type::literal_or_value: | |
| 12532 default: // the last token was unexpected | |
| 12533 { | |
| 12534 return sax->parse_error(m_lexer.get_position(), | |
| 12535 m_lexer.get_token_string(), | |
| 12536 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr)); | |
| 12537 } | |
| 12538 } | |
| 12539 } | |
| 12540 else | |
| 12541 { | |
| 12542 skip_to_state_evaluation = false; | |
| 12543 } | |
| 12544 | |
| 12545 // we reached this line after we successfully parsed a value | |
| 12546 if (states.empty()) | |
| 12547 { | |
| 12548 // empty stack: we reached the end of the hierarchy: done | |
| 12549 return true; | |
| 12550 } | |
| 12551 | |
| 12552 if (states.back()) // array | |
| 12553 { | |
| 12554 // comma -> next value | |
| 12555 if (get_token() == token_type::value_separator) | |
| 12556 { | |
| 12557 // parse a new value | |
| 12558 get_token(); | |
| 12559 continue; | |
| 12560 } | |
| 12561 | |
| 12562 // closing ] | |
| 12563 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array)) | |
| 12564 { | |
| 12565 if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) | |
| 12566 { | |
| 12567 return false; | |
| 12568 } | |
| 12569 | |
| 12570 // We are done with this array. Before we can parse a | |
| 12571 // new value, we need to evaluate the new state first. | |
| 12572 // By setting skip_to_state_evaluation to false, we | |
| 12573 // are effectively jumping to the beginning of this if. | |
| 12574 JSON_ASSERT(!states.empty()); | |
| 12575 states.pop_back(); | |
| 12576 skip_to_state_evaluation = true; | |
| 12577 continue; | |
| 12578 } | |
| 12579 | |
| 12580 return sax->parse_error(m_lexer.get_position(), | |
| 12581 m_lexer.get_token_string(), | |
| 12582 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr)); | |
| 12583 } | |
| 12584 | |
| 12585 // states.back() is false -> object | |
| 12586 | |
| 12587 // comma -> next value | |
| 12588 if (get_token() == token_type::value_separator) | |
| 12589 { | |
| 12590 // parse key | |
| 12591 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string)) | |
| 12592 { | |
| 12593 return sax->parse_error(m_lexer.get_position(), | |
| 12594 m_lexer.get_token_string(), | |
| 12595 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr)); | |
| 12596 } | |
| 12597 | |
| 12598 if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) | |
| 12599 { | |
| 12600 return false; | |
| 12601 } | |
| 12602 | |
| 12603 // parse separator (:) | |
| 12604 if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) | |
| 12605 { | |
| 12606 return sax->parse_error(m_lexer.get_position(), | |
| 12607 m_lexer.get_token_string(), | |
| 12608 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr)); | |
| 12609 } | |
| 12610 | |
| 12611 // parse values | |
| 12612 get_token(); | |
| 12613 continue; | |
| 12614 } | |
| 12615 | |
| 12616 // closing } | |
| 12617 if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object)) | |
| 12618 { | |
| 12619 if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) | |
| 12620 { | |
| 12621 return false; | |
| 12622 } | |
| 12623 | |
| 12624 // We are done with this object. Before we can parse a | |
| 12625 // new value, we need to evaluate the new state first. | |
| 12626 // By setting skip_to_state_evaluation to false, we | |
| 12627 // are effectively jumping to the beginning of this if. | |
| 12628 JSON_ASSERT(!states.empty()); | |
| 12629 states.pop_back(); | |
| 12630 skip_to_state_evaluation = true; | |
| 12631 continue; | |
| 12632 } | |
| 12633 | |
| 12634 return sax->parse_error(m_lexer.get_position(), | |
| 12635 m_lexer.get_token_string(), | |
| 12636 parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr)); | |
| 12637 } | |
| 12638 } | |
| 12639 | |
| 12640 /// get next token from lexer | |
| 12641 token_type get_token() | |
| 12642 { | |
| 12643 return last_token = m_lexer.scan(); | |
| 12644 } | |
| 12645 | |
| 12646 std::string exception_message(const token_type expected, const std::string& context) | |
| 12647 { | |
| 12648 std::string error_msg = "syntax error "; | |
| 12649 | |
| 12650 if (!context.empty()) | |
| 12651 { | |
| 12652 error_msg += concat("while parsing ", context, ' '); | |
| 12653 } | |
| 12654 | |
| 12655 error_msg += "- "; | |
| 12656 | |
| 12657 if (last_token == token_type::parse_error) | |
| 12658 { | |
| 12659 error_msg += concat(m_lexer.get_error_message(), "; last read: '", | |
| 12660 m_lexer.get_token_string(), '\''); | |
| 12661 } | |
| 12662 else | |
| 12663 { | |
| 12664 error_msg += concat("unexpected ", lexer_t::token_type_name(last_token)); | |
| 12665 } | |
| 12666 | |
| 12667 if (expected != token_type::uninitialized) | |
| 12668 { | |
| 12669 error_msg += concat("; expected ", lexer_t::token_type_name(expected)); | |
| 12670 } | |
| 12671 | |
| 12672 return error_msg; | |
| 12673 } | |
| 12674 | |
| 12675 private: | |
| 12676 /// callback function | |
| 12677 const parser_callback_t<BasicJsonType> callback = nullptr; | |
| 12678 /// the type of the last read token | |
| 12679 token_type last_token = token_type::uninitialized; | |
| 12680 /// the lexer | |
| 12681 lexer_t m_lexer; | |
| 12682 /// whether to throw exceptions in case of errors | |
| 12683 const bool allow_exceptions = true; | |
| 12684 }; | |
| 12685 | |
| 12686 } // namespace detail | |
| 12687 NLOHMANN_JSON_NAMESPACE_END | |
| 12688 | |
| 12689 // #include <nlohmann/detail/iterators/internal_iterator.hpp> | |
| 12690 // __ _____ _____ _____ | |
| 12691 // __| | __| | | | JSON for Modern C++ | |
| 12692 // | | |__ | | | | | | version 3.11.3 | |
| 12693 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 12694 // | |
| 12695 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 12696 // SPDX-License-Identifier: MIT | |
| 12697 | |
| 12698 | |
| 12699 | |
| 12700 // #include <nlohmann/detail/abi_macros.hpp> | |
| 12701 | |
| 12702 // #include <nlohmann/detail/iterators/primitive_iterator.hpp> | |
| 12703 // __ _____ _____ _____ | |
| 12704 // __| | __| | | | JSON for Modern C++ | |
| 12705 // | | |__ | | | | | | version 3.11.3 | |
| 12706 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 12707 // | |
| 12708 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 12709 // SPDX-License-Identifier: MIT | |
| 12710 | |
| 12711 | |
| 12712 | |
| 12713 #include <cstddef> // ptrdiff_t | |
| 12714 #include <limits> // numeric_limits | |
| 12715 | |
| 12716 // #include <nlohmann/detail/macro_scope.hpp> | |
| 12717 | |
| 12718 | |
| 12719 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 12720 namespace detail | |
| 12721 { | |
| 12722 | |
| 12723 /* | |
| 12724 @brief an iterator for primitive JSON types | |
| 12725 | |
| 12726 This class models an iterator for primitive JSON types (boolean, number, | |
| 12727 string). It's only purpose is to allow the iterator/const_iterator classes | |
| 12728 to "iterate" over primitive values. Internally, the iterator is modeled by | |
| 12729 a `difference_type` variable. Value begin_value (`0`) models the begin, | |
| 12730 end_value (`1`) models past the end. | |
| 12731 */ | |
| 12732 class primitive_iterator_t | |
| 12733 { | |
| 12734 private: | |
| 12735 using difference_type = std::ptrdiff_t; | |
| 12736 static constexpr difference_type begin_value = 0; | |
| 12737 static constexpr difference_type end_value = begin_value + 1; | |
| 12738 | |
| 12739 JSON_PRIVATE_UNLESS_TESTED: | |
| 12740 /// iterator as signed integer type | |
| 12741 difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)(); | |
| 12742 | |
| 12743 public: | |
| 12744 constexpr difference_type get_value() const noexcept | |
| 12745 { | |
| 12746 return m_it; | |
| 12747 } | |
| 12748 | |
| 12749 /// set iterator to a defined beginning | |
| 12750 void set_begin() noexcept | |
| 12751 { | |
| 12752 m_it = begin_value; | |
| 12753 } | |
| 12754 | |
| 12755 /// set iterator to a defined past the end | |
| 12756 void set_end() noexcept | |
| 12757 { | |
| 12758 m_it = end_value; | |
| 12759 } | |
| 12760 | |
| 12761 /// return whether the iterator can be dereferenced | |
| 12762 constexpr bool is_begin() const noexcept | |
| 12763 { | |
| 12764 return m_it == begin_value; | |
| 12765 } | |
| 12766 | |
| 12767 /// return whether the iterator is at end | |
| 12768 constexpr bool is_end() const noexcept | |
| 12769 { | |
| 12770 return m_it == end_value; | |
| 12771 } | |
| 12772 | |
| 12773 friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept | |
| 12774 { | |
| 12775 return lhs.m_it == rhs.m_it; | |
| 12776 } | |
| 12777 | |
| 12778 friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept | |
| 12779 { | |
| 12780 return lhs.m_it < rhs.m_it; | |
| 12781 } | |
| 12782 | |
| 12783 primitive_iterator_t operator+(difference_type n) noexcept | |
| 12784 { | |
| 12785 auto result = *this; | |
| 12786 result += n; | |
| 12787 return result; | |
| 12788 } | |
| 12789 | |
| 12790 friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept | |
| 12791 { | |
| 12792 return lhs.m_it - rhs.m_it; | |
| 12793 } | |
| 12794 | |
| 12795 primitive_iterator_t& operator++() noexcept | |
| 12796 { | |
| 12797 ++m_it; | |
| 12798 return *this; | |
| 12799 } | |
| 12800 | |
| 12801 primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp) | |
| 12802 { | |
| 12803 auto result = *this; | |
| 12804 ++m_it; | |
| 12805 return result; | |
| 12806 } | |
| 12807 | |
| 12808 primitive_iterator_t& operator--() noexcept | |
| 12809 { | |
| 12810 --m_it; | |
| 12811 return *this; | |
| 12812 } | |
| 12813 | |
| 12814 primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp) | |
| 12815 { | |
| 12816 auto result = *this; | |
| 12817 --m_it; | |
| 12818 return result; | |
| 12819 } | |
| 12820 | |
| 12821 primitive_iterator_t& operator+=(difference_type n) noexcept | |
| 12822 { | |
| 12823 m_it += n; | |
| 12824 return *this; | |
| 12825 } | |
| 12826 | |
| 12827 primitive_iterator_t& operator-=(difference_type n) noexcept | |
| 12828 { | |
| 12829 m_it -= n; | |
| 12830 return *this; | |
| 12831 } | |
| 12832 }; | |
| 12833 | |
| 12834 } // namespace detail | |
| 12835 NLOHMANN_JSON_NAMESPACE_END | |
| 12836 | |
| 12837 | |
| 12838 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 12839 namespace detail | |
| 12840 { | |
| 12841 | |
| 12842 /*! | |
| 12843 @brief an iterator value | |
| 12844 | |
| 12845 @note This structure could easily be a union, but MSVC currently does not allow | |
| 12846 unions members with complex constructors, see https://github.com/nlohmann/json/pull/105. | |
| 12847 */ | |
| 12848 template<typename BasicJsonType> struct internal_iterator | |
| 12849 { | |
| 12850 /// iterator for JSON objects | |
| 12851 typename BasicJsonType::object_t::iterator object_iterator {}; | |
| 12852 /// iterator for JSON arrays | |
| 12853 typename BasicJsonType::array_t::iterator array_iterator {}; | |
| 12854 /// generic iterator for all other types | |
| 12855 primitive_iterator_t primitive_iterator {}; | |
| 12856 }; | |
| 12857 | |
| 12858 } // namespace detail | |
| 12859 NLOHMANN_JSON_NAMESPACE_END | |
| 12860 | |
| 12861 // #include <nlohmann/detail/iterators/iter_impl.hpp> | |
| 12862 // __ _____ _____ _____ | |
| 12863 // __| | __| | | | JSON for Modern C++ | |
| 12864 // | | |__ | | | | | | version 3.11.3 | |
| 12865 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 12866 // | |
| 12867 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 12868 // SPDX-License-Identifier: MIT | |
| 12869 | |
| 12870 | |
| 12871 | |
| 12872 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next | |
| 12873 #include <type_traits> // conditional, is_const, remove_const | |
| 12874 | |
| 12875 // #include <nlohmann/detail/exceptions.hpp> | |
| 12876 | |
| 12877 // #include <nlohmann/detail/iterators/internal_iterator.hpp> | |
| 12878 | |
| 12879 // #include <nlohmann/detail/iterators/primitive_iterator.hpp> | |
| 12880 | |
| 12881 // #include <nlohmann/detail/macro_scope.hpp> | |
| 12882 | |
| 12883 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 12884 | |
| 12885 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 12886 | |
| 12887 // #include <nlohmann/detail/value_t.hpp> | |
| 12888 | |
| 12889 | |
| 12890 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 12891 namespace detail | |
| 12892 { | |
| 12893 | |
| 12894 // forward declare, to be able to friend it later on | |
| 12895 template<typename IteratorType> class iteration_proxy; | |
| 12896 template<typename IteratorType> class iteration_proxy_value; | |
| 12897 | |
| 12898 /*! | |
| 12899 @brief a template for a bidirectional iterator for the @ref basic_json class | |
| 12900 This class implements a both iterators (iterator and const_iterator) for the | |
| 12901 @ref basic_json class. | |
| 12902 @note An iterator is called *initialized* when a pointer to a JSON value has | |
| 12903 been set (e.g., by a constructor or a copy assignment). If the iterator is | |
| 12904 default-constructed, it is *uninitialized* and most methods are undefined. | |
| 12905 **The library uses assertions to detect calls on uninitialized iterators.** | |
| 12906 @requirement The class satisfies the following concept requirements: | |
| 12907 - | |
| 12908 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator): | |
| 12909 The iterator that can be moved can be moved in both directions (i.e. | |
| 12910 incremented and decremented). | |
| 12911 @since version 1.0.0, simplified in version 2.0.9, change to bidirectional | |
| 12912 iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593) | |
| 12913 */ | |
| 12914 template<typename BasicJsonType> | |
| 12915 class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions) | |
| 12916 { | |
| 12917 /// the iterator with BasicJsonType of different const-ness | |
| 12918 using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>; | |
| 12919 /// allow basic_json to access private members | |
| 12920 friend other_iter_impl; | |
| 12921 friend BasicJsonType; | |
| 12922 friend iteration_proxy<iter_impl>; | |
| 12923 friend iteration_proxy_value<iter_impl>; | |
| 12924 | |
| 12925 using object_t = typename BasicJsonType::object_t; | |
| 12926 using array_t = typename BasicJsonType::array_t; | |
| 12927 // make sure BasicJsonType is basic_json or const basic_json | |
| 12928 static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value, | |
| 12929 "iter_impl only accepts (const) basic_json"); | |
| 12930 // superficial check for the LegacyBidirectionalIterator named requirement | |
| 12931 static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value | |
| 12932 && std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value, | |
| 12933 "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement."); | |
| 12934 | |
| 12935 public: | |
| 12936 /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17. | |
| 12937 /// The C++ Standard has never required user-defined iterators to derive from std::iterator. | |
| 12938 /// A user-defined iterator should provide publicly accessible typedefs named | |
| 12939 /// iterator_category, value_type, difference_type, pointer, and reference. | |
| 12940 /// Note that value_type is required to be non-const, even for constant iterators. | |
| 12941 using iterator_category = std::bidirectional_iterator_tag; | |
| 12942 | |
| 12943 /// the type of the values when the iterator is dereferenced | |
| 12944 using value_type = typename BasicJsonType::value_type; | |
| 12945 /// a type to represent differences between iterators | |
| 12946 using difference_type = typename BasicJsonType::difference_type; | |
| 12947 /// defines a pointer to the type iterated over (value_type) | |
| 12948 using pointer = typename std::conditional<std::is_const<BasicJsonType>::value, | |
| 12949 typename BasicJsonType::const_pointer, | |
| 12950 typename BasicJsonType::pointer>::type; | |
| 12951 /// defines a reference to the type iterated over (value_type) | |
| 12952 using reference = | |
| 12953 typename std::conditional<std::is_const<BasicJsonType>::value, | |
| 12954 typename BasicJsonType::const_reference, | |
| 12955 typename BasicJsonType::reference>::type; | |
| 12956 | |
| 12957 iter_impl() = default; | |
| 12958 ~iter_impl() = default; | |
| 12959 iter_impl(iter_impl&&) noexcept = default; | |
| 12960 iter_impl& operator=(iter_impl&&) noexcept = default; | |
| 12961 | |
| 12962 /*! | |
| 12963 @brief constructor for a given JSON instance | |
| 12964 @param[in] object pointer to a JSON object for this iterator | |
| 12965 @pre object != nullptr | |
| 12966 @post The iterator is initialized; i.e. `m_object != nullptr`. | |
| 12967 */ | |
| 12968 explicit iter_impl(pointer object) noexcept : m_object(object) | |
| 12969 { | |
| 12970 JSON_ASSERT(m_object != nullptr); | |
| 12971 | |
| 12972 switch (m_object->m_data.m_type) | |
| 12973 { | |
| 12974 case value_t::object: | |
| 12975 { | |
| 12976 m_it.object_iterator = typename object_t::iterator(); | |
| 12977 break; | |
| 12978 } | |
| 12979 | |
| 12980 case value_t::array: | |
| 12981 { | |
| 12982 m_it.array_iterator = typename array_t::iterator(); | |
| 12983 break; | |
| 12984 } | |
| 12985 | |
| 12986 case value_t::null: | |
| 12987 case value_t::string: | |
| 12988 case value_t::boolean: | |
| 12989 case value_t::number_integer: | |
| 12990 case value_t::number_unsigned: | |
| 12991 case value_t::number_float: | |
| 12992 case value_t::binary: | |
| 12993 case value_t::discarded: | |
| 12994 default: | |
| 12995 { | |
| 12996 m_it.primitive_iterator = primitive_iterator_t(); | |
| 12997 break; | |
| 12998 } | |
| 12999 } | |
| 13000 } | |
| 13001 | |
| 13002 /*! | |
| 13003 @note The conventional copy constructor and copy assignment are implicitly | |
| 13004 defined. Combined with the following converting constructor and | |
| 13005 assignment, they support: (1) copy from iterator to iterator, (2) | |
| 13006 copy from const iterator to const iterator, and (3) conversion from | |
| 13007 iterator to const iterator. However conversion from const iterator | |
| 13008 to iterator is not defined. | |
| 13009 */ | |
| 13010 | |
| 13011 /*! | |
| 13012 @brief const copy constructor | |
| 13013 @param[in] other const iterator to copy from | |
| 13014 @note This copy constructor had to be defined explicitly to circumvent a bug | |
| 13015 occurring on msvc v19.0 compiler (VS 2015) debug build. For more | |
| 13016 information refer to: https://github.com/nlohmann/json/issues/1608 | |
| 13017 */ | |
| 13018 iter_impl(const iter_impl<const BasicJsonType>& other) noexcept | |
| 13019 : m_object(other.m_object), m_it(other.m_it) | |
| 13020 {} | |
| 13021 | |
| 13022 /*! | |
| 13023 @brief converting assignment | |
| 13024 @param[in] other const iterator to copy from | |
| 13025 @return const/non-const iterator | |
| 13026 @note It is not checked whether @a other is initialized. | |
| 13027 */ | |
| 13028 iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept | |
| 13029 { | |
| 13030 if (&other != this) | |
| 13031 { | |
| 13032 m_object = other.m_object; | |
| 13033 m_it = other.m_it; | |
| 13034 } | |
| 13035 return *this; | |
| 13036 } | |
| 13037 | |
| 13038 /*! | |
| 13039 @brief converting constructor | |
| 13040 @param[in] other non-const iterator to copy from | |
| 13041 @note It is not checked whether @a other is initialized. | |
| 13042 */ | |
| 13043 iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept | |
| 13044 : m_object(other.m_object), m_it(other.m_it) | |
| 13045 {} | |
| 13046 | |
| 13047 /*! | |
| 13048 @brief converting assignment | |
| 13049 @param[in] other non-const iterator to copy from | |
| 13050 @return const/non-const iterator | |
| 13051 @note It is not checked whether @a other is initialized. | |
| 13052 */ | |
| 13053 iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp) | |
| 13054 { | |
| 13055 m_object = other.m_object; | |
| 13056 m_it = other.m_it; | |
| 13057 return *this; | |
| 13058 } | |
| 13059 | |
| 13060 JSON_PRIVATE_UNLESS_TESTED: | |
| 13061 /*! | |
| 13062 @brief set the iterator to the first value | |
| 13063 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13064 */ | |
| 13065 void set_begin() noexcept | |
| 13066 { | |
| 13067 JSON_ASSERT(m_object != nullptr); | |
| 13068 | |
| 13069 switch (m_object->m_data.m_type) | |
| 13070 { | |
| 13071 case value_t::object: | |
| 13072 { | |
| 13073 m_it.object_iterator = m_object->m_data.m_value.object->begin(); | |
| 13074 break; | |
| 13075 } | |
| 13076 | |
| 13077 case value_t::array: | |
| 13078 { | |
| 13079 m_it.array_iterator = m_object->m_data.m_value.array->begin(); | |
| 13080 break; | |
| 13081 } | |
| 13082 | |
| 13083 case value_t::null: | |
| 13084 { | |
| 13085 // set to end so begin()==end() is true: null is empty | |
| 13086 m_it.primitive_iterator.set_end(); | |
| 13087 break; | |
| 13088 } | |
| 13089 | |
| 13090 case value_t::string: | |
| 13091 case value_t::boolean: | |
| 13092 case value_t::number_integer: | |
| 13093 case value_t::number_unsigned: | |
| 13094 case value_t::number_float: | |
| 13095 case value_t::binary: | |
| 13096 case value_t::discarded: | |
| 13097 default: | |
| 13098 { | |
| 13099 m_it.primitive_iterator.set_begin(); | |
| 13100 break; | |
| 13101 } | |
| 13102 } | |
| 13103 } | |
| 13104 | |
| 13105 /*! | |
| 13106 @brief set the iterator past the last value | |
| 13107 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13108 */ | |
| 13109 void set_end() noexcept | |
| 13110 { | |
| 13111 JSON_ASSERT(m_object != nullptr); | |
| 13112 | |
| 13113 switch (m_object->m_data.m_type) | |
| 13114 { | |
| 13115 case value_t::object: | |
| 13116 { | |
| 13117 m_it.object_iterator = m_object->m_data.m_value.object->end(); | |
| 13118 break; | |
| 13119 } | |
| 13120 | |
| 13121 case value_t::array: | |
| 13122 { | |
| 13123 m_it.array_iterator = m_object->m_data.m_value.array->end(); | |
| 13124 break; | |
| 13125 } | |
| 13126 | |
| 13127 case value_t::null: | |
| 13128 case value_t::string: | |
| 13129 case value_t::boolean: | |
| 13130 case value_t::number_integer: | |
| 13131 case value_t::number_unsigned: | |
| 13132 case value_t::number_float: | |
| 13133 case value_t::binary: | |
| 13134 case value_t::discarded: | |
| 13135 default: | |
| 13136 { | |
| 13137 m_it.primitive_iterator.set_end(); | |
| 13138 break; | |
| 13139 } | |
| 13140 } | |
| 13141 } | |
| 13142 | |
| 13143 public: | |
| 13144 /*! | |
| 13145 @brief return a reference to the value pointed to by the iterator | |
| 13146 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13147 */ | |
| 13148 reference operator*() const | |
| 13149 { | |
| 13150 JSON_ASSERT(m_object != nullptr); | |
| 13151 | |
| 13152 switch (m_object->m_data.m_type) | |
| 13153 { | |
| 13154 case value_t::object: | |
| 13155 { | |
| 13156 JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end()); | |
| 13157 return m_it.object_iterator->second; | |
| 13158 } | |
| 13159 | |
| 13160 case value_t::array: | |
| 13161 { | |
| 13162 JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end()); | |
| 13163 return *m_it.array_iterator; | |
| 13164 } | |
| 13165 | |
| 13166 case value_t::null: | |
| 13167 JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); | |
| 13168 | |
| 13169 case value_t::string: | |
| 13170 case value_t::boolean: | |
| 13171 case value_t::number_integer: | |
| 13172 case value_t::number_unsigned: | |
| 13173 case value_t::number_float: | |
| 13174 case value_t::binary: | |
| 13175 case value_t::discarded: | |
| 13176 default: | |
| 13177 { | |
| 13178 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) | |
| 13179 { | |
| 13180 return *m_object; | |
| 13181 } | |
| 13182 | |
| 13183 JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); | |
| 13184 } | |
| 13185 } | |
| 13186 } | |
| 13187 | |
| 13188 /*! | |
| 13189 @brief dereference the iterator | |
| 13190 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13191 */ | |
| 13192 pointer operator->() const | |
| 13193 { | |
| 13194 JSON_ASSERT(m_object != nullptr); | |
| 13195 | |
| 13196 switch (m_object->m_data.m_type) | |
| 13197 { | |
| 13198 case value_t::object: | |
| 13199 { | |
| 13200 JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end()); | |
| 13201 return &(m_it.object_iterator->second); | |
| 13202 } | |
| 13203 | |
| 13204 case value_t::array: | |
| 13205 { | |
| 13206 JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end()); | |
| 13207 return &*m_it.array_iterator; | |
| 13208 } | |
| 13209 | |
| 13210 case value_t::null: | |
| 13211 case value_t::string: | |
| 13212 case value_t::boolean: | |
| 13213 case value_t::number_integer: | |
| 13214 case value_t::number_unsigned: | |
| 13215 case value_t::number_float: | |
| 13216 case value_t::binary: | |
| 13217 case value_t::discarded: | |
| 13218 default: | |
| 13219 { | |
| 13220 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) | |
| 13221 { | |
| 13222 return m_object; | |
| 13223 } | |
| 13224 | |
| 13225 JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); | |
| 13226 } | |
| 13227 } | |
| 13228 } | |
| 13229 | |
| 13230 /*! | |
| 13231 @brief post-increment (it++) | |
| 13232 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13233 */ | |
| 13234 iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp) | |
| 13235 { | |
| 13236 auto result = *this; | |
| 13237 ++(*this); | |
| 13238 return result; | |
| 13239 } | |
| 13240 | |
| 13241 /*! | |
| 13242 @brief pre-increment (++it) | |
| 13243 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13244 */ | |
| 13245 iter_impl& operator++() | |
| 13246 { | |
| 13247 JSON_ASSERT(m_object != nullptr); | |
| 13248 | |
| 13249 switch (m_object->m_data.m_type) | |
| 13250 { | |
| 13251 case value_t::object: | |
| 13252 { | |
| 13253 std::advance(m_it.object_iterator, 1); | |
| 13254 break; | |
| 13255 } | |
| 13256 | |
| 13257 case value_t::array: | |
| 13258 { | |
| 13259 std::advance(m_it.array_iterator, 1); | |
| 13260 break; | |
| 13261 } | |
| 13262 | |
| 13263 case value_t::null: | |
| 13264 case value_t::string: | |
| 13265 case value_t::boolean: | |
| 13266 case value_t::number_integer: | |
| 13267 case value_t::number_unsigned: | |
| 13268 case value_t::number_float: | |
| 13269 case value_t::binary: | |
| 13270 case value_t::discarded: | |
| 13271 default: | |
| 13272 { | |
| 13273 ++m_it.primitive_iterator; | |
| 13274 break; | |
| 13275 } | |
| 13276 } | |
| 13277 | |
| 13278 return *this; | |
| 13279 } | |
| 13280 | |
| 13281 /*! | |
| 13282 @brief post-decrement (it--) | |
| 13283 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13284 */ | |
| 13285 iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp) | |
| 13286 { | |
| 13287 auto result = *this; | |
| 13288 --(*this); | |
| 13289 return result; | |
| 13290 } | |
| 13291 | |
| 13292 /*! | |
| 13293 @brief pre-decrement (--it) | |
| 13294 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13295 */ | |
| 13296 iter_impl& operator--() | |
| 13297 { | |
| 13298 JSON_ASSERT(m_object != nullptr); | |
| 13299 | |
| 13300 switch (m_object->m_data.m_type) | |
| 13301 { | |
| 13302 case value_t::object: | |
| 13303 { | |
| 13304 std::advance(m_it.object_iterator, -1); | |
| 13305 break; | |
| 13306 } | |
| 13307 | |
| 13308 case value_t::array: | |
| 13309 { | |
| 13310 std::advance(m_it.array_iterator, -1); | |
| 13311 break; | |
| 13312 } | |
| 13313 | |
| 13314 case value_t::null: | |
| 13315 case value_t::string: | |
| 13316 case value_t::boolean: | |
| 13317 case value_t::number_integer: | |
| 13318 case value_t::number_unsigned: | |
| 13319 case value_t::number_float: | |
| 13320 case value_t::binary: | |
| 13321 case value_t::discarded: | |
| 13322 default: | |
| 13323 { | |
| 13324 --m_it.primitive_iterator; | |
| 13325 break; | |
| 13326 } | |
| 13327 } | |
| 13328 | |
| 13329 return *this; | |
| 13330 } | |
| 13331 | |
| 13332 /*! | |
| 13333 @brief comparison: equal | |
| 13334 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13335 */ | |
| 13336 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 > | |
| 13337 bool operator==(const IterImpl& other) const | |
| 13338 { | |
| 13339 // if objects are not the same, the comparison is undefined | |
| 13340 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) | |
| 13341 { | |
| 13342 JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object)); | |
| 13343 } | |
| 13344 | |
| 13345 JSON_ASSERT(m_object != nullptr); | |
| 13346 | |
| 13347 switch (m_object->m_data.m_type) | |
| 13348 { | |
| 13349 case value_t::object: | |
| 13350 return (m_it.object_iterator == other.m_it.object_iterator); | |
| 13351 | |
| 13352 case value_t::array: | |
| 13353 return (m_it.array_iterator == other.m_it.array_iterator); | |
| 13354 | |
| 13355 case value_t::null: | |
| 13356 case value_t::string: | |
| 13357 case value_t::boolean: | |
| 13358 case value_t::number_integer: | |
| 13359 case value_t::number_unsigned: | |
| 13360 case value_t::number_float: | |
| 13361 case value_t::binary: | |
| 13362 case value_t::discarded: | |
| 13363 default: | |
| 13364 return (m_it.primitive_iterator == other.m_it.primitive_iterator); | |
| 13365 } | |
| 13366 } | |
| 13367 | |
| 13368 /*! | |
| 13369 @brief comparison: not equal | |
| 13370 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13371 */ | |
| 13372 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 > | |
| 13373 bool operator!=(const IterImpl& other) const | |
| 13374 { | |
| 13375 return !operator==(other); | |
| 13376 } | |
| 13377 | |
| 13378 /*! | |
| 13379 @brief comparison: smaller | |
| 13380 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13381 */ | |
| 13382 bool operator<(const iter_impl& other) const | |
| 13383 { | |
| 13384 // if objects are not the same, the comparison is undefined | |
| 13385 if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) | |
| 13386 { | |
| 13387 JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object)); | |
| 13388 } | |
| 13389 | |
| 13390 JSON_ASSERT(m_object != nullptr); | |
| 13391 | |
| 13392 switch (m_object->m_data.m_type) | |
| 13393 { | |
| 13394 case value_t::object: | |
| 13395 JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object)); | |
| 13396 | |
| 13397 case value_t::array: | |
| 13398 return (m_it.array_iterator < other.m_it.array_iterator); | |
| 13399 | |
| 13400 case value_t::null: | |
| 13401 case value_t::string: | |
| 13402 case value_t::boolean: | |
| 13403 case value_t::number_integer: | |
| 13404 case value_t::number_unsigned: | |
| 13405 case value_t::number_float: | |
| 13406 case value_t::binary: | |
| 13407 case value_t::discarded: | |
| 13408 default: | |
| 13409 return (m_it.primitive_iterator < other.m_it.primitive_iterator); | |
| 13410 } | |
| 13411 } | |
| 13412 | |
| 13413 /*! | |
| 13414 @brief comparison: less than or equal | |
| 13415 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13416 */ | |
| 13417 bool operator<=(const iter_impl& other) const | |
| 13418 { | |
| 13419 return !other.operator < (*this); | |
| 13420 } | |
| 13421 | |
| 13422 /*! | |
| 13423 @brief comparison: greater than | |
| 13424 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13425 */ | |
| 13426 bool operator>(const iter_impl& other) const | |
| 13427 { | |
| 13428 return !operator<=(other); | |
| 13429 } | |
| 13430 | |
| 13431 /*! | |
| 13432 @brief comparison: greater than or equal | |
| 13433 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13434 */ | |
| 13435 bool operator>=(const iter_impl& other) const | |
| 13436 { | |
| 13437 return !operator<(other); | |
| 13438 } | |
| 13439 | |
| 13440 /*! | |
| 13441 @brief add to iterator | |
| 13442 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13443 */ | |
| 13444 iter_impl& operator+=(difference_type i) | |
| 13445 { | |
| 13446 JSON_ASSERT(m_object != nullptr); | |
| 13447 | |
| 13448 switch (m_object->m_data.m_type) | |
| 13449 { | |
| 13450 case value_t::object: | |
| 13451 JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object)); | |
| 13452 | |
| 13453 case value_t::array: | |
| 13454 { | |
| 13455 std::advance(m_it.array_iterator, i); | |
| 13456 break; | |
| 13457 } | |
| 13458 | |
| 13459 case value_t::null: | |
| 13460 case value_t::string: | |
| 13461 case value_t::boolean: | |
| 13462 case value_t::number_integer: | |
| 13463 case value_t::number_unsigned: | |
| 13464 case value_t::number_float: | |
| 13465 case value_t::binary: | |
| 13466 case value_t::discarded: | |
| 13467 default: | |
| 13468 { | |
| 13469 m_it.primitive_iterator += i; | |
| 13470 break; | |
| 13471 } | |
| 13472 } | |
| 13473 | |
| 13474 return *this; | |
| 13475 } | |
| 13476 | |
| 13477 /*! | |
| 13478 @brief subtract from iterator | |
| 13479 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13480 */ | |
| 13481 iter_impl& operator-=(difference_type i) | |
| 13482 { | |
| 13483 return operator+=(-i); | |
| 13484 } | |
| 13485 | |
| 13486 /*! | |
| 13487 @brief add to iterator | |
| 13488 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13489 */ | |
| 13490 iter_impl operator+(difference_type i) const | |
| 13491 { | |
| 13492 auto result = *this; | |
| 13493 result += i; | |
| 13494 return result; | |
| 13495 } | |
| 13496 | |
| 13497 /*! | |
| 13498 @brief addition of distance and iterator | |
| 13499 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13500 */ | |
| 13501 friend iter_impl operator+(difference_type i, const iter_impl& it) | |
| 13502 { | |
| 13503 auto result = it; | |
| 13504 result += i; | |
| 13505 return result; | |
| 13506 } | |
| 13507 | |
| 13508 /*! | |
| 13509 @brief subtract from iterator | |
| 13510 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13511 */ | |
| 13512 iter_impl operator-(difference_type i) const | |
| 13513 { | |
| 13514 auto result = *this; | |
| 13515 result -= i; | |
| 13516 return result; | |
| 13517 } | |
| 13518 | |
| 13519 /*! | |
| 13520 @brief return difference | |
| 13521 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13522 */ | |
| 13523 difference_type operator-(const iter_impl& other) const | |
| 13524 { | |
| 13525 JSON_ASSERT(m_object != nullptr); | |
| 13526 | |
| 13527 switch (m_object->m_data.m_type) | |
| 13528 { | |
| 13529 case value_t::object: | |
| 13530 JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object)); | |
| 13531 | |
| 13532 case value_t::array: | |
| 13533 return m_it.array_iterator - other.m_it.array_iterator; | |
| 13534 | |
| 13535 case value_t::null: | |
| 13536 case value_t::string: | |
| 13537 case value_t::boolean: | |
| 13538 case value_t::number_integer: | |
| 13539 case value_t::number_unsigned: | |
| 13540 case value_t::number_float: | |
| 13541 case value_t::binary: | |
| 13542 case value_t::discarded: | |
| 13543 default: | |
| 13544 return m_it.primitive_iterator - other.m_it.primitive_iterator; | |
| 13545 } | |
| 13546 } | |
| 13547 | |
| 13548 /*! | |
| 13549 @brief access to successor | |
| 13550 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13551 */ | |
| 13552 reference operator[](difference_type n) const | |
| 13553 { | |
| 13554 JSON_ASSERT(m_object != nullptr); | |
| 13555 | |
| 13556 switch (m_object->m_data.m_type) | |
| 13557 { | |
| 13558 case value_t::object: | |
| 13559 JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object)); | |
| 13560 | |
| 13561 case value_t::array: | |
| 13562 return *std::next(m_it.array_iterator, n); | |
| 13563 | |
| 13564 case value_t::null: | |
| 13565 JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); | |
| 13566 | |
| 13567 case value_t::string: | |
| 13568 case value_t::boolean: | |
| 13569 case value_t::number_integer: | |
| 13570 case value_t::number_unsigned: | |
| 13571 case value_t::number_float: | |
| 13572 case value_t::binary: | |
| 13573 case value_t::discarded: | |
| 13574 default: | |
| 13575 { | |
| 13576 if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n)) | |
| 13577 { | |
| 13578 return *m_object; | |
| 13579 } | |
| 13580 | |
| 13581 JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); | |
| 13582 } | |
| 13583 } | |
| 13584 } | |
| 13585 | |
| 13586 /*! | |
| 13587 @brief return the key of an object iterator | |
| 13588 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13589 */ | |
| 13590 const typename object_t::key_type& key() const | |
| 13591 { | |
| 13592 JSON_ASSERT(m_object != nullptr); | |
| 13593 | |
| 13594 if (JSON_HEDLEY_LIKELY(m_object->is_object())) | |
| 13595 { | |
| 13596 return m_it.object_iterator->first; | |
| 13597 } | |
| 13598 | |
| 13599 JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object)); | |
| 13600 } | |
| 13601 | |
| 13602 /*! | |
| 13603 @brief return the value of an iterator | |
| 13604 @pre The iterator is initialized; i.e. `m_object != nullptr`. | |
| 13605 */ | |
| 13606 reference value() const | |
| 13607 { | |
| 13608 return operator*(); | |
| 13609 } | |
| 13610 | |
| 13611 JSON_PRIVATE_UNLESS_TESTED: | |
| 13612 /// associated JSON instance | |
| 13613 pointer m_object = nullptr; | |
| 13614 /// the actual iterator of the associated instance | |
| 13615 internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {}; | |
| 13616 }; | |
| 13617 | |
| 13618 } // namespace detail | |
| 13619 NLOHMANN_JSON_NAMESPACE_END | |
| 13620 | |
| 13621 // #include <nlohmann/detail/iterators/iteration_proxy.hpp> | |
| 13622 | |
| 13623 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp> | |
| 13624 // __ _____ _____ _____ | |
| 13625 // __| | __| | | | JSON for Modern C++ | |
| 13626 // | | |__ | | | | | | version 3.11.3 | |
| 13627 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 13628 // | |
| 13629 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 13630 // SPDX-License-Identifier: MIT | |
| 13631 | |
| 13632 | |
| 13633 | |
| 13634 #include <cstddef> // ptrdiff_t | |
| 13635 #include <iterator> // reverse_iterator | |
| 13636 #include <utility> // declval | |
| 13637 | |
| 13638 // #include <nlohmann/detail/abi_macros.hpp> | |
| 13639 | |
| 13640 | |
| 13641 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 13642 namespace detail | |
| 13643 { | |
| 13644 | |
| 13645 ////////////////////// | |
| 13646 // reverse_iterator // | |
| 13647 ////////////////////// | |
| 13648 | |
| 13649 /*! | |
| 13650 @brief a template for a reverse iterator class | |
| 13651 | |
| 13652 @tparam Base the base iterator type to reverse. Valid types are @ref | |
| 13653 iterator (to create @ref reverse_iterator) and @ref const_iterator (to | |
| 13654 create @ref const_reverse_iterator). | |
| 13655 | |
| 13656 @requirement The class satisfies the following concept requirements: | |
| 13657 - | |
| 13658 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator): | |
| 13659 The iterator that can be moved can be moved in both directions (i.e. | |
| 13660 incremented and decremented). | |
| 13661 - [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator): | |
| 13662 It is possible to write to the pointed-to element (only if @a Base is | |
| 13663 @ref iterator). | |
| 13664 | |
| 13665 @since version 1.0.0 | |
| 13666 */ | |
| 13667 template<typename Base> | |
| 13668 class json_reverse_iterator : public std::reverse_iterator<Base> | |
| 13669 { | |
| 13670 public: | |
| 13671 using difference_type = std::ptrdiff_t; | |
| 13672 /// shortcut to the reverse iterator adapter | |
| 13673 using base_iterator = std::reverse_iterator<Base>; | |
| 13674 /// the reference type for the pointed-to element | |
| 13675 using reference = typename Base::reference; | |
| 13676 | |
| 13677 /// create reverse iterator from iterator | |
| 13678 explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept | |
| 13679 : base_iterator(it) {} | |
| 13680 | |
| 13681 /// create reverse iterator from base class | |
| 13682 explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {} | |
| 13683 | |
| 13684 /// post-increment (it++) | |
| 13685 json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp) | |
| 13686 { | |
| 13687 return static_cast<json_reverse_iterator>(base_iterator::operator++(1)); | |
| 13688 } | |
| 13689 | |
| 13690 /// pre-increment (++it) | |
| 13691 json_reverse_iterator& operator++() | |
| 13692 { | |
| 13693 return static_cast<json_reverse_iterator&>(base_iterator::operator++()); | |
| 13694 } | |
| 13695 | |
| 13696 /// post-decrement (it--) | |
| 13697 json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp) | |
| 13698 { | |
| 13699 return static_cast<json_reverse_iterator>(base_iterator::operator--(1)); | |
| 13700 } | |
| 13701 | |
| 13702 /// pre-decrement (--it) | |
| 13703 json_reverse_iterator& operator--() | |
| 13704 { | |
| 13705 return static_cast<json_reverse_iterator&>(base_iterator::operator--()); | |
| 13706 } | |
| 13707 | |
| 13708 /// add to iterator | |
| 13709 json_reverse_iterator& operator+=(difference_type i) | |
| 13710 { | |
| 13711 return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i)); | |
| 13712 } | |
| 13713 | |
| 13714 /// add to iterator | |
| 13715 json_reverse_iterator operator+(difference_type i) const | |
| 13716 { | |
| 13717 return static_cast<json_reverse_iterator>(base_iterator::operator+(i)); | |
| 13718 } | |
| 13719 | |
| 13720 /// subtract from iterator | |
| 13721 json_reverse_iterator operator-(difference_type i) const | |
| 13722 { | |
| 13723 return static_cast<json_reverse_iterator>(base_iterator::operator-(i)); | |
| 13724 } | |
| 13725 | |
| 13726 /// return difference | |
| 13727 difference_type operator-(const json_reverse_iterator& other) const | |
| 13728 { | |
| 13729 return base_iterator(*this) - base_iterator(other); | |
| 13730 } | |
| 13731 | |
| 13732 /// access to successor | |
| 13733 reference operator[](difference_type n) const | |
| 13734 { | |
| 13735 return *(this->operator+(n)); | |
| 13736 } | |
| 13737 | |
| 13738 /// return the key of an object iterator | |
| 13739 auto key() const -> decltype(std::declval<Base>().key()) | |
| 13740 { | |
| 13741 auto it = --this->base(); | |
| 13742 return it.key(); | |
| 13743 } | |
| 13744 | |
| 13745 /// return the value of an iterator | |
| 13746 reference value() const | |
| 13747 { | |
| 13748 auto it = --this->base(); | |
| 13749 return it.operator * (); | |
| 13750 } | |
| 13751 }; | |
| 13752 | |
| 13753 } // namespace detail | |
| 13754 NLOHMANN_JSON_NAMESPACE_END | |
| 13755 | |
| 13756 // #include <nlohmann/detail/iterators/primitive_iterator.hpp> | |
| 13757 | |
| 13758 // #include <nlohmann/detail/json_custom_base_class.hpp> | |
| 13759 // __ _____ _____ _____ | |
| 13760 // __| | __| | | | JSON for Modern C++ | |
| 13761 // | | |__ | | | | | | version 3.11.3 | |
| 13762 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 13763 // | |
| 13764 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 13765 // SPDX-License-Identifier: MIT | |
| 13766 | |
| 13767 | |
| 13768 | |
| 13769 #include <type_traits> // conditional, is_same | |
| 13770 | |
| 13771 // #include <nlohmann/detail/abi_macros.hpp> | |
| 13772 | |
| 13773 | |
| 13774 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 13775 namespace detail | |
| 13776 { | |
| 13777 | |
| 13778 /*! | |
| 13779 @brief Default base class of the @ref basic_json class. | |
| 13780 | |
| 13781 So that the correct implementations of the copy / move ctors / assign operators | |
| 13782 of @ref basic_json do not require complex case distinctions | |
| 13783 (no base class / custom base class used as customization point), | |
| 13784 @ref basic_json always has a base class. | |
| 13785 By default, this class is used because it is empty and thus has no effect | |
| 13786 on the behavior of @ref basic_json. | |
| 13787 */ | |
| 13788 struct json_default_base {}; | |
| 13789 | |
| 13790 template<class T> | |
| 13791 using json_base_class = typename std::conditional < | |
| 13792 std::is_same<T, void>::value, | |
| 13793 json_default_base, | |
| 13794 T | |
| 13795 >::type; | |
| 13796 | |
| 13797 } // namespace detail | |
| 13798 NLOHMANN_JSON_NAMESPACE_END | |
| 13799 | |
| 13800 // #include <nlohmann/detail/json_pointer.hpp> | |
| 13801 // __ _____ _____ _____ | |
| 13802 // __| | __| | | | JSON for Modern C++ | |
| 13803 // | | |__ | | | | | | version 3.11.3 | |
| 13804 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 13805 // | |
| 13806 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 13807 // SPDX-License-Identifier: MIT | |
| 13808 | |
| 13809 | |
| 13810 | |
| 13811 #include <algorithm> // all_of | |
| 13812 #include <cctype> // isdigit | |
| 13813 #include <cerrno> // errno, ERANGE | |
| 13814 #include <cstdlib> // strtoull | |
| 13815 #ifndef JSON_NO_IO | |
| 13816 #include <iosfwd> // ostream | |
| 13817 #endif // JSON_NO_IO | |
| 13818 #include <limits> // max | |
| 13819 #include <numeric> // accumulate | |
| 13820 #include <string> // string | |
| 13821 #include <utility> // move | |
| 13822 #include <vector> // vector | |
| 13823 | |
| 13824 // #include <nlohmann/detail/exceptions.hpp> | |
| 13825 | |
| 13826 // #include <nlohmann/detail/macro_scope.hpp> | |
| 13827 | |
| 13828 // #include <nlohmann/detail/string_concat.hpp> | |
| 13829 | |
| 13830 // #include <nlohmann/detail/string_escape.hpp> | |
| 13831 | |
| 13832 // #include <nlohmann/detail/value_t.hpp> | |
| 13833 | |
| 13834 | |
| 13835 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 13836 | |
| 13837 /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document | |
| 13838 /// @sa https://json.nlohmann.me/api/json_pointer/ | |
| 13839 template<typename RefStringType> | |
| 13840 class json_pointer | |
| 13841 { | |
| 13842 // allow basic_json to access private members | |
| 13843 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 13844 friend class basic_json; | |
| 13845 | |
| 13846 template<typename> | |
| 13847 friend class json_pointer; | |
| 13848 | |
| 13849 template<typename T> | |
| 13850 struct string_t_helper | |
| 13851 { | |
| 13852 using type = T; | |
| 13853 }; | |
| 13854 | |
| 13855 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 13856 struct string_t_helper<NLOHMANN_BASIC_JSON_TPL> | |
| 13857 { | |
| 13858 using type = StringType; | |
| 13859 }; | |
| 13860 | |
| 13861 public: | |
| 13862 // for backwards compatibility accept BasicJsonType | |
| 13863 using string_t = typename string_t_helper<RefStringType>::type; | |
| 13864 | |
| 13865 /// @brief create JSON pointer | |
| 13866 /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/ | |
| 13867 explicit json_pointer(const string_t& s = "") | |
| 13868 : reference_tokens(split(s)) | |
| 13869 {} | |
| 13870 | |
| 13871 /// @brief return a string representation of the JSON pointer | |
| 13872 /// @sa https://json.nlohmann.me/api/json_pointer/to_string/ | |
| 13873 string_t to_string() const | |
| 13874 { | |
| 13875 return std::accumulate(reference_tokens.begin(), reference_tokens.end(), | |
| 13876 string_t{}, | |
| 13877 [](const string_t& a, const string_t& b) | |
| 13878 { | |
| 13879 return detail::concat(a, '/', detail::escape(b)); | |
| 13880 }); | |
| 13881 } | |
| 13882 | |
| 13883 /// @brief return a string representation of the JSON pointer | |
| 13884 /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/ | |
| 13885 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string()) | |
| 13886 operator string_t() const | |
| 13887 { | |
| 13888 return to_string(); | |
| 13889 } | |
| 13890 | |
| 13891 #ifndef JSON_NO_IO | |
| 13892 /// @brief write string representation of the JSON pointer to stream | |
| 13893 /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/ | |
| 13894 friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr) | |
| 13895 { | |
| 13896 o << ptr.to_string(); | |
| 13897 return o; | |
| 13898 } | |
| 13899 #endif | |
| 13900 | |
| 13901 /// @brief append another JSON pointer at the end of this JSON pointer | |
| 13902 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/ | |
| 13903 json_pointer& operator/=(const json_pointer& ptr) | |
| 13904 { | |
| 13905 reference_tokens.insert(reference_tokens.end(), | |
| 13906 ptr.reference_tokens.begin(), | |
| 13907 ptr.reference_tokens.end()); | |
| 13908 return *this; | |
| 13909 } | |
| 13910 | |
| 13911 /// @brief append an unescaped reference token at the end of this JSON pointer | |
| 13912 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/ | |
| 13913 json_pointer& operator/=(string_t token) | |
| 13914 { | |
| 13915 push_back(std::move(token)); | |
| 13916 return *this; | |
| 13917 } | |
| 13918 | |
| 13919 /// @brief append an array index at the end of this JSON pointer | |
| 13920 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/ | |
| 13921 json_pointer& operator/=(std::size_t array_idx) | |
| 13922 { | |
| 13923 return *this /= std::to_string(array_idx); | |
| 13924 } | |
| 13925 | |
| 13926 /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer | |
| 13927 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/ | |
| 13928 friend json_pointer operator/(const json_pointer& lhs, | |
| 13929 const json_pointer& rhs) | |
| 13930 { | |
| 13931 return json_pointer(lhs) /= rhs; | |
| 13932 } | |
| 13933 | |
| 13934 /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer | |
| 13935 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/ | |
| 13936 friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param) | |
| 13937 { | |
| 13938 return json_pointer(lhs) /= std::move(token); | |
| 13939 } | |
| 13940 | |
| 13941 /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer | |
| 13942 /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/ | |
| 13943 friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx) | |
| 13944 { | |
| 13945 return json_pointer(lhs) /= array_idx; | |
| 13946 } | |
| 13947 | |
| 13948 /// @brief returns the parent of this JSON pointer | |
| 13949 /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/ | |
| 13950 json_pointer parent_pointer() const | |
| 13951 { | |
| 13952 if (empty()) | |
| 13953 { | |
| 13954 return *this; | |
| 13955 } | |
| 13956 | |
| 13957 json_pointer res = *this; | |
| 13958 res.pop_back(); | |
| 13959 return res; | |
| 13960 } | |
| 13961 | |
| 13962 /// @brief remove last reference token | |
| 13963 /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/ | |
| 13964 void pop_back() | |
| 13965 { | |
| 13966 if (JSON_HEDLEY_UNLIKELY(empty())) | |
| 13967 { | |
| 13968 JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr)); | |
| 13969 } | |
| 13970 | |
| 13971 reference_tokens.pop_back(); | |
| 13972 } | |
| 13973 | |
| 13974 /// @brief return last reference token | |
| 13975 /// @sa https://json.nlohmann.me/api/json_pointer/back/ | |
| 13976 const string_t& back() const | |
| 13977 { | |
| 13978 if (JSON_HEDLEY_UNLIKELY(empty())) | |
| 13979 { | |
| 13980 JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr)); | |
| 13981 } | |
| 13982 | |
| 13983 return reference_tokens.back(); | |
| 13984 } | |
| 13985 | |
| 13986 /// @brief append an unescaped token at the end of the reference pointer | |
| 13987 /// @sa https://json.nlohmann.me/api/json_pointer/push_back/ | |
| 13988 void push_back(const string_t& token) | |
| 13989 { | |
| 13990 reference_tokens.push_back(token); | |
| 13991 } | |
| 13992 | |
| 13993 /// @brief append an unescaped token at the end of the reference pointer | |
| 13994 /// @sa https://json.nlohmann.me/api/json_pointer/push_back/ | |
| 13995 void push_back(string_t&& token) | |
| 13996 { | |
| 13997 reference_tokens.push_back(std::move(token)); | |
| 13998 } | |
| 13999 | |
| 14000 /// @brief return whether pointer points to the root document | |
| 14001 /// @sa https://json.nlohmann.me/api/json_pointer/empty/ | |
| 14002 bool empty() const noexcept | |
| 14003 { | |
| 14004 return reference_tokens.empty(); | |
| 14005 } | |
| 14006 | |
| 14007 private: | |
| 14008 /*! | |
| 14009 @param[in] s reference token to be converted into an array index | |
| 14010 | |
| 14011 @return integer representation of @a s | |
| 14012 | |
| 14013 @throw parse_error.106 if an array index begins with '0' | |
| 14014 @throw parse_error.109 if an array index begins not with a digit | |
| 14015 @throw out_of_range.404 if string @a s could not be converted to an integer | |
| 14016 @throw out_of_range.410 if an array index exceeds size_type | |
| 14017 */ | |
| 14018 template<typename BasicJsonType> | |
| 14019 static typename BasicJsonType::size_type array_index(const string_t& s) | |
| 14020 { | |
| 14021 using size_type = typename BasicJsonType::size_type; | |
| 14022 | |
| 14023 // error condition (cf. RFC 6901, Sect. 4) | |
| 14024 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0')) | |
| 14025 { | |
| 14026 JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr)); | |
| 14027 } | |
| 14028 | |
| 14029 // error condition (cf. RFC 6901, Sect. 4) | |
| 14030 if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9'))) | |
| 14031 { | |
| 14032 JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr)); | |
| 14033 } | |
| 14034 | |
| 14035 const char* p = s.c_str(); | |
| 14036 char* p_end = nullptr; | |
| 14037 errno = 0; // strtoull doesn't reset errno | |
| 14038 const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int) | |
| 14039 if (p == p_end // invalid input or empty string | |
| 14040 || errno == ERANGE // out of range | |
| 14041 || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read | |
| 14042 { | |
| 14043 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr)); | |
| 14044 } | |
| 14045 | |
| 14046 // only triggered on special platforms (like 32bit), see also | |
| 14047 // https://github.com/nlohmann/json/pull/2203 | |
| 14048 if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)())) // NOLINT(runtime/int) | |
| 14049 { | |
| 14050 JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr)); // LCOV_EXCL_LINE | |
| 14051 } | |
| 14052 | |
| 14053 return static_cast<size_type>(res); | |
| 14054 } | |
| 14055 | |
| 14056 JSON_PRIVATE_UNLESS_TESTED: | |
| 14057 json_pointer top() const | |
| 14058 { | |
| 14059 if (JSON_HEDLEY_UNLIKELY(empty())) | |
| 14060 { | |
| 14061 JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr)); | |
| 14062 } | |
| 14063 | |
| 14064 json_pointer result = *this; | |
| 14065 result.reference_tokens = {reference_tokens[0]}; | |
| 14066 return result; | |
| 14067 } | |
| 14068 | |
| 14069 private: | |
| 14070 /*! | |
| 14071 @brief create and return a reference to the pointed to value | |
| 14072 | |
| 14073 @complexity Linear in the number of reference tokens. | |
| 14074 | |
| 14075 @throw parse_error.109 if array index is not a number | |
| 14076 @throw type_error.313 if value cannot be unflattened | |
| 14077 */ | |
| 14078 template<typename BasicJsonType> | |
| 14079 BasicJsonType& get_and_create(BasicJsonType& j) const | |
| 14080 { | |
| 14081 auto* result = &j; | |
| 14082 | |
| 14083 // in case no reference tokens exist, return a reference to the JSON value | |
| 14084 // j which will be overwritten by a primitive value | |
| 14085 for (const auto& reference_token : reference_tokens) | |
| 14086 { | |
| 14087 switch (result->type()) | |
| 14088 { | |
| 14089 case detail::value_t::null: | |
| 14090 { | |
| 14091 if (reference_token == "0") | |
| 14092 { | |
| 14093 // start a new array if reference token is 0 | |
| 14094 result = &result->operator[](0); | |
| 14095 } | |
| 14096 else | |
| 14097 { | |
| 14098 // start a new object otherwise | |
| 14099 result = &result->operator[](reference_token); | |
| 14100 } | |
| 14101 break; | |
| 14102 } | |
| 14103 | |
| 14104 case detail::value_t::object: | |
| 14105 { | |
| 14106 // create an entry in the object | |
| 14107 result = &result->operator[](reference_token); | |
| 14108 break; | |
| 14109 } | |
| 14110 | |
| 14111 case detail::value_t::array: | |
| 14112 { | |
| 14113 // create an entry in the array | |
| 14114 result = &result->operator[](array_index<BasicJsonType>(reference_token)); | |
| 14115 break; | |
| 14116 } | |
| 14117 | |
| 14118 /* | |
| 14119 The following code is only reached if there exists a reference | |
| 14120 token _and_ the current value is primitive. In this case, we have | |
| 14121 an error situation, because primitive values may only occur as | |
| 14122 single value; that is, with an empty list of reference tokens. | |
| 14123 */ | |
| 14124 case detail::value_t::string: | |
| 14125 case detail::value_t::boolean: | |
| 14126 case detail::value_t::number_integer: | |
| 14127 case detail::value_t::number_unsigned: | |
| 14128 case detail::value_t::number_float: | |
| 14129 case detail::value_t::binary: | |
| 14130 case detail::value_t::discarded: | |
| 14131 default: | |
| 14132 JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j)); | |
| 14133 } | |
| 14134 } | |
| 14135 | |
| 14136 return *result; | |
| 14137 } | |
| 14138 | |
| 14139 /*! | |
| 14140 @brief return a reference to the pointed to value | |
| 14141 | |
| 14142 @note This version does not throw if a value is not present, but tries to | |
| 14143 create nested values instead. For instance, calling this function | |
| 14144 with pointer `"/this/that"` on a null value is equivalent to calling | |
| 14145 `operator[]("this").operator[]("that")` on that value, effectively | |
| 14146 changing the null value to an object. | |
| 14147 | |
| 14148 @param[in] ptr a JSON value | |
| 14149 | |
| 14150 @return reference to the JSON value pointed to by the JSON pointer | |
| 14151 | |
| 14152 @complexity Linear in the length of the JSON pointer. | |
| 14153 | |
| 14154 @throw parse_error.106 if an array index begins with '0' | |
| 14155 @throw parse_error.109 if an array index was not a number | |
| 14156 @throw out_of_range.404 if the JSON pointer can not be resolved | |
| 14157 */ | |
| 14158 template<typename BasicJsonType> | |
| 14159 BasicJsonType& get_unchecked(BasicJsonType* ptr) const | |
| 14160 { | |
| 14161 for (const auto& reference_token : reference_tokens) | |
| 14162 { | |
| 14163 // convert null values to arrays or objects before continuing | |
| 14164 if (ptr->is_null()) | |
| 14165 { | |
| 14166 // check if reference token is a number | |
| 14167 const bool nums = | |
| 14168 std::all_of(reference_token.begin(), reference_token.end(), | |
| 14169 [](const unsigned char x) | |
| 14170 { | |
| 14171 return std::isdigit(x); | |
| 14172 }); | |
| 14173 | |
| 14174 // change value to array for numbers or "-" or to object otherwise | |
| 14175 *ptr = (nums || reference_token == "-") | |
| 14176 ? detail::value_t::array | |
| 14177 : detail::value_t::object; | |
| 14178 } | |
| 14179 | |
| 14180 switch (ptr->type()) | |
| 14181 { | |
| 14182 case detail::value_t::object: | |
| 14183 { | |
| 14184 // use unchecked object access | |
| 14185 ptr = &ptr->operator[](reference_token); | |
| 14186 break; | |
| 14187 } | |
| 14188 | |
| 14189 case detail::value_t::array: | |
| 14190 { | |
| 14191 if (reference_token == "-") | |
| 14192 { | |
| 14193 // explicitly treat "-" as index beyond the end | |
| 14194 ptr = &ptr->operator[](ptr->m_data.m_value.array->size()); | |
| 14195 } | |
| 14196 else | |
| 14197 { | |
| 14198 // convert array index to number; unchecked access | |
| 14199 ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token)); | |
| 14200 } | |
| 14201 break; | |
| 14202 } | |
| 14203 | |
| 14204 case detail::value_t::null: | |
| 14205 case detail::value_t::string: | |
| 14206 case detail::value_t::boolean: | |
| 14207 case detail::value_t::number_integer: | |
| 14208 case detail::value_t::number_unsigned: | |
| 14209 case detail::value_t::number_float: | |
| 14210 case detail::value_t::binary: | |
| 14211 case detail::value_t::discarded: | |
| 14212 default: | |
| 14213 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); | |
| 14214 } | |
| 14215 } | |
| 14216 | |
| 14217 return *ptr; | |
| 14218 } | |
| 14219 | |
| 14220 /*! | |
| 14221 @throw parse_error.106 if an array index begins with '0' | |
| 14222 @throw parse_error.109 if an array index was not a number | |
| 14223 @throw out_of_range.402 if the array index '-' is used | |
| 14224 @throw out_of_range.404 if the JSON pointer can not be resolved | |
| 14225 */ | |
| 14226 template<typename BasicJsonType> | |
| 14227 BasicJsonType& get_checked(BasicJsonType* ptr) const | |
| 14228 { | |
| 14229 for (const auto& reference_token : reference_tokens) | |
| 14230 { | |
| 14231 switch (ptr->type()) | |
| 14232 { | |
| 14233 case detail::value_t::object: | |
| 14234 { | |
| 14235 // note: at performs range check | |
| 14236 ptr = &ptr->at(reference_token); | |
| 14237 break; | |
| 14238 } | |
| 14239 | |
| 14240 case detail::value_t::array: | |
| 14241 { | |
| 14242 if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) | |
| 14243 { | |
| 14244 // "-" always fails the range check | |
| 14245 JSON_THROW(detail::out_of_range::create(402, detail::concat( | |
| 14246 "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), | |
| 14247 ") is out of range"), ptr)); | |
| 14248 } | |
| 14249 | |
| 14250 // note: at performs range check | |
| 14251 ptr = &ptr->at(array_index<BasicJsonType>(reference_token)); | |
| 14252 break; | |
| 14253 } | |
| 14254 | |
| 14255 case detail::value_t::null: | |
| 14256 case detail::value_t::string: | |
| 14257 case detail::value_t::boolean: | |
| 14258 case detail::value_t::number_integer: | |
| 14259 case detail::value_t::number_unsigned: | |
| 14260 case detail::value_t::number_float: | |
| 14261 case detail::value_t::binary: | |
| 14262 case detail::value_t::discarded: | |
| 14263 default: | |
| 14264 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); | |
| 14265 } | |
| 14266 } | |
| 14267 | |
| 14268 return *ptr; | |
| 14269 } | |
| 14270 | |
| 14271 /*! | |
| 14272 @brief return a const reference to the pointed to value | |
| 14273 | |
| 14274 @param[in] ptr a JSON value | |
| 14275 | |
| 14276 @return const reference to the JSON value pointed to by the JSON | |
| 14277 pointer | |
| 14278 | |
| 14279 @throw parse_error.106 if an array index begins with '0' | |
| 14280 @throw parse_error.109 if an array index was not a number | |
| 14281 @throw out_of_range.402 if the array index '-' is used | |
| 14282 @throw out_of_range.404 if the JSON pointer can not be resolved | |
| 14283 */ | |
| 14284 template<typename BasicJsonType> | |
| 14285 const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const | |
| 14286 { | |
| 14287 for (const auto& reference_token : reference_tokens) | |
| 14288 { | |
| 14289 switch (ptr->type()) | |
| 14290 { | |
| 14291 case detail::value_t::object: | |
| 14292 { | |
| 14293 // use unchecked object access | |
| 14294 ptr = &ptr->operator[](reference_token); | |
| 14295 break; | |
| 14296 } | |
| 14297 | |
| 14298 case detail::value_t::array: | |
| 14299 { | |
| 14300 if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) | |
| 14301 { | |
| 14302 // "-" cannot be used for const access | |
| 14303 JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr)); | |
| 14304 } | |
| 14305 | |
| 14306 // use unchecked array access | |
| 14307 ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token)); | |
| 14308 break; | |
| 14309 } | |
| 14310 | |
| 14311 case detail::value_t::null: | |
| 14312 case detail::value_t::string: | |
| 14313 case detail::value_t::boolean: | |
| 14314 case detail::value_t::number_integer: | |
| 14315 case detail::value_t::number_unsigned: | |
| 14316 case detail::value_t::number_float: | |
| 14317 case detail::value_t::binary: | |
| 14318 case detail::value_t::discarded: | |
| 14319 default: | |
| 14320 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); | |
| 14321 } | |
| 14322 } | |
| 14323 | |
| 14324 return *ptr; | |
| 14325 } | |
| 14326 | |
| 14327 /*! | |
| 14328 @throw parse_error.106 if an array index begins with '0' | |
| 14329 @throw parse_error.109 if an array index was not a number | |
| 14330 @throw out_of_range.402 if the array index '-' is used | |
| 14331 @throw out_of_range.404 if the JSON pointer can not be resolved | |
| 14332 */ | |
| 14333 template<typename BasicJsonType> | |
| 14334 const BasicJsonType& get_checked(const BasicJsonType* ptr) const | |
| 14335 { | |
| 14336 for (const auto& reference_token : reference_tokens) | |
| 14337 { | |
| 14338 switch (ptr->type()) | |
| 14339 { | |
| 14340 case detail::value_t::object: | |
| 14341 { | |
| 14342 // note: at performs range check | |
| 14343 ptr = &ptr->at(reference_token); | |
| 14344 break; | |
| 14345 } | |
| 14346 | |
| 14347 case detail::value_t::array: | |
| 14348 { | |
| 14349 if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) | |
| 14350 { | |
| 14351 // "-" always fails the range check | |
| 14352 JSON_THROW(detail::out_of_range::create(402, detail::concat( | |
| 14353 "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), | |
| 14354 ") is out of range"), ptr)); | |
| 14355 } | |
| 14356 | |
| 14357 // note: at performs range check | |
| 14358 ptr = &ptr->at(array_index<BasicJsonType>(reference_token)); | |
| 14359 break; | |
| 14360 } | |
| 14361 | |
| 14362 case detail::value_t::null: | |
| 14363 case detail::value_t::string: | |
| 14364 case detail::value_t::boolean: | |
| 14365 case detail::value_t::number_integer: | |
| 14366 case detail::value_t::number_unsigned: | |
| 14367 case detail::value_t::number_float: | |
| 14368 case detail::value_t::binary: | |
| 14369 case detail::value_t::discarded: | |
| 14370 default: | |
| 14371 JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr)); | |
| 14372 } | |
| 14373 } | |
| 14374 | |
| 14375 return *ptr; | |
| 14376 } | |
| 14377 | |
| 14378 /*! | |
| 14379 @throw parse_error.106 if an array index begins with '0' | |
| 14380 @throw parse_error.109 if an array index was not a number | |
| 14381 */ | |
| 14382 template<typename BasicJsonType> | |
| 14383 bool contains(const BasicJsonType* ptr) const | |
| 14384 { | |
| 14385 for (const auto& reference_token : reference_tokens) | |
| 14386 { | |
| 14387 switch (ptr->type()) | |
| 14388 { | |
| 14389 case detail::value_t::object: | |
| 14390 { | |
| 14391 if (!ptr->contains(reference_token)) | |
| 14392 { | |
| 14393 // we did not find the key in the object | |
| 14394 return false; | |
| 14395 } | |
| 14396 | |
| 14397 ptr = &ptr->operator[](reference_token); | |
| 14398 break; | |
| 14399 } | |
| 14400 | |
| 14401 case detail::value_t::array: | |
| 14402 { | |
| 14403 if (JSON_HEDLEY_UNLIKELY(reference_token == "-")) | |
| 14404 { | |
| 14405 // "-" always fails the range check | |
| 14406 return false; | |
| 14407 } | |
| 14408 if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9"))) | |
| 14409 { | |
| 14410 // invalid char | |
| 14411 return false; | |
| 14412 } | |
| 14413 if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1)) | |
| 14414 { | |
| 14415 if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9'))) | |
| 14416 { | |
| 14417 // first char should be between '1' and '9' | |
| 14418 return false; | |
| 14419 } | |
| 14420 for (std::size_t i = 1; i < reference_token.size(); i++) | |
| 14421 { | |
| 14422 if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9'))) | |
| 14423 { | |
| 14424 // other char should be between '0' and '9' | |
| 14425 return false; | |
| 14426 } | |
| 14427 } | |
| 14428 } | |
| 14429 | |
| 14430 const auto idx = array_index<BasicJsonType>(reference_token); | |
| 14431 if (idx >= ptr->size()) | |
| 14432 { | |
| 14433 // index out of range | |
| 14434 return false; | |
| 14435 } | |
| 14436 | |
| 14437 ptr = &ptr->operator[](idx); | |
| 14438 break; | |
| 14439 } | |
| 14440 | |
| 14441 case detail::value_t::null: | |
| 14442 case detail::value_t::string: | |
| 14443 case detail::value_t::boolean: | |
| 14444 case detail::value_t::number_integer: | |
| 14445 case detail::value_t::number_unsigned: | |
| 14446 case detail::value_t::number_float: | |
| 14447 case detail::value_t::binary: | |
| 14448 case detail::value_t::discarded: | |
| 14449 default: | |
| 14450 { | |
| 14451 // we do not expect primitive values if there is still a | |
| 14452 // reference token to process | |
| 14453 return false; | |
| 14454 } | |
| 14455 } | |
| 14456 } | |
| 14457 | |
| 14458 // no reference token left means we found a primitive value | |
| 14459 return true; | |
| 14460 } | |
| 14461 | |
| 14462 /*! | |
| 14463 @brief split the string input to reference tokens | |
| 14464 | |
| 14465 @note This function is only called by the json_pointer constructor. | |
| 14466 All exceptions below are documented there. | |
| 14467 | |
| 14468 @throw parse_error.107 if the pointer is not empty or begins with '/' | |
| 14469 @throw parse_error.108 if character '~' is not followed by '0' or '1' | |
| 14470 */ | |
| 14471 static std::vector<string_t> split(const string_t& reference_string) | |
| 14472 { | |
| 14473 std::vector<string_t> result; | |
| 14474 | |
| 14475 // special case: empty reference string -> no reference tokens | |
| 14476 if (reference_string.empty()) | |
| 14477 { | |
| 14478 return result; | |
| 14479 } | |
| 14480 | |
| 14481 // check if nonempty reference string begins with slash | |
| 14482 if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/')) | |
| 14483 { | |
| 14484 JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr)); | |
| 14485 } | |
| 14486 | |
| 14487 // extract the reference tokens: | |
| 14488 // - slash: position of the last read slash (or end of string) | |
| 14489 // - start: position after the previous slash | |
| 14490 for ( | |
| 14491 // search for the first slash after the first character | |
| 14492 std::size_t slash = reference_string.find_first_of('/', 1), | |
| 14493 // set the beginning of the first reference token | |
| 14494 start = 1; | |
| 14495 // we can stop if start == 0 (if slash == string_t::npos) | |
| 14496 start != 0; | |
| 14497 // set the beginning of the next reference token | |
| 14498 // (will eventually be 0 if slash == string_t::npos) | |
| 14499 start = (slash == string_t::npos) ? 0 : slash + 1, | |
| 14500 // find next slash | |
| 14501 slash = reference_string.find_first_of('/', start)) | |
| 14502 { | |
| 14503 // use the text between the beginning of the reference token | |
| 14504 // (start) and the last slash (slash). | |
| 14505 auto reference_token = reference_string.substr(start, slash - start); | |
| 14506 | |
| 14507 // check reference tokens are properly escaped | |
| 14508 for (std::size_t pos = reference_token.find_first_of('~'); | |
| 14509 pos != string_t::npos; | |
| 14510 pos = reference_token.find_first_of('~', pos + 1)) | |
| 14511 { | |
| 14512 JSON_ASSERT(reference_token[pos] == '~'); | |
| 14513 | |
| 14514 // ~ must be followed by 0 or 1 | |
| 14515 if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 || | |
| 14516 (reference_token[pos + 1] != '0' && | |
| 14517 reference_token[pos + 1] != '1'))) | |
| 14518 { | |
| 14519 JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr)); | |
| 14520 } | |
| 14521 } | |
| 14522 | |
| 14523 // finally, store the reference token | |
| 14524 detail::unescape(reference_token); | |
| 14525 result.push_back(reference_token); | |
| 14526 } | |
| 14527 | |
| 14528 return result; | |
| 14529 } | |
| 14530 | |
| 14531 private: | |
| 14532 /*! | |
| 14533 @param[in] reference_string the reference string to the current value | |
| 14534 @param[in] value the value to consider | |
| 14535 @param[in,out] result the result object to insert values to | |
| 14536 | |
| 14537 @note Empty objects or arrays are flattened to `null`. | |
| 14538 */ | |
| 14539 template<typename BasicJsonType> | |
| 14540 static void flatten(const string_t& reference_string, | |
| 14541 const BasicJsonType& value, | |
| 14542 BasicJsonType& result) | |
| 14543 { | |
| 14544 switch (value.type()) | |
| 14545 { | |
| 14546 case detail::value_t::array: | |
| 14547 { | |
| 14548 if (value.m_data.m_value.array->empty()) | |
| 14549 { | |
| 14550 // flatten empty array as null | |
| 14551 result[reference_string] = nullptr; | |
| 14552 } | |
| 14553 else | |
| 14554 { | |
| 14555 // iterate array and use index as reference string | |
| 14556 for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i) | |
| 14557 { | |
| 14558 flatten(detail::concat(reference_string, '/', std::to_string(i)), | |
| 14559 value.m_data.m_value.array->operator[](i), result); | |
| 14560 } | |
| 14561 } | |
| 14562 break; | |
| 14563 } | |
| 14564 | |
| 14565 case detail::value_t::object: | |
| 14566 { | |
| 14567 if (value.m_data.m_value.object->empty()) | |
| 14568 { | |
| 14569 // flatten empty object as null | |
| 14570 result[reference_string] = nullptr; | |
| 14571 } | |
| 14572 else | |
| 14573 { | |
| 14574 // iterate object and use keys as reference string | |
| 14575 for (const auto& element : *value.m_data.m_value.object) | |
| 14576 { | |
| 14577 flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result); | |
| 14578 } | |
| 14579 } | |
| 14580 break; | |
| 14581 } | |
| 14582 | |
| 14583 case detail::value_t::null: | |
| 14584 case detail::value_t::string: | |
| 14585 case detail::value_t::boolean: | |
| 14586 case detail::value_t::number_integer: | |
| 14587 case detail::value_t::number_unsigned: | |
| 14588 case detail::value_t::number_float: | |
| 14589 case detail::value_t::binary: | |
| 14590 case detail::value_t::discarded: | |
| 14591 default: | |
| 14592 { | |
| 14593 // add primitive value with its reference string | |
| 14594 result[reference_string] = value; | |
| 14595 break; | |
| 14596 } | |
| 14597 } | |
| 14598 } | |
| 14599 | |
| 14600 /*! | |
| 14601 @param[in] value flattened JSON | |
| 14602 | |
| 14603 @return unflattened JSON | |
| 14604 | |
| 14605 @throw parse_error.109 if array index is not a number | |
| 14606 @throw type_error.314 if value is not an object | |
| 14607 @throw type_error.315 if object values are not primitive | |
| 14608 @throw type_error.313 if value cannot be unflattened | |
| 14609 */ | |
| 14610 template<typename BasicJsonType> | |
| 14611 static BasicJsonType | |
| 14612 unflatten(const BasicJsonType& value) | |
| 14613 { | |
| 14614 if (JSON_HEDLEY_UNLIKELY(!value.is_object())) | |
| 14615 { | |
| 14616 JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value)); | |
| 14617 } | |
| 14618 | |
| 14619 BasicJsonType result; | |
| 14620 | |
| 14621 // iterate the JSON object values | |
| 14622 for (const auto& element : *value.m_data.m_value.object) | |
| 14623 { | |
| 14624 if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive())) | |
| 14625 { | |
| 14626 JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second)); | |
| 14627 } | |
| 14628 | |
| 14629 // assign value to reference pointed to by JSON pointer; Note that if | |
| 14630 // the JSON pointer is "" (i.e., points to the whole value), function | |
| 14631 // get_and_create returns a reference to result itself. An assignment | |
| 14632 // will then create a primitive value. | |
| 14633 json_pointer(element.first).get_and_create(result) = element.second; | |
| 14634 } | |
| 14635 | |
| 14636 return result; | |
| 14637 } | |
| 14638 | |
| 14639 // can't use conversion operator because of ambiguity | |
| 14640 json_pointer<string_t> convert() const& | |
| 14641 { | |
| 14642 json_pointer<string_t> result; | |
| 14643 result.reference_tokens = reference_tokens; | |
| 14644 return result; | |
| 14645 } | |
| 14646 | |
| 14647 json_pointer<string_t> convert()&& | |
| 14648 { | |
| 14649 json_pointer<string_t> result; | |
| 14650 result.reference_tokens = std::move(reference_tokens); | |
| 14651 return result; | |
| 14652 } | |
| 14653 | |
| 14654 public: | |
| 14655 #if JSON_HAS_THREE_WAY_COMPARISON | |
| 14656 /// @brief compares two JSON pointers for equality | |
| 14657 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ | |
| 14658 template<typename RefStringTypeRhs> | |
| 14659 bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept | |
| 14660 { | |
| 14661 return reference_tokens == rhs.reference_tokens; | |
| 14662 } | |
| 14663 | |
| 14664 /// @brief compares JSON pointer and string for equality | |
| 14665 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ | |
| 14666 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer)) | |
| 14667 bool operator==(const string_t& rhs) const | |
| 14668 { | |
| 14669 return *this == json_pointer(rhs); | |
| 14670 } | |
| 14671 | |
| 14672 /// @brief 3-way compares two JSON pointers | |
| 14673 template<typename RefStringTypeRhs> | |
| 14674 std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD* | |
| 14675 { | |
| 14676 return reference_tokens <=> rhs.reference_tokens; // *NOPAD* | |
| 14677 } | |
| 14678 #else | |
| 14679 /// @brief compares two JSON pointers for equality | |
| 14680 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ | |
| 14681 template<typename RefStringTypeLhs, typename RefStringTypeRhs> | |
| 14682 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14683 friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14684 const json_pointer<RefStringTypeRhs>& rhs) noexcept; | |
| 14685 | |
| 14686 /// @brief compares JSON pointer and string for equality | |
| 14687 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ | |
| 14688 template<typename RefStringTypeLhs, typename StringType> | |
| 14689 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14690 friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14691 const StringType& rhs); | |
| 14692 | |
| 14693 /// @brief compares string and JSON pointer for equality | |
| 14694 /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/ | |
| 14695 template<typename RefStringTypeRhs, typename StringType> | |
| 14696 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14697 friend bool operator==(const StringType& lhs, | |
| 14698 const json_pointer<RefStringTypeRhs>& rhs); | |
| 14699 | |
| 14700 /// @brief compares two JSON pointers for inequality | |
| 14701 /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/ | |
| 14702 template<typename RefStringTypeLhs, typename RefStringTypeRhs> | |
| 14703 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14704 friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14705 const json_pointer<RefStringTypeRhs>& rhs) noexcept; | |
| 14706 | |
| 14707 /// @brief compares JSON pointer and string for inequality | |
| 14708 /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/ | |
| 14709 template<typename RefStringTypeLhs, typename StringType> | |
| 14710 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14711 friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14712 const StringType& rhs); | |
| 14713 | |
| 14714 /// @brief compares string and JSON pointer for inequality | |
| 14715 /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/ | |
| 14716 template<typename RefStringTypeRhs, typename StringType> | |
| 14717 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14718 friend bool operator!=(const StringType& lhs, | |
| 14719 const json_pointer<RefStringTypeRhs>& rhs); | |
| 14720 | |
| 14721 /// @brief compares two JSON pointer for less-than | |
| 14722 template<typename RefStringTypeLhs, typename RefStringTypeRhs> | |
| 14723 // NOLINTNEXTLINE(readability-redundant-declaration) | |
| 14724 friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14725 const json_pointer<RefStringTypeRhs>& rhs) noexcept; | |
| 14726 #endif | |
| 14727 | |
| 14728 private: | |
| 14729 /// the reference tokens | |
| 14730 std::vector<string_t> reference_tokens; | |
| 14731 }; | |
| 14732 | |
| 14733 #if !JSON_HAS_THREE_WAY_COMPARISON | |
| 14734 // functions cannot be defined inside class due to ODR violations | |
| 14735 template<typename RefStringTypeLhs, typename RefStringTypeRhs> | |
| 14736 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14737 const json_pointer<RefStringTypeRhs>& rhs) noexcept | |
| 14738 { | |
| 14739 return lhs.reference_tokens == rhs.reference_tokens; | |
| 14740 } | |
| 14741 | |
| 14742 template<typename RefStringTypeLhs, | |
| 14743 typename StringType = typename json_pointer<RefStringTypeLhs>::string_t> | |
| 14744 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) | |
| 14745 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14746 const StringType& rhs) | |
| 14747 { | |
| 14748 return lhs == json_pointer<RefStringTypeLhs>(rhs); | |
| 14749 } | |
| 14750 | |
| 14751 template<typename RefStringTypeRhs, | |
| 14752 typename StringType = typename json_pointer<RefStringTypeRhs>::string_t> | |
| 14753 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer)) | |
| 14754 inline bool operator==(const StringType& lhs, | |
| 14755 const json_pointer<RefStringTypeRhs>& rhs) | |
| 14756 { | |
| 14757 return json_pointer<RefStringTypeRhs>(lhs) == rhs; | |
| 14758 } | |
| 14759 | |
| 14760 template<typename RefStringTypeLhs, typename RefStringTypeRhs> | |
| 14761 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14762 const json_pointer<RefStringTypeRhs>& rhs) noexcept | |
| 14763 { | |
| 14764 return !(lhs == rhs); | |
| 14765 } | |
| 14766 | |
| 14767 template<typename RefStringTypeLhs, | |
| 14768 typename StringType = typename json_pointer<RefStringTypeLhs>::string_t> | |
| 14769 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) | |
| 14770 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14771 const StringType& rhs) | |
| 14772 { | |
| 14773 return !(lhs == rhs); | |
| 14774 } | |
| 14775 | |
| 14776 template<typename RefStringTypeRhs, | |
| 14777 typename StringType = typename json_pointer<RefStringTypeRhs>::string_t> | |
| 14778 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer)) | |
| 14779 inline bool operator!=(const StringType& lhs, | |
| 14780 const json_pointer<RefStringTypeRhs>& rhs) | |
| 14781 { | |
| 14782 return !(lhs == rhs); | |
| 14783 } | |
| 14784 | |
| 14785 template<typename RefStringTypeLhs, typename RefStringTypeRhs> | |
| 14786 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs, | |
| 14787 const json_pointer<RefStringTypeRhs>& rhs) noexcept | |
| 14788 { | |
| 14789 return lhs.reference_tokens < rhs.reference_tokens; | |
| 14790 } | |
| 14791 #endif | |
| 14792 | |
| 14793 NLOHMANN_JSON_NAMESPACE_END | |
| 14794 | |
| 14795 // #include <nlohmann/detail/json_ref.hpp> | |
| 14796 // __ _____ _____ _____ | |
| 14797 // __| | __| | | | JSON for Modern C++ | |
| 14798 // | | |__ | | | | | | version 3.11.3 | |
| 14799 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 14800 // | |
| 14801 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 14802 // SPDX-License-Identifier: MIT | |
| 14803 | |
| 14804 | |
| 14805 | |
| 14806 #include <initializer_list> | |
| 14807 #include <utility> | |
| 14808 | |
| 14809 // #include <nlohmann/detail/abi_macros.hpp> | |
| 14810 | |
| 14811 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 14812 | |
| 14813 | |
| 14814 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 14815 namespace detail | |
| 14816 { | |
| 14817 | |
| 14818 template<typename BasicJsonType> | |
| 14819 class json_ref | |
| 14820 { | |
| 14821 public: | |
| 14822 using value_type = BasicJsonType; | |
| 14823 | |
| 14824 json_ref(value_type&& value) | |
| 14825 : owned_value(std::move(value)) | |
| 14826 {} | |
| 14827 | |
| 14828 json_ref(const value_type& value) | |
| 14829 : value_ref(&value) | |
| 14830 {} | |
| 14831 | |
| 14832 json_ref(std::initializer_list<json_ref> init) | |
| 14833 : owned_value(init) | |
| 14834 {} | |
| 14835 | |
| 14836 template < | |
| 14837 class... Args, | |
| 14838 enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 > | |
| 14839 json_ref(Args && ... args) | |
| 14840 : owned_value(std::forward<Args>(args)...) | |
| 14841 {} | |
| 14842 | |
| 14843 // class should be movable only | |
| 14844 json_ref(json_ref&&) noexcept = default; | |
| 14845 json_ref(const json_ref&) = delete; | |
| 14846 json_ref& operator=(const json_ref&) = delete; | |
| 14847 json_ref& operator=(json_ref&&) = delete; | |
| 14848 ~json_ref() = default; | |
| 14849 | |
| 14850 value_type moved_or_copied() const | |
| 14851 { | |
| 14852 if (value_ref == nullptr) | |
| 14853 { | |
| 14854 return std::move(owned_value); | |
| 14855 } | |
| 14856 return *value_ref; | |
| 14857 } | |
| 14858 | |
| 14859 value_type const& operator*() const | |
| 14860 { | |
| 14861 return value_ref ? *value_ref : owned_value; | |
| 14862 } | |
| 14863 | |
| 14864 value_type const* operator->() const | |
| 14865 { | |
| 14866 return &** this; | |
| 14867 } | |
| 14868 | |
| 14869 private: | |
| 14870 mutable value_type owned_value = nullptr; | |
| 14871 value_type const* value_ref = nullptr; | |
| 14872 }; | |
| 14873 | |
| 14874 } // namespace detail | |
| 14875 NLOHMANN_JSON_NAMESPACE_END | |
| 14876 | |
| 14877 // #include <nlohmann/detail/macro_scope.hpp> | |
| 14878 | |
| 14879 // #include <nlohmann/detail/string_concat.hpp> | |
| 14880 | |
| 14881 // #include <nlohmann/detail/string_escape.hpp> | |
| 14882 | |
| 14883 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 14884 | |
| 14885 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 14886 | |
| 14887 // #include <nlohmann/detail/output/binary_writer.hpp> | |
| 14888 // __ _____ _____ _____ | |
| 14889 // __| | __| | | | JSON for Modern C++ | |
| 14890 // | | |__ | | | | | | version 3.11.3 | |
| 14891 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 14892 // | |
| 14893 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 14894 // SPDX-License-Identifier: MIT | |
| 14895 | |
| 14896 | |
| 14897 | |
| 14898 #include <algorithm> // reverse | |
| 14899 #include <array> // array | |
| 14900 #include <map> // map | |
| 14901 #include <cmath> // isnan, isinf | |
| 14902 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t | |
| 14903 #include <cstring> // memcpy | |
| 14904 #include <limits> // numeric_limits | |
| 14905 #include <string> // string | |
| 14906 #include <utility> // move | |
| 14907 #include <vector> // vector | |
| 14908 | |
| 14909 // #include <nlohmann/detail/input/binary_reader.hpp> | |
| 14910 | |
| 14911 // #include <nlohmann/detail/macro_scope.hpp> | |
| 14912 | |
| 14913 // #include <nlohmann/detail/output/output_adapters.hpp> | |
| 14914 // __ _____ _____ _____ | |
| 14915 // __| | __| | | | JSON for Modern C++ | |
| 14916 // | | |__ | | | | | | version 3.11.3 | |
| 14917 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 14918 // | |
| 14919 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 14920 // SPDX-License-Identifier: MIT | |
| 14921 | |
| 14922 | |
| 14923 | |
| 14924 #include <algorithm> // copy | |
| 14925 #include <cstddef> // size_t | |
| 14926 #include <iterator> // back_inserter | |
| 14927 #include <memory> // shared_ptr, make_shared | |
| 14928 #include <string> // basic_string | |
| 14929 #include <vector> // vector | |
| 14930 | |
| 14931 #ifndef JSON_NO_IO | |
| 14932 #include <ios> // streamsize | |
| 14933 #include <ostream> // basic_ostream | |
| 14934 #endif // JSON_NO_IO | |
| 14935 | |
| 14936 // #include <nlohmann/detail/macro_scope.hpp> | |
| 14937 | |
| 14938 | |
| 14939 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 14940 namespace detail | |
| 14941 { | |
| 14942 | |
| 14943 /// abstract output adapter interface | |
| 14944 template<typename CharType> struct output_adapter_protocol | |
| 14945 { | |
| 14946 virtual void write_character(CharType c) = 0; | |
| 14947 virtual void write_characters(const CharType* s, std::size_t length) = 0; | |
| 14948 virtual ~output_adapter_protocol() = default; | |
| 14949 | |
| 14950 output_adapter_protocol() = default; | |
| 14951 output_adapter_protocol(const output_adapter_protocol&) = default; | |
| 14952 output_adapter_protocol(output_adapter_protocol&&) noexcept = default; | |
| 14953 output_adapter_protocol& operator=(const output_adapter_protocol&) = default; | |
| 14954 output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default; | |
| 14955 }; | |
| 14956 | |
| 14957 /// a type to simplify interfaces | |
| 14958 template<typename CharType> | |
| 14959 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>; | |
| 14960 | |
| 14961 /// output adapter for byte vectors | |
| 14962 template<typename CharType, typename AllocatorType = std::allocator<CharType>> | |
| 14963 class output_vector_adapter : public output_adapter_protocol<CharType> | |
| 14964 { | |
| 14965 public: | |
| 14966 explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept | |
| 14967 : v(vec) | |
| 14968 {} | |
| 14969 | |
| 14970 void write_character(CharType c) override | |
| 14971 { | |
| 14972 v.push_back(c); | |
| 14973 } | |
| 14974 | |
| 14975 JSON_HEDLEY_NON_NULL(2) | |
| 14976 void write_characters(const CharType* s, std::size_t length) override | |
| 14977 { | |
| 14978 v.insert(v.end(), s, s + length); | |
| 14979 } | |
| 14980 | |
| 14981 private: | |
| 14982 std::vector<CharType, AllocatorType>& v; | |
| 14983 }; | |
| 14984 | |
| 14985 #ifndef JSON_NO_IO | |
| 14986 /// output adapter for output streams | |
| 14987 template<typename CharType> | |
| 14988 class output_stream_adapter : public output_adapter_protocol<CharType> | |
| 14989 { | |
| 14990 public: | |
| 14991 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept | |
| 14992 : stream(s) | |
| 14993 {} | |
| 14994 | |
| 14995 void write_character(CharType c) override | |
| 14996 { | |
| 14997 stream.put(c); | |
| 14998 } | |
| 14999 | |
| 15000 JSON_HEDLEY_NON_NULL(2) | |
| 15001 void write_characters(const CharType* s, std::size_t length) override | |
| 15002 { | |
| 15003 stream.write(s, static_cast<std::streamsize>(length)); | |
| 15004 } | |
| 15005 | |
| 15006 private: | |
| 15007 std::basic_ostream<CharType>& stream; | |
| 15008 }; | |
| 15009 #endif // JSON_NO_IO | |
| 15010 | |
| 15011 /// output adapter for basic_string | |
| 15012 template<typename CharType, typename StringType = std::basic_string<CharType>> | |
| 15013 class output_string_adapter : public output_adapter_protocol<CharType> | |
| 15014 { | |
| 15015 public: | |
| 15016 explicit output_string_adapter(StringType& s) noexcept | |
| 15017 : str(s) | |
| 15018 {} | |
| 15019 | |
| 15020 void write_character(CharType c) override | |
| 15021 { | |
| 15022 str.push_back(c); | |
| 15023 } | |
| 15024 | |
| 15025 JSON_HEDLEY_NON_NULL(2) | |
| 15026 void write_characters(const CharType* s, std::size_t length) override | |
| 15027 { | |
| 15028 str.append(s, length); | |
| 15029 } | |
| 15030 | |
| 15031 private: | |
| 15032 StringType& str; | |
| 15033 }; | |
| 15034 | |
| 15035 template<typename CharType, typename StringType = std::basic_string<CharType>> | |
| 15036 class output_adapter | |
| 15037 { | |
| 15038 public: | |
| 15039 template<typename AllocatorType = std::allocator<CharType>> | |
| 15040 output_adapter(std::vector<CharType, AllocatorType>& vec) | |
| 15041 : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {} | |
| 15042 | |
| 15043 #ifndef JSON_NO_IO | |
| 15044 output_adapter(std::basic_ostream<CharType>& s) | |
| 15045 : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {} | |
| 15046 #endif // JSON_NO_IO | |
| 15047 | |
| 15048 output_adapter(StringType& s) | |
| 15049 : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {} | |
| 15050 | |
| 15051 operator output_adapter_t<CharType>() | |
| 15052 { | |
| 15053 return oa; | |
| 15054 } | |
| 15055 | |
| 15056 private: | |
| 15057 output_adapter_t<CharType> oa = nullptr; | |
| 15058 }; | |
| 15059 | |
| 15060 } // namespace detail | |
| 15061 NLOHMANN_JSON_NAMESPACE_END | |
| 15062 | |
| 15063 // #include <nlohmann/detail/string_concat.hpp> | |
| 15064 | |
| 15065 | |
| 15066 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 15067 namespace detail | |
| 15068 { | |
| 15069 | |
| 15070 /////////////////// | |
| 15071 // binary writer // | |
| 15072 /////////////////// | |
| 15073 | |
| 15074 /*! | |
| 15075 @brief serialization to CBOR and MessagePack values | |
| 15076 */ | |
| 15077 template<typename BasicJsonType, typename CharType> | |
| 15078 class binary_writer | |
| 15079 { | |
| 15080 using string_t = typename BasicJsonType::string_t; | |
| 15081 using binary_t = typename BasicJsonType::binary_t; | |
| 15082 using number_float_t = typename BasicJsonType::number_float_t; | |
| 15083 | |
| 15084 public: | |
| 15085 /*! | |
| 15086 @brief create a binary writer | |
| 15087 | |
| 15088 @param[in] adapter output adapter to write to | |
| 15089 */ | |
| 15090 explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter)) | |
| 15091 { | |
| 15092 JSON_ASSERT(oa); | |
| 15093 } | |
| 15094 | |
| 15095 /*! | |
| 15096 @param[in] j JSON value to serialize | |
| 15097 @pre j.type() == value_t::object | |
| 15098 */ | |
| 15099 void write_bson(const BasicJsonType& j) | |
| 15100 { | |
| 15101 switch (j.type()) | |
| 15102 { | |
| 15103 case value_t::object: | |
| 15104 { | |
| 15105 write_bson_object(*j.m_data.m_value.object); | |
| 15106 break; | |
| 15107 } | |
| 15108 | |
| 15109 case value_t::null: | |
| 15110 case value_t::array: | |
| 15111 case value_t::string: | |
| 15112 case value_t::boolean: | |
| 15113 case value_t::number_integer: | |
| 15114 case value_t::number_unsigned: | |
| 15115 case value_t::number_float: | |
| 15116 case value_t::binary: | |
| 15117 case value_t::discarded: | |
| 15118 default: | |
| 15119 { | |
| 15120 JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j)); | |
| 15121 } | |
| 15122 } | |
| 15123 } | |
| 15124 | |
| 15125 /*! | |
| 15126 @param[in] j JSON value to serialize | |
| 15127 */ | |
| 15128 void write_cbor(const BasicJsonType& j) | |
| 15129 { | |
| 15130 switch (j.type()) | |
| 15131 { | |
| 15132 case value_t::null: | |
| 15133 { | |
| 15134 oa->write_character(to_char_type(0xF6)); | |
| 15135 break; | |
| 15136 } | |
| 15137 | |
| 15138 case value_t::boolean: | |
| 15139 { | |
| 15140 oa->write_character(j.m_data.m_value.boolean | |
| 15141 ? to_char_type(0xF5) | |
| 15142 : to_char_type(0xF4)); | |
| 15143 break; | |
| 15144 } | |
| 15145 | |
| 15146 case value_t::number_integer: | |
| 15147 { | |
| 15148 if (j.m_data.m_value.number_integer >= 0) | |
| 15149 { | |
| 15150 // CBOR does not differentiate between positive signed | |
| 15151 // integers and unsigned integers. Therefore, we used the | |
| 15152 // code from the value_t::number_unsigned case here. | |
| 15153 if (j.m_data.m_value.number_integer <= 0x17) | |
| 15154 { | |
| 15155 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer)); | |
| 15156 } | |
| 15157 else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15158 { | |
| 15159 oa->write_character(to_char_type(0x18)); | |
| 15160 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer)); | |
| 15161 } | |
| 15162 else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15163 { | |
| 15164 oa->write_character(to_char_type(0x19)); | |
| 15165 write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer)); | |
| 15166 } | |
| 15167 else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15168 { | |
| 15169 oa->write_character(to_char_type(0x1A)); | |
| 15170 write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer)); | |
| 15171 } | |
| 15172 else | |
| 15173 { | |
| 15174 oa->write_character(to_char_type(0x1B)); | |
| 15175 write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer)); | |
| 15176 } | |
| 15177 } | |
| 15178 else | |
| 15179 { | |
| 15180 // The conversions below encode the sign in the first | |
| 15181 // byte, and the value is converted to a positive number. | |
| 15182 const auto positive_number = -1 - j.m_data.m_value.number_integer; | |
| 15183 if (j.m_data.m_value.number_integer >= -24) | |
| 15184 { | |
| 15185 write_number(static_cast<std::uint8_t>(0x20 + positive_number)); | |
| 15186 } | |
| 15187 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15188 { | |
| 15189 oa->write_character(to_char_type(0x38)); | |
| 15190 write_number(static_cast<std::uint8_t>(positive_number)); | |
| 15191 } | |
| 15192 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15193 { | |
| 15194 oa->write_character(to_char_type(0x39)); | |
| 15195 write_number(static_cast<std::uint16_t>(positive_number)); | |
| 15196 } | |
| 15197 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15198 { | |
| 15199 oa->write_character(to_char_type(0x3A)); | |
| 15200 write_number(static_cast<std::uint32_t>(positive_number)); | |
| 15201 } | |
| 15202 else | |
| 15203 { | |
| 15204 oa->write_character(to_char_type(0x3B)); | |
| 15205 write_number(static_cast<std::uint64_t>(positive_number)); | |
| 15206 } | |
| 15207 } | |
| 15208 break; | |
| 15209 } | |
| 15210 | |
| 15211 case value_t::number_unsigned: | |
| 15212 { | |
| 15213 if (j.m_data.m_value.number_unsigned <= 0x17) | |
| 15214 { | |
| 15215 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned)); | |
| 15216 } | |
| 15217 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15218 { | |
| 15219 oa->write_character(to_char_type(0x18)); | |
| 15220 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned)); | |
| 15221 } | |
| 15222 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15223 { | |
| 15224 oa->write_character(to_char_type(0x19)); | |
| 15225 write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned)); | |
| 15226 } | |
| 15227 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15228 { | |
| 15229 oa->write_character(to_char_type(0x1A)); | |
| 15230 write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned)); | |
| 15231 } | |
| 15232 else | |
| 15233 { | |
| 15234 oa->write_character(to_char_type(0x1B)); | |
| 15235 write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned)); | |
| 15236 } | |
| 15237 break; | |
| 15238 } | |
| 15239 | |
| 15240 case value_t::number_float: | |
| 15241 { | |
| 15242 if (std::isnan(j.m_data.m_value.number_float)) | |
| 15243 { | |
| 15244 // NaN is 0xf97e00 in CBOR | |
| 15245 oa->write_character(to_char_type(0xF9)); | |
| 15246 oa->write_character(to_char_type(0x7E)); | |
| 15247 oa->write_character(to_char_type(0x00)); | |
| 15248 } | |
| 15249 else if (std::isinf(j.m_data.m_value.number_float)) | |
| 15250 { | |
| 15251 // Infinity is 0xf97c00, -Infinity is 0xf9fc00 | |
| 15252 oa->write_character(to_char_type(0xf9)); | |
| 15253 oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC)); | |
| 15254 oa->write_character(to_char_type(0x00)); | |
| 15255 } | |
| 15256 else | |
| 15257 { | |
| 15258 write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor); | |
| 15259 } | |
| 15260 break; | |
| 15261 } | |
| 15262 | |
| 15263 case value_t::string: | |
| 15264 { | |
| 15265 // step 1: write control byte and the string length | |
| 15266 const auto N = j.m_data.m_value.string->size(); | |
| 15267 if (N <= 0x17) | |
| 15268 { | |
| 15269 write_number(static_cast<std::uint8_t>(0x60 + N)); | |
| 15270 } | |
| 15271 else if (N <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15272 { | |
| 15273 oa->write_character(to_char_type(0x78)); | |
| 15274 write_number(static_cast<std::uint8_t>(N)); | |
| 15275 } | |
| 15276 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15277 { | |
| 15278 oa->write_character(to_char_type(0x79)); | |
| 15279 write_number(static_cast<std::uint16_t>(N)); | |
| 15280 } | |
| 15281 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15282 { | |
| 15283 oa->write_character(to_char_type(0x7A)); | |
| 15284 write_number(static_cast<std::uint32_t>(N)); | |
| 15285 } | |
| 15286 // LCOV_EXCL_START | |
| 15287 else if (N <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15288 { | |
| 15289 oa->write_character(to_char_type(0x7B)); | |
| 15290 write_number(static_cast<std::uint64_t>(N)); | |
| 15291 } | |
| 15292 // LCOV_EXCL_STOP | |
| 15293 | |
| 15294 // step 2: write the string | |
| 15295 oa->write_characters( | |
| 15296 reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()), | |
| 15297 j.m_data.m_value.string->size()); | |
| 15298 break; | |
| 15299 } | |
| 15300 | |
| 15301 case value_t::array: | |
| 15302 { | |
| 15303 // step 1: write control byte and the array size | |
| 15304 const auto N = j.m_data.m_value.array->size(); | |
| 15305 if (N <= 0x17) | |
| 15306 { | |
| 15307 write_number(static_cast<std::uint8_t>(0x80 + N)); | |
| 15308 } | |
| 15309 else if (N <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15310 { | |
| 15311 oa->write_character(to_char_type(0x98)); | |
| 15312 write_number(static_cast<std::uint8_t>(N)); | |
| 15313 } | |
| 15314 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15315 { | |
| 15316 oa->write_character(to_char_type(0x99)); | |
| 15317 write_number(static_cast<std::uint16_t>(N)); | |
| 15318 } | |
| 15319 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15320 { | |
| 15321 oa->write_character(to_char_type(0x9A)); | |
| 15322 write_number(static_cast<std::uint32_t>(N)); | |
| 15323 } | |
| 15324 // LCOV_EXCL_START | |
| 15325 else if (N <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15326 { | |
| 15327 oa->write_character(to_char_type(0x9B)); | |
| 15328 write_number(static_cast<std::uint64_t>(N)); | |
| 15329 } | |
| 15330 // LCOV_EXCL_STOP | |
| 15331 | |
| 15332 // step 2: write each element | |
| 15333 for (const auto& el : *j.m_data.m_value.array) | |
| 15334 { | |
| 15335 write_cbor(el); | |
| 15336 } | |
| 15337 break; | |
| 15338 } | |
| 15339 | |
| 15340 case value_t::binary: | |
| 15341 { | |
| 15342 if (j.m_data.m_value.binary->has_subtype()) | |
| 15343 { | |
| 15344 if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15345 { | |
| 15346 write_number(static_cast<std::uint8_t>(0xd8)); | |
| 15347 write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype())); | |
| 15348 } | |
| 15349 else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15350 { | |
| 15351 write_number(static_cast<std::uint8_t>(0xd9)); | |
| 15352 write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype())); | |
| 15353 } | |
| 15354 else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15355 { | |
| 15356 write_number(static_cast<std::uint8_t>(0xda)); | |
| 15357 write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype())); | |
| 15358 } | |
| 15359 else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15360 { | |
| 15361 write_number(static_cast<std::uint8_t>(0xdb)); | |
| 15362 write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype())); | |
| 15363 } | |
| 15364 } | |
| 15365 | |
| 15366 // step 1: write control byte and the binary array size | |
| 15367 const auto N = j.m_data.m_value.binary->size(); | |
| 15368 if (N <= 0x17) | |
| 15369 { | |
| 15370 write_number(static_cast<std::uint8_t>(0x40 + N)); | |
| 15371 } | |
| 15372 else if (N <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15373 { | |
| 15374 oa->write_character(to_char_type(0x58)); | |
| 15375 write_number(static_cast<std::uint8_t>(N)); | |
| 15376 } | |
| 15377 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15378 { | |
| 15379 oa->write_character(to_char_type(0x59)); | |
| 15380 write_number(static_cast<std::uint16_t>(N)); | |
| 15381 } | |
| 15382 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15383 { | |
| 15384 oa->write_character(to_char_type(0x5A)); | |
| 15385 write_number(static_cast<std::uint32_t>(N)); | |
| 15386 } | |
| 15387 // LCOV_EXCL_START | |
| 15388 else if (N <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15389 { | |
| 15390 oa->write_character(to_char_type(0x5B)); | |
| 15391 write_number(static_cast<std::uint64_t>(N)); | |
| 15392 } | |
| 15393 // LCOV_EXCL_STOP | |
| 15394 | |
| 15395 // step 2: write each element | |
| 15396 oa->write_characters( | |
| 15397 reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()), | |
| 15398 N); | |
| 15399 | |
| 15400 break; | |
| 15401 } | |
| 15402 | |
| 15403 case value_t::object: | |
| 15404 { | |
| 15405 // step 1: write control byte and the object size | |
| 15406 const auto N = j.m_data.m_value.object->size(); | |
| 15407 if (N <= 0x17) | |
| 15408 { | |
| 15409 write_number(static_cast<std::uint8_t>(0xA0 + N)); | |
| 15410 } | |
| 15411 else if (N <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15412 { | |
| 15413 oa->write_character(to_char_type(0xB8)); | |
| 15414 write_number(static_cast<std::uint8_t>(N)); | |
| 15415 } | |
| 15416 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15417 { | |
| 15418 oa->write_character(to_char_type(0xB9)); | |
| 15419 write_number(static_cast<std::uint16_t>(N)); | |
| 15420 } | |
| 15421 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15422 { | |
| 15423 oa->write_character(to_char_type(0xBA)); | |
| 15424 write_number(static_cast<std::uint32_t>(N)); | |
| 15425 } | |
| 15426 // LCOV_EXCL_START | |
| 15427 else if (N <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15428 { | |
| 15429 oa->write_character(to_char_type(0xBB)); | |
| 15430 write_number(static_cast<std::uint64_t>(N)); | |
| 15431 } | |
| 15432 // LCOV_EXCL_STOP | |
| 15433 | |
| 15434 // step 2: write each element | |
| 15435 for (const auto& el : *j.m_data.m_value.object) | |
| 15436 { | |
| 15437 write_cbor(el.first); | |
| 15438 write_cbor(el.second); | |
| 15439 } | |
| 15440 break; | |
| 15441 } | |
| 15442 | |
| 15443 case value_t::discarded: | |
| 15444 default: | |
| 15445 break; | |
| 15446 } | |
| 15447 } | |
| 15448 | |
| 15449 /*! | |
| 15450 @param[in] j JSON value to serialize | |
| 15451 */ | |
| 15452 void write_msgpack(const BasicJsonType& j) | |
| 15453 { | |
| 15454 switch (j.type()) | |
| 15455 { | |
| 15456 case value_t::null: // nil | |
| 15457 { | |
| 15458 oa->write_character(to_char_type(0xC0)); | |
| 15459 break; | |
| 15460 } | |
| 15461 | |
| 15462 case value_t::boolean: // true and false | |
| 15463 { | |
| 15464 oa->write_character(j.m_data.m_value.boolean | |
| 15465 ? to_char_type(0xC3) | |
| 15466 : to_char_type(0xC2)); | |
| 15467 break; | |
| 15468 } | |
| 15469 | |
| 15470 case value_t::number_integer: | |
| 15471 { | |
| 15472 if (j.m_data.m_value.number_integer >= 0) | |
| 15473 { | |
| 15474 // MessagePack does not differentiate between positive | |
| 15475 // signed integers and unsigned integers. Therefore, we used | |
| 15476 // the code from the value_t::number_unsigned case here. | |
| 15477 if (j.m_data.m_value.number_unsigned < 128) | |
| 15478 { | |
| 15479 // positive fixnum | |
| 15480 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer)); | |
| 15481 } | |
| 15482 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15483 { | |
| 15484 // uint 8 | |
| 15485 oa->write_character(to_char_type(0xCC)); | |
| 15486 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer)); | |
| 15487 } | |
| 15488 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15489 { | |
| 15490 // uint 16 | |
| 15491 oa->write_character(to_char_type(0xCD)); | |
| 15492 write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer)); | |
| 15493 } | |
| 15494 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15495 { | |
| 15496 // uint 32 | |
| 15497 oa->write_character(to_char_type(0xCE)); | |
| 15498 write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer)); | |
| 15499 } | |
| 15500 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15501 { | |
| 15502 // uint 64 | |
| 15503 oa->write_character(to_char_type(0xCF)); | |
| 15504 write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer)); | |
| 15505 } | |
| 15506 } | |
| 15507 else | |
| 15508 { | |
| 15509 if (j.m_data.m_value.number_integer >= -32) | |
| 15510 { | |
| 15511 // negative fixnum | |
| 15512 write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer)); | |
| 15513 } | |
| 15514 else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() && | |
| 15515 j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)()) | |
| 15516 { | |
| 15517 // int 8 | |
| 15518 oa->write_character(to_char_type(0xD0)); | |
| 15519 write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer)); | |
| 15520 } | |
| 15521 else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() && | |
| 15522 j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)()) | |
| 15523 { | |
| 15524 // int 16 | |
| 15525 oa->write_character(to_char_type(0xD1)); | |
| 15526 write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer)); | |
| 15527 } | |
| 15528 else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() && | |
| 15529 j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)()) | |
| 15530 { | |
| 15531 // int 32 | |
| 15532 oa->write_character(to_char_type(0xD2)); | |
| 15533 write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer)); | |
| 15534 } | |
| 15535 else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() && | |
| 15536 j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)()) | |
| 15537 { | |
| 15538 // int 64 | |
| 15539 oa->write_character(to_char_type(0xD3)); | |
| 15540 write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer)); | |
| 15541 } | |
| 15542 } | |
| 15543 break; | |
| 15544 } | |
| 15545 | |
| 15546 case value_t::number_unsigned: | |
| 15547 { | |
| 15548 if (j.m_data.m_value.number_unsigned < 128) | |
| 15549 { | |
| 15550 // positive fixnum | |
| 15551 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer)); | |
| 15552 } | |
| 15553 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15554 { | |
| 15555 // uint 8 | |
| 15556 oa->write_character(to_char_type(0xCC)); | |
| 15557 write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer)); | |
| 15558 } | |
| 15559 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15560 { | |
| 15561 // uint 16 | |
| 15562 oa->write_character(to_char_type(0xCD)); | |
| 15563 write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer)); | |
| 15564 } | |
| 15565 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15566 { | |
| 15567 // uint 32 | |
| 15568 oa->write_character(to_char_type(0xCE)); | |
| 15569 write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer)); | |
| 15570 } | |
| 15571 else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 15572 { | |
| 15573 // uint 64 | |
| 15574 oa->write_character(to_char_type(0xCF)); | |
| 15575 write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer)); | |
| 15576 } | |
| 15577 break; | |
| 15578 } | |
| 15579 | |
| 15580 case value_t::number_float: | |
| 15581 { | |
| 15582 write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack); | |
| 15583 break; | |
| 15584 } | |
| 15585 | |
| 15586 case value_t::string: | |
| 15587 { | |
| 15588 // step 1: write control byte and the string length | |
| 15589 const auto N = j.m_data.m_value.string->size(); | |
| 15590 if (N <= 31) | |
| 15591 { | |
| 15592 // fixstr | |
| 15593 write_number(static_cast<std::uint8_t>(0xA0 | N)); | |
| 15594 } | |
| 15595 else if (N <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15596 { | |
| 15597 // str 8 | |
| 15598 oa->write_character(to_char_type(0xD9)); | |
| 15599 write_number(static_cast<std::uint8_t>(N)); | |
| 15600 } | |
| 15601 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15602 { | |
| 15603 // str 16 | |
| 15604 oa->write_character(to_char_type(0xDA)); | |
| 15605 write_number(static_cast<std::uint16_t>(N)); | |
| 15606 } | |
| 15607 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15608 { | |
| 15609 // str 32 | |
| 15610 oa->write_character(to_char_type(0xDB)); | |
| 15611 write_number(static_cast<std::uint32_t>(N)); | |
| 15612 } | |
| 15613 | |
| 15614 // step 2: write the string | |
| 15615 oa->write_characters( | |
| 15616 reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()), | |
| 15617 j.m_data.m_value.string->size()); | |
| 15618 break; | |
| 15619 } | |
| 15620 | |
| 15621 case value_t::array: | |
| 15622 { | |
| 15623 // step 1: write control byte and the array size | |
| 15624 const auto N = j.m_data.m_value.array->size(); | |
| 15625 if (N <= 15) | |
| 15626 { | |
| 15627 // fixarray | |
| 15628 write_number(static_cast<std::uint8_t>(0x90 | N)); | |
| 15629 } | |
| 15630 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15631 { | |
| 15632 // array 16 | |
| 15633 oa->write_character(to_char_type(0xDC)); | |
| 15634 write_number(static_cast<std::uint16_t>(N)); | |
| 15635 } | |
| 15636 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15637 { | |
| 15638 // array 32 | |
| 15639 oa->write_character(to_char_type(0xDD)); | |
| 15640 write_number(static_cast<std::uint32_t>(N)); | |
| 15641 } | |
| 15642 | |
| 15643 // step 2: write each element | |
| 15644 for (const auto& el : *j.m_data.m_value.array) | |
| 15645 { | |
| 15646 write_msgpack(el); | |
| 15647 } | |
| 15648 break; | |
| 15649 } | |
| 15650 | |
| 15651 case value_t::binary: | |
| 15652 { | |
| 15653 // step 0: determine if the binary type has a set subtype to | |
| 15654 // determine whether or not to use the ext or fixext types | |
| 15655 const bool use_ext = j.m_data.m_value.binary->has_subtype(); | |
| 15656 | |
| 15657 // step 1: write control byte and the byte string length | |
| 15658 const auto N = j.m_data.m_value.binary->size(); | |
| 15659 if (N <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 15660 { | |
| 15661 std::uint8_t output_type{}; | |
| 15662 bool fixed = true; | |
| 15663 if (use_ext) | |
| 15664 { | |
| 15665 switch (N) | |
| 15666 { | |
| 15667 case 1: | |
| 15668 output_type = 0xD4; // fixext 1 | |
| 15669 break; | |
| 15670 case 2: | |
| 15671 output_type = 0xD5; // fixext 2 | |
| 15672 break; | |
| 15673 case 4: | |
| 15674 output_type = 0xD6; // fixext 4 | |
| 15675 break; | |
| 15676 case 8: | |
| 15677 output_type = 0xD7; // fixext 8 | |
| 15678 break; | |
| 15679 case 16: | |
| 15680 output_type = 0xD8; // fixext 16 | |
| 15681 break; | |
| 15682 default: | |
| 15683 output_type = 0xC7; // ext 8 | |
| 15684 fixed = false; | |
| 15685 break; | |
| 15686 } | |
| 15687 | |
| 15688 } | |
| 15689 else | |
| 15690 { | |
| 15691 output_type = 0xC4; // bin 8 | |
| 15692 fixed = false; | |
| 15693 } | |
| 15694 | |
| 15695 oa->write_character(to_char_type(output_type)); | |
| 15696 if (!fixed) | |
| 15697 { | |
| 15698 write_number(static_cast<std::uint8_t>(N)); | |
| 15699 } | |
| 15700 } | |
| 15701 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15702 { | |
| 15703 const std::uint8_t output_type = use_ext | |
| 15704 ? 0xC8 // ext 16 | |
| 15705 : 0xC5; // bin 16 | |
| 15706 | |
| 15707 oa->write_character(to_char_type(output_type)); | |
| 15708 write_number(static_cast<std::uint16_t>(N)); | |
| 15709 } | |
| 15710 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15711 { | |
| 15712 const std::uint8_t output_type = use_ext | |
| 15713 ? 0xC9 // ext 32 | |
| 15714 : 0xC6; // bin 32 | |
| 15715 | |
| 15716 oa->write_character(to_char_type(output_type)); | |
| 15717 write_number(static_cast<std::uint32_t>(N)); | |
| 15718 } | |
| 15719 | |
| 15720 // step 1.5: if this is an ext type, write the subtype | |
| 15721 if (use_ext) | |
| 15722 { | |
| 15723 write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype())); | |
| 15724 } | |
| 15725 | |
| 15726 // step 2: write the byte string | |
| 15727 oa->write_characters( | |
| 15728 reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()), | |
| 15729 N); | |
| 15730 | |
| 15731 break; | |
| 15732 } | |
| 15733 | |
| 15734 case value_t::object: | |
| 15735 { | |
| 15736 // step 1: write control byte and the object size | |
| 15737 const auto N = j.m_data.m_value.object->size(); | |
| 15738 if (N <= 15) | |
| 15739 { | |
| 15740 // fixmap | |
| 15741 write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF))); | |
| 15742 } | |
| 15743 else if (N <= (std::numeric_limits<std::uint16_t>::max)()) | |
| 15744 { | |
| 15745 // map 16 | |
| 15746 oa->write_character(to_char_type(0xDE)); | |
| 15747 write_number(static_cast<std::uint16_t>(N)); | |
| 15748 } | |
| 15749 else if (N <= (std::numeric_limits<std::uint32_t>::max)()) | |
| 15750 { | |
| 15751 // map 32 | |
| 15752 oa->write_character(to_char_type(0xDF)); | |
| 15753 write_number(static_cast<std::uint32_t>(N)); | |
| 15754 } | |
| 15755 | |
| 15756 // step 2: write each element | |
| 15757 for (const auto& el : *j.m_data.m_value.object) | |
| 15758 { | |
| 15759 write_msgpack(el.first); | |
| 15760 write_msgpack(el.second); | |
| 15761 } | |
| 15762 break; | |
| 15763 } | |
| 15764 | |
| 15765 case value_t::discarded: | |
| 15766 default: | |
| 15767 break; | |
| 15768 } | |
| 15769 } | |
| 15770 | |
| 15771 /*! | |
| 15772 @param[in] j JSON value to serialize | |
| 15773 @param[in] use_count whether to use '#' prefixes (optimized format) | |
| 15774 @param[in] use_type whether to use '$' prefixes (optimized format) | |
| 15775 @param[in] add_prefix whether prefixes need to be used for this value | |
| 15776 @param[in] use_bjdata whether write in BJData format, default is false | |
| 15777 */ | |
| 15778 void write_ubjson(const BasicJsonType& j, const bool use_count, | |
| 15779 const bool use_type, const bool add_prefix = true, | |
| 15780 const bool use_bjdata = false) | |
| 15781 { | |
| 15782 switch (j.type()) | |
| 15783 { | |
| 15784 case value_t::null: | |
| 15785 { | |
| 15786 if (add_prefix) | |
| 15787 { | |
| 15788 oa->write_character(to_char_type('Z')); | |
| 15789 } | |
| 15790 break; | |
| 15791 } | |
| 15792 | |
| 15793 case value_t::boolean: | |
| 15794 { | |
| 15795 if (add_prefix) | |
| 15796 { | |
| 15797 oa->write_character(j.m_data.m_value.boolean | |
| 15798 ? to_char_type('T') | |
| 15799 : to_char_type('F')); | |
| 15800 } | |
| 15801 break; | |
| 15802 } | |
| 15803 | |
| 15804 case value_t::number_integer: | |
| 15805 { | |
| 15806 write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata); | |
| 15807 break; | |
| 15808 } | |
| 15809 | |
| 15810 case value_t::number_unsigned: | |
| 15811 { | |
| 15812 write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata); | |
| 15813 break; | |
| 15814 } | |
| 15815 | |
| 15816 case value_t::number_float: | |
| 15817 { | |
| 15818 write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata); | |
| 15819 break; | |
| 15820 } | |
| 15821 | |
| 15822 case value_t::string: | |
| 15823 { | |
| 15824 if (add_prefix) | |
| 15825 { | |
| 15826 oa->write_character(to_char_type('S')); | |
| 15827 } | |
| 15828 write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata); | |
| 15829 oa->write_characters( | |
| 15830 reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()), | |
| 15831 j.m_data.m_value.string->size()); | |
| 15832 break; | |
| 15833 } | |
| 15834 | |
| 15835 case value_t::array: | |
| 15836 { | |
| 15837 if (add_prefix) | |
| 15838 { | |
| 15839 oa->write_character(to_char_type('[')); | |
| 15840 } | |
| 15841 | |
| 15842 bool prefix_required = true; | |
| 15843 if (use_type && !j.m_data.m_value.array->empty()) | |
| 15844 { | |
| 15845 JSON_ASSERT(use_count); | |
| 15846 const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata); | |
| 15847 const bool same_prefix = std::all_of(j.begin() + 1, j.end(), | |
| 15848 [this, first_prefix, use_bjdata](const BasicJsonType & v) | |
| 15849 { | |
| 15850 return ubjson_prefix(v, use_bjdata) == first_prefix; | |
| 15851 }); | |
| 15852 | |
| 15853 std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type | |
| 15854 | |
| 15855 if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end())) | |
| 15856 { | |
| 15857 prefix_required = false; | |
| 15858 oa->write_character(to_char_type('$')); | |
| 15859 oa->write_character(first_prefix); | |
| 15860 } | |
| 15861 } | |
| 15862 | |
| 15863 if (use_count) | |
| 15864 { | |
| 15865 oa->write_character(to_char_type('#')); | |
| 15866 write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata); | |
| 15867 } | |
| 15868 | |
| 15869 for (const auto& el : *j.m_data.m_value.array) | |
| 15870 { | |
| 15871 write_ubjson(el, use_count, use_type, prefix_required, use_bjdata); | |
| 15872 } | |
| 15873 | |
| 15874 if (!use_count) | |
| 15875 { | |
| 15876 oa->write_character(to_char_type(']')); | |
| 15877 } | |
| 15878 | |
| 15879 break; | |
| 15880 } | |
| 15881 | |
| 15882 case value_t::binary: | |
| 15883 { | |
| 15884 if (add_prefix) | |
| 15885 { | |
| 15886 oa->write_character(to_char_type('[')); | |
| 15887 } | |
| 15888 | |
| 15889 if (use_type && !j.m_data.m_value.binary->empty()) | |
| 15890 { | |
| 15891 JSON_ASSERT(use_count); | |
| 15892 oa->write_character(to_char_type('$')); | |
| 15893 oa->write_character('U'); | |
| 15894 } | |
| 15895 | |
| 15896 if (use_count) | |
| 15897 { | |
| 15898 oa->write_character(to_char_type('#')); | |
| 15899 write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata); | |
| 15900 } | |
| 15901 | |
| 15902 if (use_type) | |
| 15903 { | |
| 15904 oa->write_characters( | |
| 15905 reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()), | |
| 15906 j.m_data.m_value.binary->size()); | |
| 15907 } | |
| 15908 else | |
| 15909 { | |
| 15910 for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i) | |
| 15911 { | |
| 15912 oa->write_character(to_char_type('U')); | |
| 15913 oa->write_character(j.m_data.m_value.binary->data()[i]); | |
| 15914 } | |
| 15915 } | |
| 15916 | |
| 15917 if (!use_count) | |
| 15918 { | |
| 15919 oa->write_character(to_char_type(']')); | |
| 15920 } | |
| 15921 | |
| 15922 break; | |
| 15923 } | |
| 15924 | |
| 15925 case value_t::object: | |
| 15926 { | |
| 15927 if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end()) | |
| 15928 { | |
| 15929 if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type)) // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata) | |
| 15930 { | |
| 15931 break; | |
| 15932 } | |
| 15933 } | |
| 15934 | |
| 15935 if (add_prefix) | |
| 15936 { | |
| 15937 oa->write_character(to_char_type('{')); | |
| 15938 } | |
| 15939 | |
| 15940 bool prefix_required = true; | |
| 15941 if (use_type && !j.m_data.m_value.object->empty()) | |
| 15942 { | |
| 15943 JSON_ASSERT(use_count); | |
| 15944 const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata); | |
| 15945 const bool same_prefix = std::all_of(j.begin(), j.end(), | |
| 15946 [this, first_prefix, use_bjdata](const BasicJsonType & v) | |
| 15947 { | |
| 15948 return ubjson_prefix(v, use_bjdata) == first_prefix; | |
| 15949 }); | |
| 15950 | |
| 15951 std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type | |
| 15952 | |
| 15953 if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end())) | |
| 15954 { | |
| 15955 prefix_required = false; | |
| 15956 oa->write_character(to_char_type('$')); | |
| 15957 oa->write_character(first_prefix); | |
| 15958 } | |
| 15959 } | |
| 15960 | |
| 15961 if (use_count) | |
| 15962 { | |
| 15963 oa->write_character(to_char_type('#')); | |
| 15964 write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata); | |
| 15965 } | |
| 15966 | |
| 15967 for (const auto& el : *j.m_data.m_value.object) | |
| 15968 { | |
| 15969 write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata); | |
| 15970 oa->write_characters( | |
| 15971 reinterpret_cast<const CharType*>(el.first.c_str()), | |
| 15972 el.first.size()); | |
| 15973 write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata); | |
| 15974 } | |
| 15975 | |
| 15976 if (!use_count) | |
| 15977 { | |
| 15978 oa->write_character(to_char_type('}')); | |
| 15979 } | |
| 15980 | |
| 15981 break; | |
| 15982 } | |
| 15983 | |
| 15984 case value_t::discarded: | |
| 15985 default: | |
| 15986 break; | |
| 15987 } | |
| 15988 } | |
| 15989 | |
| 15990 private: | |
| 15991 ////////// | |
| 15992 // BSON // | |
| 15993 ////////// | |
| 15994 | |
| 15995 /*! | |
| 15996 @return The size of a BSON document entry header, including the id marker | |
| 15997 and the entry name size (and its null-terminator). | |
| 15998 */ | |
| 15999 static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j) | |
| 16000 { | |
| 16001 const auto it = name.find(static_cast<typename string_t::value_type>(0)); | |
| 16002 if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos)) | |
| 16003 { | |
| 16004 JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j)); | |
| 16005 static_cast<void>(j); | |
| 16006 } | |
| 16007 | |
| 16008 return /*id*/ 1ul + name.size() + /*zero-terminator*/1u; | |
| 16009 } | |
| 16010 | |
| 16011 /*! | |
| 16012 @brief Writes the given @a element_type and @a name to the output adapter | |
| 16013 */ | |
| 16014 void write_bson_entry_header(const string_t& name, | |
| 16015 const std::uint8_t element_type) | |
| 16016 { | |
| 16017 oa->write_character(to_char_type(element_type)); // boolean | |
| 16018 oa->write_characters( | |
| 16019 reinterpret_cast<const CharType*>(name.c_str()), | |
| 16020 name.size() + 1u); | |
| 16021 } | |
| 16022 | |
| 16023 /*! | |
| 16024 @brief Writes a BSON element with key @a name and boolean value @a value | |
| 16025 */ | |
| 16026 void write_bson_boolean(const string_t& name, | |
| 16027 const bool value) | |
| 16028 { | |
| 16029 write_bson_entry_header(name, 0x08); | |
| 16030 oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00)); | |
| 16031 } | |
| 16032 | |
| 16033 /*! | |
| 16034 @brief Writes a BSON element with key @a name and double value @a value | |
| 16035 */ | |
| 16036 void write_bson_double(const string_t& name, | |
| 16037 const double value) | |
| 16038 { | |
| 16039 write_bson_entry_header(name, 0x01); | |
| 16040 write_number<double>(value, true); | |
| 16041 } | |
| 16042 | |
| 16043 /*! | |
| 16044 @return The size of the BSON-encoded string in @a value | |
| 16045 */ | |
| 16046 static std::size_t calc_bson_string_size(const string_t& value) | |
| 16047 { | |
| 16048 return sizeof(std::int32_t) + value.size() + 1ul; | |
| 16049 } | |
| 16050 | |
| 16051 /*! | |
| 16052 @brief Writes a BSON element with key @a name and string value @a value | |
| 16053 */ | |
| 16054 void write_bson_string(const string_t& name, | |
| 16055 const string_t& value) | |
| 16056 { | |
| 16057 write_bson_entry_header(name, 0x02); | |
| 16058 | |
| 16059 write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true); | |
| 16060 oa->write_characters( | |
| 16061 reinterpret_cast<const CharType*>(value.c_str()), | |
| 16062 value.size() + 1); | |
| 16063 } | |
| 16064 | |
| 16065 /*! | |
| 16066 @brief Writes a BSON element with key @a name and null value | |
| 16067 */ | |
| 16068 void write_bson_null(const string_t& name) | |
| 16069 { | |
| 16070 write_bson_entry_header(name, 0x0A); | |
| 16071 } | |
| 16072 | |
| 16073 /*! | |
| 16074 @return The size of the BSON-encoded integer @a value | |
| 16075 */ | |
| 16076 static std::size_t calc_bson_integer_size(const std::int64_t value) | |
| 16077 { | |
| 16078 return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)() | |
| 16079 ? sizeof(std::int32_t) | |
| 16080 : sizeof(std::int64_t); | |
| 16081 } | |
| 16082 | |
| 16083 /*! | |
| 16084 @brief Writes a BSON element with key @a name and integer @a value | |
| 16085 */ | |
| 16086 void write_bson_integer(const string_t& name, | |
| 16087 const std::int64_t value) | |
| 16088 { | |
| 16089 if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()) | |
| 16090 { | |
| 16091 write_bson_entry_header(name, 0x10); // int32 | |
| 16092 write_number<std::int32_t>(static_cast<std::int32_t>(value), true); | |
| 16093 } | |
| 16094 else | |
| 16095 { | |
| 16096 write_bson_entry_header(name, 0x12); // int64 | |
| 16097 write_number<std::int64_t>(static_cast<std::int64_t>(value), true); | |
| 16098 } | |
| 16099 } | |
| 16100 | |
| 16101 /*! | |
| 16102 @return The size of the BSON-encoded unsigned integer in @a j | |
| 16103 */ | |
| 16104 static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept | |
| 16105 { | |
| 16106 return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)())) | |
| 16107 ? sizeof(std::int32_t) | |
| 16108 : sizeof(std::int64_t); | |
| 16109 } | |
| 16110 | |
| 16111 /*! | |
| 16112 @brief Writes a BSON element with key @a name and unsigned @a value | |
| 16113 */ | |
| 16114 void write_bson_unsigned(const string_t& name, | |
| 16115 const BasicJsonType& j) | |
| 16116 { | |
| 16117 if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)())) | |
| 16118 { | |
| 16119 write_bson_entry_header(name, 0x10 /* int32 */); | |
| 16120 write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true); | |
| 16121 } | |
| 16122 else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)())) | |
| 16123 { | |
| 16124 write_bson_entry_header(name, 0x12 /* int64 */); | |
| 16125 write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true); | |
| 16126 } | |
| 16127 else | |
| 16128 { | |
| 16129 JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j)); | |
| 16130 } | |
| 16131 } | |
| 16132 | |
| 16133 /*! | |
| 16134 @brief Writes a BSON element with key @a name and object @a value | |
| 16135 */ | |
| 16136 void write_bson_object_entry(const string_t& name, | |
| 16137 const typename BasicJsonType::object_t& value) | |
| 16138 { | |
| 16139 write_bson_entry_header(name, 0x03); // object | |
| 16140 write_bson_object(value); | |
| 16141 } | |
| 16142 | |
| 16143 /*! | |
| 16144 @return The size of the BSON-encoded array @a value | |
| 16145 */ | |
| 16146 static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value) | |
| 16147 { | |
| 16148 std::size_t array_index = 0ul; | |
| 16149 | |
| 16150 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) | |
| 16151 { | |
| 16152 return result + calc_bson_element_size(std::to_string(array_index++), el); | |
| 16153 }); | |
| 16154 | |
| 16155 return sizeof(std::int32_t) + embedded_document_size + 1ul; | |
| 16156 } | |
| 16157 | |
| 16158 /*! | |
| 16159 @return The size of the BSON-encoded binary array @a value | |
| 16160 */ | |
| 16161 static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value) | |
| 16162 { | |
| 16163 return sizeof(std::int32_t) + value.size() + 1ul; | |
| 16164 } | |
| 16165 | |
| 16166 /*! | |
| 16167 @brief Writes a BSON element with key @a name and array @a value | |
| 16168 */ | |
| 16169 void write_bson_array(const string_t& name, | |
| 16170 const typename BasicJsonType::array_t& value) | |
| 16171 { | |
| 16172 write_bson_entry_header(name, 0x04); // array | |
| 16173 write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true); | |
| 16174 | |
| 16175 std::size_t array_index = 0ul; | |
| 16176 | |
| 16177 for (const auto& el : value) | |
| 16178 { | |
| 16179 write_bson_element(std::to_string(array_index++), el); | |
| 16180 } | |
| 16181 | |
| 16182 oa->write_character(to_char_type(0x00)); | |
| 16183 } | |
| 16184 | |
| 16185 /*! | |
| 16186 @brief Writes a BSON element with key @a name and binary value @a value | |
| 16187 */ | |
| 16188 void write_bson_binary(const string_t& name, | |
| 16189 const binary_t& value) | |
| 16190 { | |
| 16191 write_bson_entry_header(name, 0x05); | |
| 16192 | |
| 16193 write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true); | |
| 16194 write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00)); | |
| 16195 | |
| 16196 oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size()); | |
| 16197 } | |
| 16198 | |
| 16199 /*! | |
| 16200 @brief Calculates the size necessary to serialize the JSON value @a j with its @a name | |
| 16201 @return The calculated size for the BSON document entry for @a j with the given @a name. | |
| 16202 */ | |
| 16203 static std::size_t calc_bson_element_size(const string_t& name, | |
| 16204 const BasicJsonType& j) | |
| 16205 { | |
| 16206 const auto header_size = calc_bson_entry_header_size(name, j); | |
| 16207 switch (j.type()) | |
| 16208 { | |
| 16209 case value_t::object: | |
| 16210 return header_size + calc_bson_object_size(*j.m_data.m_value.object); | |
| 16211 | |
| 16212 case value_t::array: | |
| 16213 return header_size + calc_bson_array_size(*j.m_data.m_value.array); | |
| 16214 | |
| 16215 case value_t::binary: | |
| 16216 return header_size + calc_bson_binary_size(*j.m_data.m_value.binary); | |
| 16217 | |
| 16218 case value_t::boolean: | |
| 16219 return header_size + 1ul; | |
| 16220 | |
| 16221 case value_t::number_float: | |
| 16222 return header_size + 8ul; | |
| 16223 | |
| 16224 case value_t::number_integer: | |
| 16225 return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer); | |
| 16226 | |
| 16227 case value_t::number_unsigned: | |
| 16228 return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned); | |
| 16229 | |
| 16230 case value_t::string: | |
| 16231 return header_size + calc_bson_string_size(*j.m_data.m_value.string); | |
| 16232 | |
| 16233 case value_t::null: | |
| 16234 return header_size + 0ul; | |
| 16235 | |
| 16236 // LCOV_EXCL_START | |
| 16237 case value_t::discarded: | |
| 16238 default: | |
| 16239 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) | |
| 16240 return 0ul; | |
| 16241 // LCOV_EXCL_STOP | |
| 16242 } | |
| 16243 } | |
| 16244 | |
| 16245 /*! | |
| 16246 @brief Serializes the JSON value @a j to BSON and associates it with the | |
| 16247 key @a name. | |
| 16248 @param name The name to associate with the JSON entity @a j within the | |
| 16249 current BSON document | |
| 16250 */ | |
| 16251 void write_bson_element(const string_t& name, | |
| 16252 const BasicJsonType& j) | |
| 16253 { | |
| 16254 switch (j.type()) | |
| 16255 { | |
| 16256 case value_t::object: | |
| 16257 return write_bson_object_entry(name, *j.m_data.m_value.object); | |
| 16258 | |
| 16259 case value_t::array: | |
| 16260 return write_bson_array(name, *j.m_data.m_value.array); | |
| 16261 | |
| 16262 case value_t::binary: | |
| 16263 return write_bson_binary(name, *j.m_data.m_value.binary); | |
| 16264 | |
| 16265 case value_t::boolean: | |
| 16266 return write_bson_boolean(name, j.m_data.m_value.boolean); | |
| 16267 | |
| 16268 case value_t::number_float: | |
| 16269 return write_bson_double(name, j.m_data.m_value.number_float); | |
| 16270 | |
| 16271 case value_t::number_integer: | |
| 16272 return write_bson_integer(name, j.m_data.m_value.number_integer); | |
| 16273 | |
| 16274 case value_t::number_unsigned: | |
| 16275 return write_bson_unsigned(name, j); | |
| 16276 | |
| 16277 case value_t::string: | |
| 16278 return write_bson_string(name, *j.m_data.m_value.string); | |
| 16279 | |
| 16280 case value_t::null: | |
| 16281 return write_bson_null(name); | |
| 16282 | |
| 16283 // LCOV_EXCL_START | |
| 16284 case value_t::discarded: | |
| 16285 default: | |
| 16286 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) | |
| 16287 return; | |
| 16288 // LCOV_EXCL_STOP | |
| 16289 } | |
| 16290 } | |
| 16291 | |
| 16292 /*! | |
| 16293 @brief Calculates the size of the BSON serialization of the given | |
| 16294 JSON-object @a j. | |
| 16295 @param[in] value JSON value to serialize | |
| 16296 @pre value.type() == value_t::object | |
| 16297 */ | |
| 16298 static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value) | |
| 16299 { | |
| 16300 const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0), | |
| 16301 [](size_t result, const typename BasicJsonType::object_t::value_type & el) | |
| 16302 { | |
| 16303 return result += calc_bson_element_size(el.first, el.second); | |
| 16304 }); | |
| 16305 | |
| 16306 return sizeof(std::int32_t) + document_size + 1ul; | |
| 16307 } | |
| 16308 | |
| 16309 /*! | |
| 16310 @param[in] value JSON value to serialize | |
| 16311 @pre value.type() == value_t::object | |
| 16312 */ | |
| 16313 void write_bson_object(const typename BasicJsonType::object_t& value) | |
| 16314 { | |
| 16315 write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true); | |
| 16316 | |
| 16317 for (const auto& el : value) | |
| 16318 { | |
| 16319 write_bson_element(el.first, el.second); | |
| 16320 } | |
| 16321 | |
| 16322 oa->write_character(to_char_type(0x00)); | |
| 16323 } | |
| 16324 | |
| 16325 ////////// | |
| 16326 // CBOR // | |
| 16327 ////////// | |
| 16328 | |
| 16329 static constexpr CharType get_cbor_float_prefix(float /*unused*/) | |
| 16330 { | |
| 16331 return to_char_type(0xFA); // Single-Precision Float | |
| 16332 } | |
| 16333 | |
| 16334 static constexpr CharType get_cbor_float_prefix(double /*unused*/) | |
| 16335 { | |
| 16336 return to_char_type(0xFB); // Double-Precision Float | |
| 16337 } | |
| 16338 | |
| 16339 ///////////// | |
| 16340 // MsgPack // | |
| 16341 ///////////// | |
| 16342 | |
| 16343 static constexpr CharType get_msgpack_float_prefix(float /*unused*/) | |
| 16344 { | |
| 16345 return to_char_type(0xCA); // float 32 | |
| 16346 } | |
| 16347 | |
| 16348 static constexpr CharType get_msgpack_float_prefix(double /*unused*/) | |
| 16349 { | |
| 16350 return to_char_type(0xCB); // float 64 | |
| 16351 } | |
| 16352 | |
| 16353 //////////// | |
| 16354 // UBJSON // | |
| 16355 //////////// | |
| 16356 | |
| 16357 // UBJSON: write number (floating point) | |
| 16358 template<typename NumberType, typename std::enable_if< | |
| 16359 std::is_floating_point<NumberType>::value, int>::type = 0> | |
| 16360 void write_number_with_ubjson_prefix(const NumberType n, | |
| 16361 const bool add_prefix, | |
| 16362 const bool use_bjdata) | |
| 16363 { | |
| 16364 if (add_prefix) | |
| 16365 { | |
| 16366 oa->write_character(get_ubjson_float_prefix(n)); | |
| 16367 } | |
| 16368 write_number(n, use_bjdata); | |
| 16369 } | |
| 16370 | |
| 16371 // UBJSON: write number (unsigned integer) | |
| 16372 template<typename NumberType, typename std::enable_if< | |
| 16373 std::is_unsigned<NumberType>::value, int>::type = 0> | |
| 16374 void write_number_with_ubjson_prefix(const NumberType n, | |
| 16375 const bool add_prefix, | |
| 16376 const bool use_bjdata) | |
| 16377 { | |
| 16378 if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)())) | |
| 16379 { | |
| 16380 if (add_prefix) | |
| 16381 { | |
| 16382 oa->write_character(to_char_type('i')); // int8 | |
| 16383 } | |
| 16384 write_number(static_cast<std::uint8_t>(n), use_bjdata); | |
| 16385 } | |
| 16386 else if (n <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 16387 { | |
| 16388 if (add_prefix) | |
| 16389 { | |
| 16390 oa->write_character(to_char_type('U')); // uint8 | |
| 16391 } | |
| 16392 write_number(static_cast<std::uint8_t>(n), use_bjdata); | |
| 16393 } | |
| 16394 else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)())) | |
| 16395 { | |
| 16396 if (add_prefix) | |
| 16397 { | |
| 16398 oa->write_character(to_char_type('I')); // int16 | |
| 16399 } | |
| 16400 write_number(static_cast<std::int16_t>(n), use_bjdata); | |
| 16401 } | |
| 16402 else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)())) | |
| 16403 { | |
| 16404 if (add_prefix) | |
| 16405 { | |
| 16406 oa->write_character(to_char_type('u')); // uint16 - bjdata only | |
| 16407 } | |
| 16408 write_number(static_cast<std::uint16_t>(n), use_bjdata); | |
| 16409 } | |
| 16410 else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)())) | |
| 16411 { | |
| 16412 if (add_prefix) | |
| 16413 { | |
| 16414 oa->write_character(to_char_type('l')); // int32 | |
| 16415 } | |
| 16416 write_number(static_cast<std::int32_t>(n), use_bjdata); | |
| 16417 } | |
| 16418 else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)())) | |
| 16419 { | |
| 16420 if (add_prefix) | |
| 16421 { | |
| 16422 oa->write_character(to_char_type('m')); // uint32 - bjdata only | |
| 16423 } | |
| 16424 write_number(static_cast<std::uint32_t>(n), use_bjdata); | |
| 16425 } | |
| 16426 else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)())) | |
| 16427 { | |
| 16428 if (add_prefix) | |
| 16429 { | |
| 16430 oa->write_character(to_char_type('L')); // int64 | |
| 16431 } | |
| 16432 write_number(static_cast<std::int64_t>(n), use_bjdata); | |
| 16433 } | |
| 16434 else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)()) | |
| 16435 { | |
| 16436 if (add_prefix) | |
| 16437 { | |
| 16438 oa->write_character(to_char_type('M')); // uint64 - bjdata only | |
| 16439 } | |
| 16440 write_number(static_cast<std::uint64_t>(n), use_bjdata); | |
| 16441 } | |
| 16442 else | |
| 16443 { | |
| 16444 if (add_prefix) | |
| 16445 { | |
| 16446 oa->write_character(to_char_type('H')); // high-precision number | |
| 16447 } | |
| 16448 | |
| 16449 const auto number = BasicJsonType(n).dump(); | |
| 16450 write_number_with_ubjson_prefix(number.size(), true, use_bjdata); | |
| 16451 for (std::size_t i = 0; i < number.size(); ++i) | |
| 16452 { | |
| 16453 oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i]))); | |
| 16454 } | |
| 16455 } | |
| 16456 } | |
| 16457 | |
| 16458 // UBJSON: write number (signed integer) | |
| 16459 template < typename NumberType, typename std::enable_if < | |
| 16460 std::is_signed<NumberType>::value&& | |
| 16461 !std::is_floating_point<NumberType>::value, int >::type = 0 > | |
| 16462 void write_number_with_ubjson_prefix(const NumberType n, | |
| 16463 const bool add_prefix, | |
| 16464 const bool use_bjdata) | |
| 16465 { | |
| 16466 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)()) | |
| 16467 { | |
| 16468 if (add_prefix) | |
| 16469 { | |
| 16470 oa->write_character(to_char_type('i')); // int8 | |
| 16471 } | |
| 16472 write_number(static_cast<std::int8_t>(n), use_bjdata); | |
| 16473 } | |
| 16474 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)())) | |
| 16475 { | |
| 16476 if (add_prefix) | |
| 16477 { | |
| 16478 oa->write_character(to_char_type('U')); // uint8 | |
| 16479 } | |
| 16480 write_number(static_cast<std::uint8_t>(n), use_bjdata); | |
| 16481 } | |
| 16482 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)()) | |
| 16483 { | |
| 16484 if (add_prefix) | |
| 16485 { | |
| 16486 oa->write_character(to_char_type('I')); // int16 | |
| 16487 } | |
| 16488 write_number(static_cast<std::int16_t>(n), use_bjdata); | |
| 16489 } | |
| 16490 else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)()))) | |
| 16491 { | |
| 16492 if (add_prefix) | |
| 16493 { | |
| 16494 oa->write_character(to_char_type('u')); // uint16 - bjdata only | |
| 16495 } | |
| 16496 write_number(static_cast<uint16_t>(n), use_bjdata); | |
| 16497 } | |
| 16498 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)()) | |
| 16499 { | |
| 16500 if (add_prefix) | |
| 16501 { | |
| 16502 oa->write_character(to_char_type('l')); // int32 | |
| 16503 } | |
| 16504 write_number(static_cast<std::int32_t>(n), use_bjdata); | |
| 16505 } | |
| 16506 else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)()))) | |
| 16507 { | |
| 16508 if (add_prefix) | |
| 16509 { | |
| 16510 oa->write_character(to_char_type('m')); // uint32 - bjdata only | |
| 16511 } | |
| 16512 write_number(static_cast<uint32_t>(n), use_bjdata); | |
| 16513 } | |
| 16514 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)()) | |
| 16515 { | |
| 16516 if (add_prefix) | |
| 16517 { | |
| 16518 oa->write_character(to_char_type('L')); // int64 | |
| 16519 } | |
| 16520 write_number(static_cast<std::int64_t>(n), use_bjdata); | |
| 16521 } | |
| 16522 // LCOV_EXCL_START | |
| 16523 else | |
| 16524 { | |
| 16525 if (add_prefix) | |
| 16526 { | |
| 16527 oa->write_character(to_char_type('H')); // high-precision number | |
| 16528 } | |
| 16529 | |
| 16530 const auto number = BasicJsonType(n).dump(); | |
| 16531 write_number_with_ubjson_prefix(number.size(), true, use_bjdata); | |
| 16532 for (std::size_t i = 0; i < number.size(); ++i) | |
| 16533 { | |
| 16534 oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i]))); | |
| 16535 } | |
| 16536 } | |
| 16537 // LCOV_EXCL_STOP | |
| 16538 } | |
| 16539 | |
| 16540 /*! | |
| 16541 @brief determine the type prefix of container values | |
| 16542 */ | |
| 16543 CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept | |
| 16544 { | |
| 16545 switch (j.type()) | |
| 16546 { | |
| 16547 case value_t::null: | |
| 16548 return 'Z'; | |
| 16549 | |
| 16550 case value_t::boolean: | |
| 16551 return j.m_data.m_value.boolean ? 'T' : 'F'; | |
| 16552 | |
| 16553 case value_t::number_integer: | |
| 16554 { | |
| 16555 if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)()) | |
| 16556 { | |
| 16557 return 'i'; | |
| 16558 } | |
| 16559 if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)()) | |
| 16560 { | |
| 16561 return 'U'; | |
| 16562 } | |
| 16563 if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)()) | |
| 16564 { | |
| 16565 return 'I'; | |
| 16566 } | |
| 16567 if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())) | |
| 16568 { | |
| 16569 return 'u'; | |
| 16570 } | |
| 16571 if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)()) | |
| 16572 { | |
| 16573 return 'l'; | |
| 16574 } | |
| 16575 if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())) | |
| 16576 { | |
| 16577 return 'm'; | |
| 16578 } | |
| 16579 if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)()) | |
| 16580 { | |
| 16581 return 'L'; | |
| 16582 } | |
| 16583 // anything else is treated as high-precision number | |
| 16584 return 'H'; // LCOV_EXCL_LINE | |
| 16585 } | |
| 16586 | |
| 16587 case value_t::number_unsigned: | |
| 16588 { | |
| 16589 if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)())) | |
| 16590 { | |
| 16591 return 'i'; | |
| 16592 } | |
| 16593 if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)())) | |
| 16594 { | |
| 16595 return 'U'; | |
| 16596 } | |
| 16597 if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)())) | |
| 16598 { | |
| 16599 return 'I'; | |
| 16600 } | |
| 16601 if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)())) | |
| 16602 { | |
| 16603 return 'u'; | |
| 16604 } | |
| 16605 if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)())) | |
| 16606 { | |
| 16607 return 'l'; | |
| 16608 } | |
| 16609 if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)())) | |
| 16610 { | |
| 16611 return 'm'; | |
| 16612 } | |
| 16613 if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)())) | |
| 16614 { | |
| 16615 return 'L'; | |
| 16616 } | |
| 16617 if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)()) | |
| 16618 { | |
| 16619 return 'M'; | |
| 16620 } | |
| 16621 // anything else is treated as high-precision number | |
| 16622 return 'H'; // LCOV_EXCL_LINE | |
| 16623 } | |
| 16624 | |
| 16625 case value_t::number_float: | |
| 16626 return get_ubjson_float_prefix(j.m_data.m_value.number_float); | |
| 16627 | |
| 16628 case value_t::string: | |
| 16629 return 'S'; | |
| 16630 | |
| 16631 case value_t::array: // fallthrough | |
| 16632 case value_t::binary: | |
| 16633 return '['; | |
| 16634 | |
| 16635 case value_t::object: | |
| 16636 return '{'; | |
| 16637 | |
| 16638 case value_t::discarded: | |
| 16639 default: // discarded values | |
| 16640 return 'N'; | |
| 16641 } | |
| 16642 } | |
| 16643 | |
| 16644 static constexpr CharType get_ubjson_float_prefix(float /*unused*/) | |
| 16645 { | |
| 16646 return 'd'; // float 32 | |
| 16647 } | |
| 16648 | |
| 16649 static constexpr CharType get_ubjson_float_prefix(double /*unused*/) | |
| 16650 { | |
| 16651 return 'D'; // float 64 | |
| 16652 } | |
| 16653 | |
| 16654 /*! | |
| 16655 @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid | |
| 16656 */ | |
| 16657 bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type) | |
| 16658 { | |
| 16659 std::map<string_t, CharType> bjdtype = {{"uint8", 'U'}, {"int8", 'i'}, {"uint16", 'u'}, {"int16", 'I'}, | |
| 16660 {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'} | |
| 16661 }; | |
| 16662 | |
| 16663 string_t key = "_ArrayType_"; | |
| 16664 auto it = bjdtype.find(static_cast<string_t>(value.at(key))); | |
| 16665 if (it == bjdtype.end()) | |
| 16666 { | |
| 16667 return true; | |
| 16668 } | |
| 16669 CharType dtype = it->second; | |
| 16670 | |
| 16671 key = "_ArraySize_"; | |
| 16672 std::size_t len = (value.at(key).empty() ? 0 : 1); | |
| 16673 for (const auto& el : value.at(key)) | |
| 16674 { | |
| 16675 len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned); | |
| 16676 } | |
| 16677 | |
| 16678 key = "_ArrayData_"; | |
| 16679 if (value.at(key).size() != len) | |
| 16680 { | |
| 16681 return true; | |
| 16682 } | |
| 16683 | |
| 16684 oa->write_character('['); | |
| 16685 oa->write_character('$'); | |
| 16686 oa->write_character(dtype); | |
| 16687 oa->write_character('#'); | |
| 16688 | |
| 16689 key = "_ArraySize_"; | |
| 16690 write_ubjson(value.at(key), use_count, use_type, true, true); | |
| 16691 | |
| 16692 key = "_ArrayData_"; | |
| 16693 if (dtype == 'U' || dtype == 'C') | |
| 16694 { | |
| 16695 for (const auto& el : value.at(key)) | |
| 16696 { | |
| 16697 write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true); | |
| 16698 } | |
| 16699 } | |
| 16700 else if (dtype == 'i') | |
| 16701 { | |
| 16702 for (const auto& el : value.at(key)) | |
| 16703 { | |
| 16704 write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true); | |
| 16705 } | |
| 16706 } | |
| 16707 else if (dtype == 'u') | |
| 16708 { | |
| 16709 for (const auto& el : value.at(key)) | |
| 16710 { | |
| 16711 write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true); | |
| 16712 } | |
| 16713 } | |
| 16714 else if (dtype == 'I') | |
| 16715 { | |
| 16716 for (const auto& el : value.at(key)) | |
| 16717 { | |
| 16718 write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true); | |
| 16719 } | |
| 16720 } | |
| 16721 else if (dtype == 'm') | |
| 16722 { | |
| 16723 for (const auto& el : value.at(key)) | |
| 16724 { | |
| 16725 write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true); | |
| 16726 } | |
| 16727 } | |
| 16728 else if (dtype == 'l') | |
| 16729 { | |
| 16730 for (const auto& el : value.at(key)) | |
| 16731 { | |
| 16732 write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true); | |
| 16733 } | |
| 16734 } | |
| 16735 else if (dtype == 'M') | |
| 16736 { | |
| 16737 for (const auto& el : value.at(key)) | |
| 16738 { | |
| 16739 write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true); | |
| 16740 } | |
| 16741 } | |
| 16742 else if (dtype == 'L') | |
| 16743 { | |
| 16744 for (const auto& el : value.at(key)) | |
| 16745 { | |
| 16746 write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true); | |
| 16747 } | |
| 16748 } | |
| 16749 else if (dtype == 'd') | |
| 16750 { | |
| 16751 for (const auto& el : value.at(key)) | |
| 16752 { | |
| 16753 write_number(static_cast<float>(el.m_data.m_value.number_float), true); | |
| 16754 } | |
| 16755 } | |
| 16756 else if (dtype == 'D') | |
| 16757 { | |
| 16758 for (const auto& el : value.at(key)) | |
| 16759 { | |
| 16760 write_number(static_cast<double>(el.m_data.m_value.number_float), true); | |
| 16761 } | |
| 16762 } | |
| 16763 return false; | |
| 16764 } | |
| 16765 | |
| 16766 /////////////////////// | |
| 16767 // Utility functions // | |
| 16768 /////////////////////// | |
| 16769 | |
| 16770 /* | |
| 16771 @brief write a number to output input | |
| 16772 @param[in] n number of type @a NumberType | |
| 16773 @param[in] OutputIsLittleEndian Set to true if output data is | |
| 16774 required to be little endian | |
| 16775 @tparam NumberType the type of the number | |
| 16776 | |
| 16777 @note This function needs to respect the system's endianness, because bytes | |
| 16778 in CBOR, MessagePack, and UBJSON are stored in network order (big | |
| 16779 endian) and therefore need reordering on little endian systems. | |
| 16780 On the other hand, BSON and BJData use little endian and should reorder | |
| 16781 on big endian systems. | |
| 16782 */ | |
| 16783 template<typename NumberType> | |
| 16784 void write_number(const NumberType n, const bool OutputIsLittleEndian = false) | |
| 16785 { | |
| 16786 // step 1: write number to array of length NumberType | |
| 16787 std::array<CharType, sizeof(NumberType)> vec{}; | |
| 16788 std::memcpy(vec.data(), &n, sizeof(NumberType)); | |
| 16789 | |
| 16790 // step 2: write array to output (with possible reordering) | |
| 16791 if (is_little_endian != OutputIsLittleEndian) | |
| 16792 { | |
| 16793 // reverse byte order prior to conversion if necessary | |
| 16794 std::reverse(vec.begin(), vec.end()); | |
| 16795 } | |
| 16796 | |
| 16797 oa->write_characters(vec.data(), sizeof(NumberType)); | |
| 16798 } | |
| 16799 | |
| 16800 void write_compact_float(const number_float_t n, detail::input_format_t format) | |
| 16801 { | |
| 16802 #ifdef __GNUC__ | |
| 16803 #pragma GCC diagnostic push | |
| 16804 #pragma GCC diagnostic ignored "-Wfloat-equal" | |
| 16805 #endif | |
| 16806 if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) && | |
| 16807 static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) && | |
| 16808 static_cast<double>(static_cast<float>(n)) == static_cast<double>(n)) | |
| 16809 { | |
| 16810 oa->write_character(format == detail::input_format_t::cbor | |
| 16811 ? get_cbor_float_prefix(static_cast<float>(n)) | |
| 16812 : get_msgpack_float_prefix(static_cast<float>(n))); | |
| 16813 write_number(static_cast<float>(n)); | |
| 16814 } | |
| 16815 else | |
| 16816 { | |
| 16817 oa->write_character(format == detail::input_format_t::cbor | |
| 16818 ? get_cbor_float_prefix(n) | |
| 16819 : get_msgpack_float_prefix(n)); | |
| 16820 write_number(n); | |
| 16821 } | |
| 16822 #ifdef __GNUC__ | |
| 16823 #pragma GCC diagnostic pop | |
| 16824 #endif | |
| 16825 } | |
| 16826 | |
| 16827 public: | |
| 16828 // The following to_char_type functions are implement the conversion | |
| 16829 // between uint8_t and CharType. In case CharType is not unsigned, | |
| 16830 // such a conversion is required to allow values greater than 128. | |
| 16831 // See <https://github.com/nlohmann/json/issues/1286> for a discussion. | |
| 16832 template < typename C = CharType, | |
| 16833 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr > | |
| 16834 static constexpr CharType to_char_type(std::uint8_t x) noexcept | |
| 16835 { | |
| 16836 return *reinterpret_cast<char*>(&x); | |
| 16837 } | |
| 16838 | |
| 16839 template < typename C = CharType, | |
| 16840 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr > | |
| 16841 static CharType to_char_type(std::uint8_t x) noexcept | |
| 16842 { | |
| 16843 static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t"); | |
| 16844 static_assert(std::is_trivial<CharType>::value, "CharType must be trivial"); | |
| 16845 CharType result; | |
| 16846 std::memcpy(&result, &x, sizeof(x)); | |
| 16847 return result; | |
| 16848 } | |
| 16849 | |
| 16850 template<typename C = CharType, | |
| 16851 enable_if_t<std::is_unsigned<C>::value>* = nullptr> | |
| 16852 static constexpr CharType to_char_type(std::uint8_t x) noexcept | |
| 16853 { | |
| 16854 return x; | |
| 16855 } | |
| 16856 | |
| 16857 template < typename InputCharType, typename C = CharType, | |
| 16858 enable_if_t < | |
| 16859 std::is_signed<C>::value && | |
| 16860 std::is_signed<char>::value && | |
| 16861 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value | |
| 16862 > * = nullptr > | |
| 16863 static constexpr CharType to_char_type(InputCharType x) noexcept | |
| 16864 { | |
| 16865 return x; | |
| 16866 } | |
| 16867 | |
| 16868 private: | |
| 16869 /// whether we can assume little endianness | |
| 16870 const bool is_little_endian = little_endianness(); | |
| 16871 | |
| 16872 /// the output | |
| 16873 output_adapter_t<CharType> oa = nullptr; | |
| 16874 }; | |
| 16875 | |
| 16876 } // namespace detail | |
| 16877 NLOHMANN_JSON_NAMESPACE_END | |
| 16878 | |
| 16879 // #include <nlohmann/detail/output/output_adapters.hpp> | |
| 16880 | |
| 16881 // #include <nlohmann/detail/output/serializer.hpp> | |
| 16882 // __ _____ _____ _____ | |
| 16883 // __| | __| | | | JSON for Modern C++ | |
| 16884 // | | |__ | | | | | | version 3.11.3 | |
| 16885 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 16886 // | |
| 16887 // SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de> | |
| 16888 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 16889 // SPDX-License-Identifier: MIT | |
| 16890 | |
| 16891 | |
| 16892 | |
| 16893 #include <algorithm> // reverse, remove, fill, find, none_of | |
| 16894 #include <array> // array | |
| 16895 #include <clocale> // localeconv, lconv | |
| 16896 #include <cmath> // labs, isfinite, isnan, signbit | |
| 16897 #include <cstddef> // size_t, ptrdiff_t | |
| 16898 #include <cstdint> // uint8_t | |
| 16899 #include <cstdio> // snprintf | |
| 16900 #include <limits> // numeric_limits | |
| 16901 #include <string> // string, char_traits | |
| 16902 #include <iomanip> // setfill, setw | |
| 16903 #include <type_traits> // is_same | |
| 16904 #include <utility> // move | |
| 16905 | |
| 16906 // #include <nlohmann/detail/conversions/to_chars.hpp> | |
| 16907 // __ _____ _____ _____ | |
| 16908 // __| | __| | | | JSON for Modern C++ | |
| 16909 // | | |__ | | | | | | version 3.11.3 | |
| 16910 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 16911 // | |
| 16912 // SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/> | |
| 16913 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 16914 // SPDX-License-Identifier: MIT | |
| 16915 | |
| 16916 | |
| 16917 | |
| 16918 #include <array> // array | |
| 16919 #include <cmath> // signbit, isfinite | |
| 16920 #include <cstdint> // intN_t, uintN_t | |
| 16921 #include <cstring> // memcpy, memmove | |
| 16922 #include <limits> // numeric_limits | |
| 16923 #include <type_traits> // conditional | |
| 16924 | |
| 16925 // #include <nlohmann/detail/macro_scope.hpp> | |
| 16926 | |
| 16927 | |
| 16928 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 16929 namespace detail | |
| 16930 { | |
| 16931 | |
| 16932 /*! | |
| 16933 @brief implements the Grisu2 algorithm for binary to decimal floating-point | |
| 16934 conversion. | |
| 16935 | |
| 16936 This implementation is a slightly modified version of the reference | |
| 16937 implementation which may be obtained from | |
| 16938 http://florian.loitsch.com/publications (bench.tar.gz). | |
| 16939 | |
| 16940 The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch. | |
| 16941 | |
| 16942 For a detailed description of the algorithm see: | |
| 16943 | |
| 16944 [1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with | |
| 16945 Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming | |
| 16946 Language Design and Implementation, PLDI 2010 | |
| 16947 [2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately", | |
| 16948 Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language | |
| 16949 Design and Implementation, PLDI 1996 | |
| 16950 */ | |
| 16951 namespace dtoa_impl | |
| 16952 { | |
| 16953 | |
| 16954 template<typename Target, typename Source> | |
| 16955 Target reinterpret_bits(const Source source) | |
| 16956 { | |
| 16957 static_assert(sizeof(Target) == sizeof(Source), "size mismatch"); | |
| 16958 | |
| 16959 Target target; | |
| 16960 std::memcpy(&target, &source, sizeof(Source)); | |
| 16961 return target; | |
| 16962 } | |
| 16963 | |
| 16964 struct diyfp // f * 2^e | |
| 16965 { | |
| 16966 static constexpr int kPrecision = 64; // = q | |
| 16967 | |
| 16968 std::uint64_t f = 0; | |
| 16969 int e = 0; | |
| 16970 | |
| 16971 constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {} | |
| 16972 | |
| 16973 /*! | |
| 16974 @brief returns x - y | |
| 16975 @pre x.e == y.e and x.f >= y.f | |
| 16976 */ | |
| 16977 static diyfp sub(const diyfp& x, const diyfp& y) noexcept | |
| 16978 { | |
| 16979 JSON_ASSERT(x.e == y.e); | |
| 16980 JSON_ASSERT(x.f >= y.f); | |
| 16981 | |
| 16982 return {x.f - y.f, x.e}; | |
| 16983 } | |
| 16984 | |
| 16985 /*! | |
| 16986 @brief returns x * y | |
| 16987 @note The result is rounded. (Only the upper q bits are returned.) | |
| 16988 */ | |
| 16989 static diyfp mul(const diyfp& x, const diyfp& y) noexcept | |
| 16990 { | |
| 16991 static_assert(kPrecision == 64, "internal error"); | |
| 16992 | |
| 16993 // Computes: | |
| 16994 // f = round((x.f * y.f) / 2^q) | |
| 16995 // e = x.e + y.e + q | |
| 16996 | |
| 16997 // Emulate the 64-bit * 64-bit multiplication: | |
| 16998 // | |
| 16999 // p = u * v | |
| 17000 // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi) | |
| 17001 // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi ) | |
| 17002 // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 ) | |
| 17003 // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 ) | |
| 17004 // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3) | |
| 17005 // = (p0_lo ) + 2^32 (Q ) + 2^64 (H ) | |
| 17006 // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H ) | |
| 17007 // | |
| 17008 // (Since Q might be larger than 2^32 - 1) | |
| 17009 // | |
| 17010 // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H) | |
| 17011 // | |
| 17012 // (Q_hi + H does not overflow a 64-bit int) | |
| 17013 // | |
| 17014 // = p_lo + 2^64 p_hi | |
| 17015 | |
| 17016 const std::uint64_t u_lo = x.f & 0xFFFFFFFFu; | |
| 17017 const std::uint64_t u_hi = x.f >> 32u; | |
| 17018 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu; | |
| 17019 const std::uint64_t v_hi = y.f >> 32u; | |
| 17020 | |
| 17021 const std::uint64_t p0 = u_lo * v_lo; | |
| 17022 const std::uint64_t p1 = u_lo * v_hi; | |
| 17023 const std::uint64_t p2 = u_hi * v_lo; | |
| 17024 const std::uint64_t p3 = u_hi * v_hi; | |
| 17025 | |
| 17026 const std::uint64_t p0_hi = p0 >> 32u; | |
| 17027 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu; | |
| 17028 const std::uint64_t p1_hi = p1 >> 32u; | |
| 17029 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu; | |
| 17030 const std::uint64_t p2_hi = p2 >> 32u; | |
| 17031 | |
| 17032 std::uint64_t Q = p0_hi + p1_lo + p2_lo; | |
| 17033 | |
| 17034 // The full product might now be computed as | |
| 17035 // | |
| 17036 // p_hi = p3 + p2_hi + p1_hi + (Q >> 32) | |
| 17037 // p_lo = p0_lo + (Q << 32) | |
| 17038 // | |
| 17039 // But in this particular case here, the full p_lo is not required. | |
| 17040 // Effectively we only need to add the highest bit in p_lo to p_hi (and | |
| 17041 // Q_hi + 1 does not overflow). | |
| 17042 | |
| 17043 Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up | |
| 17044 | |
| 17045 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u); | |
| 17046 | |
| 17047 return {h, x.e + y.e + 64}; | |
| 17048 } | |
| 17049 | |
| 17050 /*! | |
| 17051 @brief normalize x such that the significand is >= 2^(q-1) | |
| 17052 @pre x.f != 0 | |
| 17053 */ | |
| 17054 static diyfp normalize(diyfp x) noexcept | |
| 17055 { | |
| 17056 JSON_ASSERT(x.f != 0); | |
| 17057 | |
| 17058 while ((x.f >> 63u) == 0) | |
| 17059 { | |
| 17060 x.f <<= 1u; | |
| 17061 x.e--; | |
| 17062 } | |
| 17063 | |
| 17064 return x; | |
| 17065 } | |
| 17066 | |
| 17067 /*! | |
| 17068 @brief normalize x such that the result has the exponent E | |
| 17069 @pre e >= x.e and the upper e - x.e bits of x.f must be zero. | |
| 17070 */ | |
| 17071 static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept | |
| 17072 { | |
| 17073 const int delta = x.e - target_exponent; | |
| 17074 | |
| 17075 JSON_ASSERT(delta >= 0); | |
| 17076 JSON_ASSERT(((x.f << delta) >> delta) == x.f); | |
| 17077 | |
| 17078 return {x.f << delta, target_exponent}; | |
| 17079 } | |
| 17080 }; | |
| 17081 | |
| 17082 struct boundaries | |
| 17083 { | |
| 17084 diyfp w; | |
| 17085 diyfp minus; | |
| 17086 diyfp plus; | |
| 17087 }; | |
| 17088 | |
| 17089 /*! | |
| 17090 Compute the (normalized) diyfp representing the input number 'value' and its | |
| 17091 boundaries. | |
| 17092 | |
| 17093 @pre value must be finite and positive | |
| 17094 */ | |
| 17095 template<typename FloatType> | |
| 17096 boundaries compute_boundaries(FloatType value) | |
| 17097 { | |
| 17098 JSON_ASSERT(std::isfinite(value)); | |
| 17099 JSON_ASSERT(value > 0); | |
| 17100 | |
| 17101 // Convert the IEEE representation into a diyfp. | |
| 17102 // | |
| 17103 // If v is denormal: | |
| 17104 // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1)) | |
| 17105 // If v is normalized: | |
| 17106 // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1)) | |
| 17107 | |
| 17108 static_assert(std::numeric_limits<FloatType>::is_iec559, | |
| 17109 "internal error: dtoa_short requires an IEEE-754 floating-point implementation"); | |
| 17110 | |
| 17111 constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit) | |
| 17112 constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1); | |
| 17113 constexpr int kMinExp = 1 - kBias; | |
| 17114 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1) | |
| 17115 | |
| 17116 using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type; | |
| 17117 | |
| 17118 const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value)); | |
| 17119 const std::uint64_t E = bits >> (kPrecision - 1); | |
| 17120 const std::uint64_t F = bits & (kHiddenBit - 1); | |
| 17121 | |
| 17122 const bool is_denormal = E == 0; | |
| 17123 const diyfp v = is_denormal | |
| 17124 ? diyfp(F, kMinExp) | |
| 17125 : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias); | |
| 17126 | |
| 17127 // Compute the boundaries m- and m+ of the floating-point value | |
| 17128 // v = f * 2^e. | |
| 17129 // | |
| 17130 // Determine v- and v+, the floating-point predecessor and successor if v, | |
| 17131 // respectively. | |
| 17132 // | |
| 17133 // v- = v - 2^e if f != 2^(p-1) or e == e_min (A) | |
| 17134 // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B) | |
| 17135 // | |
| 17136 // v+ = v + 2^e | |
| 17137 // | |
| 17138 // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_ | |
| 17139 // between m- and m+ round to v, regardless of how the input rounding | |
| 17140 // algorithm breaks ties. | |
| 17141 // | |
| 17142 // ---+-------------+-------------+-------------+-------------+--- (A) | |
| 17143 // v- m- v m+ v+ | |
| 17144 // | |
| 17145 // -----------------+------+------+-------------+-------------+--- (B) | |
| 17146 // v- m- v m+ v+ | |
| 17147 | |
| 17148 const bool lower_boundary_is_closer = F == 0 && E > 1; | |
| 17149 const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1); | |
| 17150 const diyfp m_minus = lower_boundary_is_closer | |
| 17151 ? diyfp(4 * v.f - 1, v.e - 2) // (B) | |
| 17152 : diyfp(2 * v.f - 1, v.e - 1); // (A) | |
| 17153 | |
| 17154 // Determine the normalized w+ = m+. | |
| 17155 const diyfp w_plus = diyfp::normalize(m_plus); | |
| 17156 | |
| 17157 // Determine w- = m- such that e_(w-) = e_(w+). | |
| 17158 const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e); | |
| 17159 | |
| 17160 return {diyfp::normalize(v), w_minus, w_plus}; | |
| 17161 } | |
| 17162 | |
| 17163 // Given normalized diyfp w, Grisu needs to find a (normalized) cached | |
| 17164 // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies | |
| 17165 // within a certain range [alpha, gamma] (Definition 3.2 from [1]) | |
| 17166 // | |
| 17167 // alpha <= e = e_c + e_w + q <= gamma | |
| 17168 // | |
| 17169 // or | |
| 17170 // | |
| 17171 // f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q | |
| 17172 // <= f_c * f_w * 2^gamma | |
| 17173 // | |
| 17174 // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies | |
| 17175 // | |
| 17176 // 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma | |
| 17177 // | |
| 17178 // or | |
| 17179 // | |
| 17180 // 2^(q - 2 + alpha) <= c * w < 2^(q + gamma) | |
| 17181 // | |
| 17182 // The choice of (alpha,gamma) determines the size of the table and the form of | |
| 17183 // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well | |
| 17184 // in practice: | |
| 17185 // | |
| 17186 // The idea is to cut the number c * w = f * 2^e into two parts, which can be | |
| 17187 // processed independently: An integral part p1, and a fractional part p2: | |
| 17188 // | |
| 17189 // f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e | |
| 17190 // = (f div 2^-e) + (f mod 2^-e) * 2^e | |
| 17191 // = p1 + p2 * 2^e | |
| 17192 // | |
| 17193 // The conversion of p1 into decimal form requires a series of divisions and | |
| 17194 // modulos by (a power of) 10. These operations are faster for 32-bit than for | |
| 17195 // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be | |
| 17196 // achieved by choosing | |
| 17197 // | |
| 17198 // -e >= 32 or e <= -32 := gamma | |
| 17199 // | |
| 17200 // In order to convert the fractional part | |
| 17201 // | |
| 17202 // p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ... | |
| 17203 // | |
| 17204 // into decimal form, the fraction is repeatedly multiplied by 10 and the digits | |
| 17205 // d[-i] are extracted in order: | |
| 17206 // | |
| 17207 // (10 * p2) div 2^-e = d[-1] | |
| 17208 // (10 * p2) mod 2^-e = d[-2] / 10^1 + ... | |
| 17209 // | |
| 17210 // The multiplication by 10 must not overflow. It is sufficient to choose | |
| 17211 // | |
| 17212 // 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64. | |
| 17213 // | |
| 17214 // Since p2 = f mod 2^-e < 2^-e, | |
| 17215 // | |
| 17216 // -e <= 60 or e >= -60 := alpha | |
| 17217 | |
| 17218 constexpr int kAlpha = -60; | |
| 17219 constexpr int kGamma = -32; | |
| 17220 | |
| 17221 struct cached_power // c = f * 2^e ~= 10^k | |
| 17222 { | |
| 17223 std::uint64_t f; | |
| 17224 int e; | |
| 17225 int k; | |
| 17226 }; | |
| 17227 | |
| 17228 /*! | |
| 17229 For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached | |
| 17230 power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c | |
| 17231 satisfies (Definition 3.2 from [1]) | |
| 17232 | |
| 17233 alpha <= e_c + e + q <= gamma. | |
| 17234 */ | |
| 17235 inline cached_power get_cached_power_for_binary_exponent(int e) | |
| 17236 { | |
| 17237 // Now | |
| 17238 // | |
| 17239 // alpha <= e_c + e + q <= gamma (1) | |
| 17240 // ==> f_c * 2^alpha <= c * 2^e * 2^q | |
| 17241 // | |
| 17242 // and since the c's are normalized, 2^(q-1) <= f_c, | |
| 17243 // | |
| 17244 // ==> 2^(q - 1 + alpha) <= c * 2^(e + q) | |
| 17245 // ==> 2^(alpha - e - 1) <= c | |
| 17246 // | |
| 17247 // If c were an exact power of ten, i.e. c = 10^k, one may determine k as | |
| 17248 // | |
| 17249 // k = ceil( log_10( 2^(alpha - e - 1) ) ) | |
| 17250 // = ceil( (alpha - e - 1) * log_10(2) ) | |
| 17251 // | |
| 17252 // From the paper: | |
| 17253 // "In theory the result of the procedure could be wrong since c is rounded, | |
| 17254 // and the computation itself is approximated [...]. In practice, however, | |
| 17255 // this simple function is sufficient." | |
| 17256 // | |
| 17257 // For IEEE double precision floating-point numbers converted into | |
| 17258 // normalized diyfp's w = f * 2^e, with q = 64, | |
| 17259 // | |
| 17260 // e >= -1022 (min IEEE exponent) | |
| 17261 // -52 (p - 1) | |
| 17262 // -52 (p - 1, possibly normalize denormal IEEE numbers) | |
| 17263 // -11 (normalize the diyfp) | |
| 17264 // = -1137 | |
| 17265 // | |
| 17266 // and | |
| 17267 // | |
| 17268 // e <= +1023 (max IEEE exponent) | |
| 17269 // -52 (p - 1) | |
| 17270 // -11 (normalize the diyfp) | |
| 17271 // = 960 | |
| 17272 // | |
| 17273 // This binary exponent range [-1137,960] results in a decimal exponent | |
| 17274 // range [-307,324]. One does not need to store a cached power for each | |
| 17275 // k in this range. For each such k it suffices to find a cached power | |
| 17276 // such that the exponent of the product lies in [alpha,gamma]. | |
| 17277 // This implies that the difference of the decimal exponents of adjacent | |
| 17278 // table entries must be less than or equal to | |
| 17279 // | |
| 17280 // floor( (gamma - alpha) * log_10(2) ) = 8. | |
| 17281 // | |
| 17282 // (A smaller distance gamma-alpha would require a larger table.) | |
| 17283 | |
| 17284 // NB: | |
| 17285 // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34. | |
| 17286 | |
| 17287 constexpr int kCachedPowersMinDecExp = -300; | |
| 17288 constexpr int kCachedPowersDecStep = 8; | |
| 17289 | |
| 17290 static constexpr std::array<cached_power, 79> kCachedPowers = | |
| 17291 { | |
| 17292 { | |
| 17293 { 0xAB70FE17C79AC6CA, -1060, -300 }, | |
| 17294 { 0xFF77B1FCBEBCDC4F, -1034, -292 }, | |
| 17295 { 0xBE5691EF416BD60C, -1007, -284 }, | |
| 17296 { 0x8DD01FAD907FFC3C, -980, -276 }, | |
| 17297 { 0xD3515C2831559A83, -954, -268 }, | |
| 17298 { 0x9D71AC8FADA6C9B5, -927, -260 }, | |
| 17299 { 0xEA9C227723EE8BCB, -901, -252 }, | |
| 17300 { 0xAECC49914078536D, -874, -244 }, | |
| 17301 { 0x823C12795DB6CE57, -847, -236 }, | |
| 17302 { 0xC21094364DFB5637, -821, -228 }, | |
| 17303 { 0x9096EA6F3848984F, -794, -220 }, | |
| 17304 { 0xD77485CB25823AC7, -768, -212 }, | |
| 17305 { 0xA086CFCD97BF97F4, -741, -204 }, | |
| 17306 { 0xEF340A98172AACE5, -715, -196 }, | |
| 17307 { 0xB23867FB2A35B28E, -688, -188 }, | |
| 17308 { 0x84C8D4DFD2C63F3B, -661, -180 }, | |
| 17309 { 0xC5DD44271AD3CDBA, -635, -172 }, | |
| 17310 { 0x936B9FCEBB25C996, -608, -164 }, | |
| 17311 { 0xDBAC6C247D62A584, -582, -156 }, | |
| 17312 { 0xA3AB66580D5FDAF6, -555, -148 }, | |
| 17313 { 0xF3E2F893DEC3F126, -529, -140 }, | |
| 17314 { 0xB5B5ADA8AAFF80B8, -502, -132 }, | |
| 17315 { 0x87625F056C7C4A8B, -475, -124 }, | |
| 17316 { 0xC9BCFF6034C13053, -449, -116 }, | |
| 17317 { 0x964E858C91BA2655, -422, -108 }, | |
| 17318 { 0xDFF9772470297EBD, -396, -100 }, | |
| 17319 { 0xA6DFBD9FB8E5B88F, -369, -92 }, | |
| 17320 { 0xF8A95FCF88747D94, -343, -84 }, | |
| 17321 { 0xB94470938FA89BCF, -316, -76 }, | |
| 17322 { 0x8A08F0F8BF0F156B, -289, -68 }, | |
| 17323 { 0xCDB02555653131B6, -263, -60 }, | |
| 17324 { 0x993FE2C6D07B7FAC, -236, -52 }, | |
| 17325 { 0xE45C10C42A2B3B06, -210, -44 }, | |
| 17326 { 0xAA242499697392D3, -183, -36 }, | |
| 17327 { 0xFD87B5F28300CA0E, -157, -28 }, | |
| 17328 { 0xBCE5086492111AEB, -130, -20 }, | |
| 17329 { 0x8CBCCC096F5088CC, -103, -12 }, | |
| 17330 { 0xD1B71758E219652C, -77, -4 }, | |
| 17331 { 0x9C40000000000000, -50, 4 }, | |
| 17332 { 0xE8D4A51000000000, -24, 12 }, | |
| 17333 { 0xAD78EBC5AC620000, 3, 20 }, | |
| 17334 { 0x813F3978F8940984, 30, 28 }, | |
| 17335 { 0xC097CE7BC90715B3, 56, 36 }, | |
| 17336 { 0x8F7E32CE7BEA5C70, 83, 44 }, | |
| 17337 { 0xD5D238A4ABE98068, 109, 52 }, | |
| 17338 { 0x9F4F2726179A2245, 136, 60 }, | |
| 17339 { 0xED63A231D4C4FB27, 162, 68 }, | |
| 17340 { 0xB0DE65388CC8ADA8, 189, 76 }, | |
| 17341 { 0x83C7088E1AAB65DB, 216, 84 }, | |
| 17342 { 0xC45D1DF942711D9A, 242, 92 }, | |
| 17343 { 0x924D692CA61BE758, 269, 100 }, | |
| 17344 { 0xDA01EE641A708DEA, 295, 108 }, | |
| 17345 { 0xA26DA3999AEF774A, 322, 116 }, | |
| 17346 { 0xF209787BB47D6B85, 348, 124 }, | |
| 17347 { 0xB454E4A179DD1877, 375, 132 }, | |
| 17348 { 0x865B86925B9BC5C2, 402, 140 }, | |
| 17349 { 0xC83553C5C8965D3D, 428, 148 }, | |
| 17350 { 0x952AB45CFA97A0B3, 455, 156 }, | |
| 17351 { 0xDE469FBD99A05FE3, 481, 164 }, | |
| 17352 { 0xA59BC234DB398C25, 508, 172 }, | |
| 17353 { 0xF6C69A72A3989F5C, 534, 180 }, | |
| 17354 { 0xB7DCBF5354E9BECE, 561, 188 }, | |
| 17355 { 0x88FCF317F22241E2, 588, 196 }, | |
| 17356 { 0xCC20CE9BD35C78A5, 614, 204 }, | |
| 17357 { 0x98165AF37B2153DF, 641, 212 }, | |
| 17358 { 0xE2A0B5DC971F303A, 667, 220 }, | |
| 17359 { 0xA8D9D1535CE3B396, 694, 228 }, | |
| 17360 { 0xFB9B7CD9A4A7443C, 720, 236 }, | |
| 17361 { 0xBB764C4CA7A44410, 747, 244 }, | |
| 17362 { 0x8BAB8EEFB6409C1A, 774, 252 }, | |
| 17363 { 0xD01FEF10A657842C, 800, 260 }, | |
| 17364 { 0x9B10A4E5E9913129, 827, 268 }, | |
| 17365 { 0xE7109BFBA19C0C9D, 853, 276 }, | |
| 17366 { 0xAC2820D9623BF429, 880, 284 }, | |
| 17367 { 0x80444B5E7AA7CF85, 907, 292 }, | |
| 17368 { 0xBF21E44003ACDD2D, 933, 300 }, | |
| 17369 { 0x8E679C2F5E44FF8F, 960, 308 }, | |
| 17370 { 0xD433179D9C8CB841, 986, 316 }, | |
| 17371 { 0x9E19DB92B4E31BA9, 1013, 324 }, | |
| 17372 } | |
| 17373 }; | |
| 17374 | |
| 17375 // This computation gives exactly the same results for k as | |
| 17376 // k = ceil((kAlpha - e - 1) * 0.30102999566398114) | |
| 17377 // for |e| <= 1500, but doesn't require floating-point operations. | |
| 17378 // NB: log_10(2) ~= 78913 / 2^18 | |
| 17379 JSON_ASSERT(e >= -1500); | |
| 17380 JSON_ASSERT(e <= 1500); | |
| 17381 const int f = kAlpha - e - 1; | |
| 17382 const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0); | |
| 17383 | |
| 17384 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep; | |
| 17385 JSON_ASSERT(index >= 0); | |
| 17386 JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size()); | |
| 17387 | |
| 17388 const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)]; | |
| 17389 JSON_ASSERT(kAlpha <= cached.e + e + 64); | |
| 17390 JSON_ASSERT(kGamma >= cached.e + e + 64); | |
| 17391 | |
| 17392 return cached; | |
| 17393 } | |
| 17394 | |
| 17395 /*! | |
| 17396 For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k. | |
| 17397 For n == 0, returns 1 and sets pow10 := 1. | |
| 17398 */ | |
| 17399 inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10) | |
| 17400 { | |
| 17401 // LCOV_EXCL_START | |
| 17402 if (n >= 1000000000) | |
| 17403 { | |
| 17404 pow10 = 1000000000; | |
| 17405 return 10; | |
| 17406 } | |
| 17407 // LCOV_EXCL_STOP | |
| 17408 if (n >= 100000000) | |
| 17409 { | |
| 17410 pow10 = 100000000; | |
| 17411 return 9; | |
| 17412 } | |
| 17413 if (n >= 10000000) | |
| 17414 { | |
| 17415 pow10 = 10000000; | |
| 17416 return 8; | |
| 17417 } | |
| 17418 if (n >= 1000000) | |
| 17419 { | |
| 17420 pow10 = 1000000; | |
| 17421 return 7; | |
| 17422 } | |
| 17423 if (n >= 100000) | |
| 17424 { | |
| 17425 pow10 = 100000; | |
| 17426 return 6; | |
| 17427 } | |
| 17428 if (n >= 10000) | |
| 17429 { | |
| 17430 pow10 = 10000; | |
| 17431 return 5; | |
| 17432 } | |
| 17433 if (n >= 1000) | |
| 17434 { | |
| 17435 pow10 = 1000; | |
| 17436 return 4; | |
| 17437 } | |
| 17438 if (n >= 100) | |
| 17439 { | |
| 17440 pow10 = 100; | |
| 17441 return 3; | |
| 17442 } | |
| 17443 if (n >= 10) | |
| 17444 { | |
| 17445 pow10 = 10; | |
| 17446 return 2; | |
| 17447 } | |
| 17448 | |
| 17449 pow10 = 1; | |
| 17450 return 1; | |
| 17451 } | |
| 17452 | |
| 17453 inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta, | |
| 17454 std::uint64_t rest, std::uint64_t ten_k) | |
| 17455 { | |
| 17456 JSON_ASSERT(len >= 1); | |
| 17457 JSON_ASSERT(dist <= delta); | |
| 17458 JSON_ASSERT(rest <= delta); | |
| 17459 JSON_ASSERT(ten_k > 0); | |
| 17460 | |
| 17461 // <--------------------------- delta ----> | |
| 17462 // <---- dist ---------> | |
| 17463 // --------------[------------------+-------------------]-------------- | |
| 17464 // M- w M+ | |
| 17465 // | |
| 17466 // ten_k | |
| 17467 // <------> | |
| 17468 // <---- rest ----> | |
| 17469 // --------------[------------------+----+--------------]-------------- | |
| 17470 // w V | |
| 17471 // = buf * 10^k | |
| 17472 // | |
| 17473 // ten_k represents a unit-in-the-last-place in the decimal representation | |
| 17474 // stored in buf. | |
| 17475 // Decrement buf by ten_k while this takes buf closer to w. | |
| 17476 | |
| 17477 // The tests are written in this order to avoid overflow in unsigned | |
| 17478 // integer arithmetic. | |
| 17479 | |
| 17480 while (rest < dist | |
| 17481 && delta - rest >= ten_k | |
| 17482 && (rest + ten_k < dist || dist - rest > rest + ten_k - dist)) | |
| 17483 { | |
| 17484 JSON_ASSERT(buf[len - 1] != '0'); | |
| 17485 buf[len - 1]--; | |
| 17486 rest += ten_k; | |
| 17487 } | |
| 17488 } | |
| 17489 | |
| 17490 /*! | |
| 17491 Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+. | |
| 17492 M- and M+ must be normalized and share the same exponent -60 <= e <= -32. | |
| 17493 */ | |
| 17494 inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent, | |
| 17495 diyfp M_minus, diyfp w, diyfp M_plus) | |
| 17496 { | |
| 17497 static_assert(kAlpha >= -60, "internal error"); | |
| 17498 static_assert(kGamma <= -32, "internal error"); | |
| 17499 | |
| 17500 // Generates the digits (and the exponent) of a decimal floating-point | |
| 17501 // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's | |
| 17502 // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma. | |
| 17503 // | |
| 17504 // <--------------------------- delta ----> | |
| 17505 // <---- dist ---------> | |
| 17506 // --------------[------------------+-------------------]-------------- | |
| 17507 // M- w M+ | |
| 17508 // | |
| 17509 // Grisu2 generates the digits of M+ from left to right and stops as soon as | |
| 17510 // V is in [M-,M+]. | |
| 17511 | |
| 17512 JSON_ASSERT(M_plus.e >= kAlpha); | |
| 17513 JSON_ASSERT(M_plus.e <= kGamma); | |
| 17514 | |
| 17515 std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e) | |
| 17516 std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e) | |
| 17517 | |
| 17518 // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0): | |
| 17519 // | |
| 17520 // M+ = f * 2^e | |
| 17521 // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e | |
| 17522 // = ((p1 ) * 2^-e + (p2 )) * 2^e | |
| 17523 // = p1 + p2 * 2^e | |
| 17524 | |
| 17525 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e); | |
| 17526 | |
| 17527 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.) | |
| 17528 std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e | |
| 17529 | |
| 17530 // 1) | |
| 17531 // | |
| 17532 // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0] | |
| 17533 | |
| 17534 JSON_ASSERT(p1 > 0); | |
| 17535 | |
| 17536 std::uint32_t pow10{}; | |
| 17537 const int k = find_largest_pow10(p1, pow10); | |
| 17538 | |
| 17539 // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1) | |
| 17540 // | |
| 17541 // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1)) | |
| 17542 // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1)) | |
| 17543 // | |
| 17544 // M+ = p1 + p2 * 2^e | |
| 17545 // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e | |
| 17546 // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e | |
| 17547 // = d[k-1] * 10^(k-1) + ( rest) * 2^e | |
| 17548 // | |
| 17549 // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0) | |
| 17550 // | |
| 17551 // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0] | |
| 17552 // | |
| 17553 // but stop as soon as | |
| 17554 // | |
| 17555 // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e | |
| 17556 | |
| 17557 int n = k; | |
| 17558 while (n > 0) | |
| 17559 { | |
| 17560 // Invariants: | |
| 17561 // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k) | |
| 17562 // pow10 = 10^(n-1) <= p1 < 10^n | |
| 17563 // | |
| 17564 const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1) | |
| 17565 const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1) | |
| 17566 // | |
| 17567 // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e | |
| 17568 // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e) | |
| 17569 // | |
| 17570 JSON_ASSERT(d <= 9); | |
| 17571 buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d | |
| 17572 // | |
| 17573 // M+ = buffer * 10^(n-1) + (r + p2 * 2^e) | |
| 17574 // | |
| 17575 p1 = r; | |
| 17576 n--; | |
| 17577 // | |
| 17578 // M+ = buffer * 10^n + (p1 + p2 * 2^e) | |
| 17579 // pow10 = 10^n | |
| 17580 // | |
| 17581 | |
| 17582 // Now check if enough digits have been generated. | |
| 17583 // Compute | |
| 17584 // | |
| 17585 // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e | |
| 17586 // | |
| 17587 // Note: | |
| 17588 // Since rest and delta share the same exponent e, it suffices to | |
| 17589 // compare the significands. | |
| 17590 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2; | |
| 17591 if (rest <= delta) | |
| 17592 { | |
| 17593 // V = buffer * 10^n, with M- <= V <= M+. | |
| 17594 | |
| 17595 decimal_exponent += n; | |
| 17596 | |
| 17597 // We may now just stop. But instead look if the buffer could be | |
| 17598 // decremented to bring V closer to w. | |
| 17599 // | |
| 17600 // pow10 = 10^n is now 1 ulp in the decimal representation V. | |
| 17601 // The rounding procedure works with diyfp's with an implicit | |
| 17602 // exponent of e. | |
| 17603 // | |
| 17604 // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e | |
| 17605 // | |
| 17606 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e; | |
| 17607 grisu2_round(buffer, length, dist, delta, rest, ten_n); | |
| 17608 | |
| 17609 return; | |
| 17610 } | |
| 17611 | |
| 17612 pow10 /= 10; | |
| 17613 // | |
| 17614 // pow10 = 10^(n-1) <= p1 < 10^n | |
| 17615 // Invariants restored. | |
| 17616 } | |
| 17617 | |
| 17618 // 2) | |
| 17619 // | |
| 17620 // The digits of the integral part have been generated: | |
| 17621 // | |
| 17622 // M+ = d[k-1]...d[1]d[0] + p2 * 2^e | |
| 17623 // = buffer + p2 * 2^e | |
| 17624 // | |
| 17625 // Now generate the digits of the fractional part p2 * 2^e. | |
| 17626 // | |
| 17627 // Note: | |
| 17628 // No decimal point is generated: the exponent is adjusted instead. | |
| 17629 // | |
| 17630 // p2 actually represents the fraction | |
| 17631 // | |
| 17632 // p2 * 2^e | |
| 17633 // = p2 / 2^-e | |
| 17634 // = d[-1] / 10^1 + d[-2] / 10^2 + ... | |
| 17635 // | |
| 17636 // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...) | |
| 17637 // | |
| 17638 // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m | |
| 17639 // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...) | |
| 17640 // | |
| 17641 // using | |
| 17642 // | |
| 17643 // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e) | |
| 17644 // = ( d) * 2^-e + ( r) | |
| 17645 // | |
| 17646 // or | |
| 17647 // 10^m * p2 * 2^e = d + r * 2^e | |
| 17648 // | |
| 17649 // i.e. | |
| 17650 // | |
| 17651 // M+ = buffer + p2 * 2^e | |
| 17652 // = buffer + 10^-m * (d + r * 2^e) | |
| 17653 // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e | |
| 17654 // | |
| 17655 // and stop as soon as 10^-m * r * 2^e <= delta * 2^e | |
| 17656 | |
| 17657 JSON_ASSERT(p2 > delta); | |
| 17658 | |
| 17659 int m = 0; | |
| 17660 for (;;) | |
| 17661 { | |
| 17662 // Invariant: | |
| 17663 // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e | |
| 17664 // = buffer * 10^-m + 10^-m * (p2 ) * 2^e | |
| 17665 // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e | |
| 17666 // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e | |
| 17667 // | |
| 17668 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10); | |
| 17669 p2 *= 10; | |
| 17670 const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e | |
| 17671 const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e | |
| 17672 // | |
| 17673 // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e | |
| 17674 // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e)) | |
| 17675 // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e | |
| 17676 // | |
| 17677 JSON_ASSERT(d <= 9); | |
| 17678 buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d | |
| 17679 // | |
| 17680 // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e | |
| 17681 // | |
| 17682 p2 = r; | |
| 17683 m++; | |
| 17684 // | |
| 17685 // M+ = buffer * 10^-m + 10^-m * p2 * 2^e | |
| 17686 // Invariant restored. | |
| 17687 | |
| 17688 // Check if enough digits have been generated. | |
| 17689 // | |
| 17690 // 10^-m * p2 * 2^e <= delta * 2^e | |
| 17691 // p2 * 2^e <= 10^m * delta * 2^e | |
| 17692 // p2 <= 10^m * delta | |
| 17693 delta *= 10; | |
| 17694 dist *= 10; | |
| 17695 if (p2 <= delta) | |
| 17696 { | |
| 17697 break; | |
| 17698 } | |
| 17699 } | |
| 17700 | |
| 17701 // V = buffer * 10^-m, with M- <= V <= M+. | |
| 17702 | |
| 17703 decimal_exponent -= m; | |
| 17704 | |
| 17705 // 1 ulp in the decimal representation is now 10^-m. | |
| 17706 // Since delta and dist are now scaled by 10^m, we need to do the | |
| 17707 // same with ulp in order to keep the units in sync. | |
| 17708 // | |
| 17709 // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e | |
| 17710 // | |
| 17711 const std::uint64_t ten_m = one.f; | |
| 17712 grisu2_round(buffer, length, dist, delta, p2, ten_m); | |
| 17713 | |
| 17714 // By construction this algorithm generates the shortest possible decimal | |
| 17715 // number (Loitsch, Theorem 6.2) which rounds back to w. | |
| 17716 // For an input number of precision p, at least | |
| 17717 // | |
| 17718 // N = 1 + ceil(p * log_10(2)) | |
| 17719 // | |
| 17720 // decimal digits are sufficient to identify all binary floating-point | |
| 17721 // numbers (Matula, "In-and-Out conversions"). | |
| 17722 // This implies that the algorithm does not produce more than N decimal | |
| 17723 // digits. | |
| 17724 // | |
| 17725 // N = 17 for p = 53 (IEEE double precision) | |
| 17726 // N = 9 for p = 24 (IEEE single precision) | |
| 17727 } | |
| 17728 | |
| 17729 /*! | |
| 17730 v = buf * 10^decimal_exponent | |
| 17731 len is the length of the buffer (number of decimal digits) | |
| 17732 The buffer must be large enough, i.e. >= max_digits10. | |
| 17733 */ | |
| 17734 JSON_HEDLEY_NON_NULL(1) | |
| 17735 inline void grisu2(char* buf, int& len, int& decimal_exponent, | |
| 17736 diyfp m_minus, diyfp v, diyfp m_plus) | |
| 17737 { | |
| 17738 JSON_ASSERT(m_plus.e == m_minus.e); | |
| 17739 JSON_ASSERT(m_plus.e == v.e); | |
| 17740 | |
| 17741 // --------(-----------------------+-----------------------)-------- (A) | |
| 17742 // m- v m+ | |
| 17743 // | |
| 17744 // --------------------(-----------+-----------------------)-------- (B) | |
| 17745 // m- v m+ | |
| 17746 // | |
| 17747 // First scale v (and m- and m+) such that the exponent is in the range | |
| 17748 // [alpha, gamma]. | |
| 17749 | |
| 17750 const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e); | |
| 17751 | |
| 17752 const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k | |
| 17753 | |
| 17754 // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma] | |
| 17755 const diyfp w = diyfp::mul(v, c_minus_k); | |
| 17756 const diyfp w_minus = diyfp::mul(m_minus, c_minus_k); | |
| 17757 const diyfp w_plus = diyfp::mul(m_plus, c_minus_k); | |
| 17758 | |
| 17759 // ----(---+---)---------------(---+---)---------------(---+---)---- | |
| 17760 // w- w w+ | |
| 17761 // = c*m- = c*v = c*m+ | |
| 17762 // | |
| 17763 // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and | |
| 17764 // w+ are now off by a small amount. | |
| 17765 // In fact: | |
| 17766 // | |
| 17767 // w - v * 10^k < 1 ulp | |
| 17768 // | |
| 17769 // To account for this inaccuracy, add resp. subtract 1 ulp. | |
| 17770 // | |
| 17771 // --------+---[---------------(---+---)---------------]---+-------- | |
| 17772 // w- M- w M+ w+ | |
| 17773 // | |
| 17774 // Now any number in [M-, M+] (bounds included) will round to w when input, | |
| 17775 // regardless of how the input rounding algorithm breaks ties. | |
| 17776 // | |
| 17777 // And digit_gen generates the shortest possible such number in [M-, M+]. | |
| 17778 // Note that this does not mean that Grisu2 always generates the shortest | |
| 17779 // possible number in the interval (m-, m+). | |
| 17780 const diyfp M_minus(w_minus.f + 1, w_minus.e); | |
| 17781 const diyfp M_plus (w_plus.f - 1, w_plus.e ); | |
| 17782 | |
| 17783 decimal_exponent = -cached.k; // = -(-k) = k | |
| 17784 | |
| 17785 grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus); | |
| 17786 } | |
| 17787 | |
| 17788 /*! | |
| 17789 v = buf * 10^decimal_exponent | |
| 17790 len is the length of the buffer (number of decimal digits) | |
| 17791 The buffer must be large enough, i.e. >= max_digits10. | |
| 17792 */ | |
| 17793 template<typename FloatType> | |
| 17794 JSON_HEDLEY_NON_NULL(1) | |
| 17795 void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value) | |
| 17796 { | |
| 17797 static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3, | |
| 17798 "internal error: not enough precision"); | |
| 17799 | |
| 17800 JSON_ASSERT(std::isfinite(value)); | |
| 17801 JSON_ASSERT(value > 0); | |
| 17802 | |
| 17803 // If the neighbors (and boundaries) of 'value' are always computed for double-precision | |
| 17804 // numbers, all float's can be recovered using strtod (and strtof). However, the resulting | |
| 17805 // decimal representations are not exactly "short". | |
| 17806 // | |
| 17807 // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars) | |
| 17808 // says "value is converted to a string as if by std::sprintf in the default ("C") locale" | |
| 17809 // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars' | |
| 17810 // does. | |
| 17811 // On the other hand, the documentation for 'std::to_chars' requires that "parsing the | |
| 17812 // representation using the corresponding std::from_chars function recovers value exactly". That | |
| 17813 // indicates that single precision floating-point numbers should be recovered using | |
| 17814 // 'std::strtof'. | |
| 17815 // | |
| 17816 // NB: If the neighbors are computed for single-precision numbers, there is a single float | |
| 17817 // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision | |
| 17818 // value is off by 1 ulp. | |
| 17819 #if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if) | |
| 17820 const boundaries w = compute_boundaries(static_cast<double>(value)); | |
| 17821 #else | |
| 17822 const boundaries w = compute_boundaries(value); | |
| 17823 #endif | |
| 17824 | |
| 17825 grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus); | |
| 17826 } | |
| 17827 | |
| 17828 /*! | |
| 17829 @brief appends a decimal representation of e to buf | |
| 17830 @return a pointer to the element following the exponent. | |
| 17831 @pre -1000 < e < 1000 | |
| 17832 */ | |
| 17833 JSON_HEDLEY_NON_NULL(1) | |
| 17834 JSON_HEDLEY_RETURNS_NON_NULL | |
| 17835 inline char* append_exponent(char* buf, int e) | |
| 17836 { | |
| 17837 JSON_ASSERT(e > -1000); | |
| 17838 JSON_ASSERT(e < 1000); | |
| 17839 | |
| 17840 if (e < 0) | |
| 17841 { | |
| 17842 e = -e; | |
| 17843 *buf++ = '-'; | |
| 17844 } | |
| 17845 else | |
| 17846 { | |
| 17847 *buf++ = '+'; | |
| 17848 } | |
| 17849 | |
| 17850 auto k = static_cast<std::uint32_t>(e); | |
| 17851 if (k < 10) | |
| 17852 { | |
| 17853 // Always print at least two digits in the exponent. | |
| 17854 // This is for compatibility with printf("%g"). | |
| 17855 *buf++ = '0'; | |
| 17856 *buf++ = static_cast<char>('0' + k); | |
| 17857 } | |
| 17858 else if (k < 100) | |
| 17859 { | |
| 17860 *buf++ = static_cast<char>('0' + k / 10); | |
| 17861 k %= 10; | |
| 17862 *buf++ = static_cast<char>('0' + k); | |
| 17863 } | |
| 17864 else | |
| 17865 { | |
| 17866 *buf++ = static_cast<char>('0' + k / 100); | |
| 17867 k %= 100; | |
| 17868 *buf++ = static_cast<char>('0' + k / 10); | |
| 17869 k %= 10; | |
| 17870 *buf++ = static_cast<char>('0' + k); | |
| 17871 } | |
| 17872 | |
| 17873 return buf; | |
| 17874 } | |
| 17875 | |
| 17876 /*! | |
| 17877 @brief prettify v = buf * 10^decimal_exponent | |
| 17878 | |
| 17879 If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point | |
| 17880 notation. Otherwise it will be printed in exponential notation. | |
| 17881 | |
| 17882 @pre min_exp < 0 | |
| 17883 @pre max_exp > 0 | |
| 17884 */ | |
| 17885 JSON_HEDLEY_NON_NULL(1) | |
| 17886 JSON_HEDLEY_RETURNS_NON_NULL | |
| 17887 inline char* format_buffer(char* buf, int len, int decimal_exponent, | |
| 17888 int min_exp, int max_exp) | |
| 17889 { | |
| 17890 JSON_ASSERT(min_exp < 0); | |
| 17891 JSON_ASSERT(max_exp > 0); | |
| 17892 | |
| 17893 const int k = len; | |
| 17894 const int n = len + decimal_exponent; | |
| 17895 | |
| 17896 // v = buf * 10^(n-k) | |
| 17897 // k is the length of the buffer (number of decimal digits) | |
| 17898 // n is the position of the decimal point relative to the start of the buffer. | |
| 17899 | |
| 17900 if (k <= n && n <= max_exp) | |
| 17901 { | |
| 17902 // digits[000] | |
| 17903 // len <= max_exp + 2 | |
| 17904 | |
| 17905 std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k)); | |
| 17906 // Make it look like a floating-point number (#362, #378) | |
| 17907 buf[n + 0] = '.'; | |
| 17908 buf[n + 1] = '0'; | |
| 17909 return buf + (static_cast<size_t>(n) + 2); | |
| 17910 } | |
| 17911 | |
| 17912 if (0 < n && n <= max_exp) | |
| 17913 { | |
| 17914 // dig.its | |
| 17915 // len <= max_digits10 + 1 | |
| 17916 | |
| 17917 JSON_ASSERT(k > n); | |
| 17918 | |
| 17919 std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n)); | |
| 17920 buf[n] = '.'; | |
| 17921 return buf + (static_cast<size_t>(k) + 1U); | |
| 17922 } | |
| 17923 | |
| 17924 if (min_exp < n && n <= 0) | |
| 17925 { | |
| 17926 // 0.[000]digits | |
| 17927 // len <= 2 + (-min_exp - 1) + max_digits10 | |
| 17928 | |
| 17929 std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k)); | |
| 17930 buf[0] = '0'; | |
| 17931 buf[1] = '.'; | |
| 17932 std::memset(buf + 2, '0', static_cast<size_t>(-n)); | |
| 17933 return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k)); | |
| 17934 } | |
| 17935 | |
| 17936 if (k == 1) | |
| 17937 { | |
| 17938 // dE+123 | |
| 17939 // len <= 1 + 5 | |
| 17940 | |
| 17941 buf += 1; | |
| 17942 } | |
| 17943 else | |
| 17944 { | |
| 17945 // d.igitsE+123 | |
| 17946 // len <= max_digits10 + 1 + 5 | |
| 17947 | |
| 17948 std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1); | |
| 17949 buf[1] = '.'; | |
| 17950 buf += 1 + static_cast<size_t>(k); | |
| 17951 } | |
| 17952 | |
| 17953 *buf++ = 'e'; | |
| 17954 return append_exponent(buf, n - 1); | |
| 17955 } | |
| 17956 | |
| 17957 } // namespace dtoa_impl | |
| 17958 | |
| 17959 /*! | |
| 17960 @brief generates a decimal representation of the floating-point number value in [first, last). | |
| 17961 | |
| 17962 The format of the resulting decimal representation is similar to printf's %g | |
| 17963 format. Returns an iterator pointing past-the-end of the decimal representation. | |
| 17964 | |
| 17965 @note The input number must be finite, i.e. NaN's and Inf's are not supported. | |
| 17966 @note The buffer must be large enough. | |
| 17967 @note The result is NOT null-terminated. | |
| 17968 */ | |
| 17969 template<typename FloatType> | |
| 17970 JSON_HEDLEY_NON_NULL(1, 2) | |
| 17971 JSON_HEDLEY_RETURNS_NON_NULL | |
| 17972 char* to_chars(char* first, const char* last, FloatType value) | |
| 17973 { | |
| 17974 static_cast<void>(last); // maybe unused - fix warning | |
| 17975 JSON_ASSERT(std::isfinite(value)); | |
| 17976 | |
| 17977 // Use signbit(value) instead of (value < 0) since signbit works for -0. | |
| 17978 if (std::signbit(value)) | |
| 17979 { | |
| 17980 value = -value; | |
| 17981 *first++ = '-'; | |
| 17982 } | |
| 17983 | |
| 17984 #ifdef __GNUC__ | |
| 17985 #pragma GCC diagnostic push | |
| 17986 #pragma GCC diagnostic ignored "-Wfloat-equal" | |
| 17987 #endif | |
| 17988 if (value == 0) // +-0 | |
| 17989 { | |
| 17990 *first++ = '0'; | |
| 17991 // Make it look like a floating-point number (#362, #378) | |
| 17992 *first++ = '.'; | |
| 17993 *first++ = '0'; | |
| 17994 return first; | |
| 17995 } | |
| 17996 #ifdef __GNUC__ | |
| 17997 #pragma GCC diagnostic pop | |
| 17998 #endif | |
| 17999 | |
| 18000 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10); | |
| 18001 | |
| 18002 // Compute v = buffer * 10^decimal_exponent. | |
| 18003 // The decimal digits are stored in the buffer, which needs to be interpreted | |
| 18004 // as an unsigned decimal integer. | |
| 18005 // len is the length of the buffer, i.e. the number of decimal digits. | |
| 18006 int len = 0; | |
| 18007 int decimal_exponent = 0; | |
| 18008 dtoa_impl::grisu2(first, len, decimal_exponent, value); | |
| 18009 | |
| 18010 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10); | |
| 18011 | |
| 18012 // Format the buffer like printf("%.*g", prec, value) | |
| 18013 constexpr int kMinExp = -4; | |
| 18014 // Use digits10 here to increase compatibility with version 2. | |
| 18015 constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10; | |
| 18016 | |
| 18017 JSON_ASSERT(last - first >= kMaxExp + 2); | |
| 18018 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10); | |
| 18019 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6); | |
| 18020 | |
| 18021 return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp); | |
| 18022 } | |
| 18023 | |
| 18024 } // namespace detail | |
| 18025 NLOHMANN_JSON_NAMESPACE_END | |
| 18026 | |
| 18027 // #include <nlohmann/detail/exceptions.hpp> | |
| 18028 | |
| 18029 // #include <nlohmann/detail/macro_scope.hpp> | |
| 18030 | |
| 18031 // #include <nlohmann/detail/meta/cpp_future.hpp> | |
| 18032 | |
| 18033 // #include <nlohmann/detail/output/binary_writer.hpp> | |
| 18034 | |
| 18035 // #include <nlohmann/detail/output/output_adapters.hpp> | |
| 18036 | |
| 18037 // #include <nlohmann/detail/string_concat.hpp> | |
| 18038 | |
| 18039 // #include <nlohmann/detail/value_t.hpp> | |
| 18040 | |
| 18041 | |
| 18042 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 18043 namespace detail | |
| 18044 { | |
| 18045 | |
| 18046 /////////////////// | |
| 18047 // serialization // | |
| 18048 /////////////////// | |
| 18049 | |
| 18050 /// how to treat decoding errors | |
| 18051 enum class error_handler_t | |
| 18052 { | |
| 18053 strict, ///< throw a type_error exception in case of invalid UTF-8 | |
| 18054 replace, ///< replace invalid UTF-8 sequences with U+FFFD | |
| 18055 ignore ///< ignore invalid UTF-8 sequences | |
| 18056 }; | |
| 18057 | |
| 18058 template<typename BasicJsonType> | |
| 18059 class serializer | |
| 18060 { | |
| 18061 using string_t = typename BasicJsonType::string_t; | |
| 18062 using number_float_t = typename BasicJsonType::number_float_t; | |
| 18063 using number_integer_t = typename BasicJsonType::number_integer_t; | |
| 18064 using number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 18065 using binary_char_t = typename BasicJsonType::binary_t::value_type; | |
| 18066 static constexpr std::uint8_t UTF8_ACCEPT = 0; | |
| 18067 static constexpr std::uint8_t UTF8_REJECT = 1; | |
| 18068 | |
| 18069 public: | |
| 18070 /*! | |
| 18071 @param[in] s output stream to serialize to | |
| 18072 @param[in] ichar indentation character to use | |
| 18073 @param[in] error_handler_ how to react on decoding errors | |
| 18074 */ | |
| 18075 serializer(output_adapter_t<char> s, const char ichar, | |
| 18076 error_handler_t error_handler_ = error_handler_t::strict) | |
| 18077 : o(std::move(s)) | |
| 18078 , loc(std::localeconv()) | |
| 18079 , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep))) | |
| 18080 , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point))) | |
| 18081 , indent_char(ichar) | |
| 18082 , indent_string(512, indent_char) | |
| 18083 , error_handler(error_handler_) | |
| 18084 {} | |
| 18085 | |
| 18086 // delete because of pointer members | |
| 18087 serializer(const serializer&) = delete; | |
| 18088 serializer& operator=(const serializer&) = delete; | |
| 18089 serializer(serializer&&) = delete; | |
| 18090 serializer& operator=(serializer&&) = delete; | |
| 18091 ~serializer() = default; | |
| 18092 | |
| 18093 /*! | |
| 18094 @brief internal implementation of the serialization function | |
| 18095 | |
| 18096 This function is called by the public member function dump and organizes | |
| 18097 the serialization internally. The indentation level is propagated as | |
| 18098 additional parameter. In case of arrays and objects, the function is | |
| 18099 called recursively. | |
| 18100 | |
| 18101 - strings and object keys are escaped using `escape_string()` | |
| 18102 - integer numbers are converted implicitly via `operator<<` | |
| 18103 - floating-point numbers are converted to a string using `"%g"` format | |
| 18104 - binary values are serialized as objects containing the subtype and the | |
| 18105 byte array | |
| 18106 | |
| 18107 @param[in] val value to serialize | |
| 18108 @param[in] pretty_print whether the output shall be pretty-printed | |
| 18109 @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters | |
| 18110 in the output are escaped with `\uXXXX` sequences, and the result consists | |
| 18111 of ASCII characters only. | |
| 18112 @param[in] indent_step the indent level | |
| 18113 @param[in] current_indent the current indent level (only used internally) | |
| 18114 */ | |
| 18115 void dump(const BasicJsonType& val, | |
| 18116 const bool pretty_print, | |
| 18117 const bool ensure_ascii, | |
| 18118 const unsigned int indent_step, | |
| 18119 const unsigned int current_indent = 0) | |
| 18120 { | |
| 18121 switch (val.m_data.m_type) | |
| 18122 { | |
| 18123 case value_t::object: | |
| 18124 { | |
| 18125 if (val.m_data.m_value.object->empty()) | |
| 18126 { | |
| 18127 o->write_characters("{}", 2); | |
| 18128 return; | |
| 18129 } | |
| 18130 | |
| 18131 if (pretty_print) | |
| 18132 { | |
| 18133 o->write_characters("{\n", 2); | |
| 18134 | |
| 18135 // variable to hold indentation for recursive calls | |
| 18136 const auto new_indent = current_indent + indent_step; | |
| 18137 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) | |
| 18138 { | |
| 18139 indent_string.resize(indent_string.size() * 2, ' '); | |
| 18140 } | |
| 18141 | |
| 18142 // first n-1 elements | |
| 18143 auto i = val.m_data.m_value.object->cbegin(); | |
| 18144 for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i) | |
| 18145 { | |
| 18146 o->write_characters(indent_string.c_str(), new_indent); | |
| 18147 o->write_character('\"'); | |
| 18148 dump_escaped(i->first, ensure_ascii); | |
| 18149 o->write_characters("\": ", 3); | |
| 18150 dump(i->second, true, ensure_ascii, indent_step, new_indent); | |
| 18151 o->write_characters(",\n", 2); | |
| 18152 } | |
| 18153 | |
| 18154 // last element | |
| 18155 JSON_ASSERT(i != val.m_data.m_value.object->cend()); | |
| 18156 JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend()); | |
| 18157 o->write_characters(indent_string.c_str(), new_indent); | |
| 18158 o->write_character('\"'); | |
| 18159 dump_escaped(i->first, ensure_ascii); | |
| 18160 o->write_characters("\": ", 3); | |
| 18161 dump(i->second, true, ensure_ascii, indent_step, new_indent); | |
| 18162 | |
| 18163 o->write_character('\n'); | |
| 18164 o->write_characters(indent_string.c_str(), current_indent); | |
| 18165 o->write_character('}'); | |
| 18166 } | |
| 18167 else | |
| 18168 { | |
| 18169 o->write_character('{'); | |
| 18170 | |
| 18171 // first n-1 elements | |
| 18172 auto i = val.m_data.m_value.object->cbegin(); | |
| 18173 for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i) | |
| 18174 { | |
| 18175 o->write_character('\"'); | |
| 18176 dump_escaped(i->first, ensure_ascii); | |
| 18177 o->write_characters("\":", 2); | |
| 18178 dump(i->second, false, ensure_ascii, indent_step, current_indent); | |
| 18179 o->write_character(','); | |
| 18180 } | |
| 18181 | |
| 18182 // last element | |
| 18183 JSON_ASSERT(i != val.m_data.m_value.object->cend()); | |
| 18184 JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend()); | |
| 18185 o->write_character('\"'); | |
| 18186 dump_escaped(i->first, ensure_ascii); | |
| 18187 o->write_characters("\":", 2); | |
| 18188 dump(i->second, false, ensure_ascii, indent_step, current_indent); | |
| 18189 | |
| 18190 o->write_character('}'); | |
| 18191 } | |
| 18192 | |
| 18193 return; | |
| 18194 } | |
| 18195 | |
| 18196 case value_t::array: | |
| 18197 { | |
| 18198 if (val.m_data.m_value.array->empty()) | |
| 18199 { | |
| 18200 o->write_characters("[]", 2); | |
| 18201 return; | |
| 18202 } | |
| 18203 | |
| 18204 if (pretty_print) | |
| 18205 { | |
| 18206 o->write_characters("[\n", 2); | |
| 18207 | |
| 18208 // variable to hold indentation for recursive calls | |
| 18209 const auto new_indent = current_indent + indent_step; | |
| 18210 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) | |
| 18211 { | |
| 18212 indent_string.resize(indent_string.size() * 2, ' '); | |
| 18213 } | |
| 18214 | |
| 18215 // first n-1 elements | |
| 18216 for (auto i = val.m_data.m_value.array->cbegin(); | |
| 18217 i != val.m_data.m_value.array->cend() - 1; ++i) | |
| 18218 { | |
| 18219 o->write_characters(indent_string.c_str(), new_indent); | |
| 18220 dump(*i, true, ensure_ascii, indent_step, new_indent); | |
| 18221 o->write_characters(",\n", 2); | |
| 18222 } | |
| 18223 | |
| 18224 // last element | |
| 18225 JSON_ASSERT(!val.m_data.m_value.array->empty()); | |
| 18226 o->write_characters(indent_string.c_str(), new_indent); | |
| 18227 dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent); | |
| 18228 | |
| 18229 o->write_character('\n'); | |
| 18230 o->write_characters(indent_string.c_str(), current_indent); | |
| 18231 o->write_character(']'); | |
| 18232 } | |
| 18233 else | |
| 18234 { | |
| 18235 o->write_character('['); | |
| 18236 | |
| 18237 // first n-1 elements | |
| 18238 for (auto i = val.m_data.m_value.array->cbegin(); | |
| 18239 i != val.m_data.m_value.array->cend() - 1; ++i) | |
| 18240 { | |
| 18241 dump(*i, false, ensure_ascii, indent_step, current_indent); | |
| 18242 o->write_character(','); | |
| 18243 } | |
| 18244 | |
| 18245 // last element | |
| 18246 JSON_ASSERT(!val.m_data.m_value.array->empty()); | |
| 18247 dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent); | |
| 18248 | |
| 18249 o->write_character(']'); | |
| 18250 } | |
| 18251 | |
| 18252 return; | |
| 18253 } | |
| 18254 | |
| 18255 case value_t::string: | |
| 18256 { | |
| 18257 o->write_character('\"'); | |
| 18258 dump_escaped(*val.m_data.m_value.string, ensure_ascii); | |
| 18259 o->write_character('\"'); | |
| 18260 return; | |
| 18261 } | |
| 18262 | |
| 18263 case value_t::binary: | |
| 18264 { | |
| 18265 if (pretty_print) | |
| 18266 { | |
| 18267 o->write_characters("{\n", 2); | |
| 18268 | |
| 18269 // variable to hold indentation for recursive calls | |
| 18270 const auto new_indent = current_indent + indent_step; | |
| 18271 if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) | |
| 18272 { | |
| 18273 indent_string.resize(indent_string.size() * 2, ' '); | |
| 18274 } | |
| 18275 | |
| 18276 o->write_characters(indent_string.c_str(), new_indent); | |
| 18277 | |
| 18278 o->write_characters("\"bytes\": [", 10); | |
| 18279 | |
| 18280 if (!val.m_data.m_value.binary->empty()) | |
| 18281 { | |
| 18282 for (auto i = val.m_data.m_value.binary->cbegin(); | |
| 18283 i != val.m_data.m_value.binary->cend() - 1; ++i) | |
| 18284 { | |
| 18285 dump_integer(*i); | |
| 18286 o->write_characters(", ", 2); | |
| 18287 } | |
| 18288 dump_integer(val.m_data.m_value.binary->back()); | |
| 18289 } | |
| 18290 | |
| 18291 o->write_characters("],\n", 3); | |
| 18292 o->write_characters(indent_string.c_str(), new_indent); | |
| 18293 | |
| 18294 o->write_characters("\"subtype\": ", 11); | |
| 18295 if (val.m_data.m_value.binary->has_subtype()) | |
| 18296 { | |
| 18297 dump_integer(val.m_data.m_value.binary->subtype()); | |
| 18298 } | |
| 18299 else | |
| 18300 { | |
| 18301 o->write_characters("null", 4); | |
| 18302 } | |
| 18303 o->write_character('\n'); | |
| 18304 o->write_characters(indent_string.c_str(), current_indent); | |
| 18305 o->write_character('}'); | |
| 18306 } | |
| 18307 else | |
| 18308 { | |
| 18309 o->write_characters("{\"bytes\":[", 10); | |
| 18310 | |
| 18311 if (!val.m_data.m_value.binary->empty()) | |
| 18312 { | |
| 18313 for (auto i = val.m_data.m_value.binary->cbegin(); | |
| 18314 i != val.m_data.m_value.binary->cend() - 1; ++i) | |
| 18315 { | |
| 18316 dump_integer(*i); | |
| 18317 o->write_character(','); | |
| 18318 } | |
| 18319 dump_integer(val.m_data.m_value.binary->back()); | |
| 18320 } | |
| 18321 | |
| 18322 o->write_characters("],\"subtype\":", 12); | |
| 18323 if (val.m_data.m_value.binary->has_subtype()) | |
| 18324 { | |
| 18325 dump_integer(val.m_data.m_value.binary->subtype()); | |
| 18326 o->write_character('}'); | |
| 18327 } | |
| 18328 else | |
| 18329 { | |
| 18330 o->write_characters("null}", 5); | |
| 18331 } | |
| 18332 } | |
| 18333 return; | |
| 18334 } | |
| 18335 | |
| 18336 case value_t::boolean: | |
| 18337 { | |
| 18338 if (val.m_data.m_value.boolean) | |
| 18339 { | |
| 18340 o->write_characters("true", 4); | |
| 18341 } | |
| 18342 else | |
| 18343 { | |
| 18344 o->write_characters("false", 5); | |
| 18345 } | |
| 18346 return; | |
| 18347 } | |
| 18348 | |
| 18349 case value_t::number_integer: | |
| 18350 { | |
| 18351 dump_integer(val.m_data.m_value.number_integer); | |
| 18352 return; | |
| 18353 } | |
| 18354 | |
| 18355 case value_t::number_unsigned: | |
| 18356 { | |
| 18357 dump_integer(val.m_data.m_value.number_unsigned); | |
| 18358 return; | |
| 18359 } | |
| 18360 | |
| 18361 case value_t::number_float: | |
| 18362 { | |
| 18363 dump_float(val.m_data.m_value.number_float); | |
| 18364 return; | |
| 18365 } | |
| 18366 | |
| 18367 case value_t::discarded: | |
| 18368 { | |
| 18369 o->write_characters("<discarded>", 11); | |
| 18370 return; | |
| 18371 } | |
| 18372 | |
| 18373 case value_t::null: | |
| 18374 { | |
| 18375 o->write_characters("null", 4); | |
| 18376 return; | |
| 18377 } | |
| 18378 | |
| 18379 default: // LCOV_EXCL_LINE | |
| 18380 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 18381 } | |
| 18382 } | |
| 18383 | |
| 18384 JSON_PRIVATE_UNLESS_TESTED: | |
| 18385 /*! | |
| 18386 @brief dump escaped string | |
| 18387 | |
| 18388 Escape a string by replacing certain special characters by a sequence of an | |
| 18389 escape character (backslash) and another character and other control | |
| 18390 characters by a sequence of "\u" followed by a four-digit hex | |
| 18391 representation. The escaped string is written to output stream @a o. | |
| 18392 | |
| 18393 @param[in] s the string to escape | |
| 18394 @param[in] ensure_ascii whether to escape non-ASCII characters with | |
| 18395 \uXXXX sequences | |
| 18396 | |
| 18397 @complexity Linear in the length of string @a s. | |
| 18398 */ | |
| 18399 void dump_escaped(const string_t& s, const bool ensure_ascii) | |
| 18400 { | |
| 18401 std::uint32_t codepoint{}; | |
| 18402 std::uint8_t state = UTF8_ACCEPT; | |
| 18403 std::size_t bytes = 0; // number of bytes written to string_buffer | |
| 18404 | |
| 18405 // number of bytes written at the point of the last valid byte | |
| 18406 std::size_t bytes_after_last_accept = 0; | |
| 18407 std::size_t undumped_chars = 0; | |
| 18408 | |
| 18409 for (std::size_t i = 0; i < s.size(); ++i) | |
| 18410 { | |
| 18411 const auto byte = static_cast<std::uint8_t>(s[i]); | |
| 18412 | |
| 18413 switch (decode(state, codepoint, byte)) | |
| 18414 { | |
| 18415 case UTF8_ACCEPT: // decode found a new code point | |
| 18416 { | |
| 18417 switch (codepoint) | |
| 18418 { | |
| 18419 case 0x08: // backspace | |
| 18420 { | |
| 18421 string_buffer[bytes++] = '\\'; | |
| 18422 string_buffer[bytes++] = 'b'; | |
| 18423 break; | |
| 18424 } | |
| 18425 | |
| 18426 case 0x09: // horizontal tab | |
| 18427 { | |
| 18428 string_buffer[bytes++] = '\\'; | |
| 18429 string_buffer[bytes++] = 't'; | |
| 18430 break; | |
| 18431 } | |
| 18432 | |
| 18433 case 0x0A: // newline | |
| 18434 { | |
| 18435 string_buffer[bytes++] = '\\'; | |
| 18436 string_buffer[bytes++] = 'n'; | |
| 18437 break; | |
| 18438 } | |
| 18439 | |
| 18440 case 0x0C: // formfeed | |
| 18441 { | |
| 18442 string_buffer[bytes++] = '\\'; | |
| 18443 string_buffer[bytes++] = 'f'; | |
| 18444 break; | |
| 18445 } | |
| 18446 | |
| 18447 case 0x0D: // carriage return | |
| 18448 { | |
| 18449 string_buffer[bytes++] = '\\'; | |
| 18450 string_buffer[bytes++] = 'r'; | |
| 18451 break; | |
| 18452 } | |
| 18453 | |
| 18454 case 0x22: // quotation mark | |
| 18455 { | |
| 18456 string_buffer[bytes++] = '\\'; | |
| 18457 string_buffer[bytes++] = '\"'; | |
| 18458 break; | |
| 18459 } | |
| 18460 | |
| 18461 case 0x5C: // reverse solidus | |
| 18462 { | |
| 18463 string_buffer[bytes++] = '\\'; | |
| 18464 string_buffer[bytes++] = '\\'; | |
| 18465 break; | |
| 18466 } | |
| 18467 | |
| 18468 default: | |
| 18469 { | |
| 18470 // escape control characters (0x00..0x1F) or, if | |
| 18471 // ensure_ascii parameter is used, non-ASCII characters | |
| 18472 if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F))) | |
| 18473 { | |
| 18474 if (codepoint <= 0xFFFF) | |
| 18475 { | |
| 18476 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 18477 static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x", | |
| 18478 static_cast<std::uint16_t>(codepoint))); | |
| 18479 bytes += 6; | |
| 18480 } | |
| 18481 else | |
| 18482 { | |
| 18483 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 18484 static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x", | |
| 18485 static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)), | |
| 18486 static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)))); | |
| 18487 bytes += 12; | |
| 18488 } | |
| 18489 } | |
| 18490 else | |
| 18491 { | |
| 18492 // copy byte to buffer (all previous bytes | |
| 18493 // been copied have in default case above) | |
| 18494 string_buffer[bytes++] = s[i]; | |
| 18495 } | |
| 18496 break; | |
| 18497 } | |
| 18498 } | |
| 18499 | |
| 18500 // write buffer and reset index; there must be 13 bytes | |
| 18501 // left, as this is the maximal number of bytes to be | |
| 18502 // written ("\uxxxx\uxxxx\0") for one code point | |
| 18503 if (string_buffer.size() - bytes < 13) | |
| 18504 { | |
| 18505 o->write_characters(string_buffer.data(), bytes); | |
| 18506 bytes = 0; | |
| 18507 } | |
| 18508 | |
| 18509 // remember the byte position of this accept | |
| 18510 bytes_after_last_accept = bytes; | |
| 18511 undumped_chars = 0; | |
| 18512 break; | |
| 18513 } | |
| 18514 | |
| 18515 case UTF8_REJECT: // decode found invalid UTF-8 byte | |
| 18516 { | |
| 18517 switch (error_handler) | |
| 18518 { | |
| 18519 case error_handler_t::strict: | |
| 18520 { | |
| 18521 JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr)); | |
| 18522 } | |
| 18523 | |
| 18524 case error_handler_t::ignore: | |
| 18525 case error_handler_t::replace: | |
| 18526 { | |
| 18527 // in case we saw this character the first time, we | |
| 18528 // would like to read it again, because the byte | |
| 18529 // may be OK for itself, but just not OK for the | |
| 18530 // previous sequence | |
| 18531 if (undumped_chars > 0) | |
| 18532 { | |
| 18533 --i; | |
| 18534 } | |
| 18535 | |
| 18536 // reset length buffer to the last accepted index; | |
| 18537 // thus removing/ignoring the invalid characters | |
| 18538 bytes = bytes_after_last_accept; | |
| 18539 | |
| 18540 if (error_handler == error_handler_t::replace) | |
| 18541 { | |
| 18542 // add a replacement character | |
| 18543 if (ensure_ascii) | |
| 18544 { | |
| 18545 string_buffer[bytes++] = '\\'; | |
| 18546 string_buffer[bytes++] = 'u'; | |
| 18547 string_buffer[bytes++] = 'f'; | |
| 18548 string_buffer[bytes++] = 'f'; | |
| 18549 string_buffer[bytes++] = 'f'; | |
| 18550 string_buffer[bytes++] = 'd'; | |
| 18551 } | |
| 18552 else | |
| 18553 { | |
| 18554 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF'); | |
| 18555 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF'); | |
| 18556 string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD'); | |
| 18557 } | |
| 18558 | |
| 18559 // write buffer and reset index; there must be 13 bytes | |
| 18560 // left, as this is the maximal number of bytes to be | |
| 18561 // written ("\uxxxx\uxxxx\0") for one code point | |
| 18562 if (string_buffer.size() - bytes < 13) | |
| 18563 { | |
| 18564 o->write_characters(string_buffer.data(), bytes); | |
| 18565 bytes = 0; | |
| 18566 } | |
| 18567 | |
| 18568 bytes_after_last_accept = bytes; | |
| 18569 } | |
| 18570 | |
| 18571 undumped_chars = 0; | |
| 18572 | |
| 18573 // continue processing the string | |
| 18574 state = UTF8_ACCEPT; | |
| 18575 break; | |
| 18576 } | |
| 18577 | |
| 18578 default: // LCOV_EXCL_LINE | |
| 18579 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 18580 } | |
| 18581 break; | |
| 18582 } | |
| 18583 | |
| 18584 default: // decode found yet incomplete multi-byte code point | |
| 18585 { | |
| 18586 if (!ensure_ascii) | |
| 18587 { | |
| 18588 // code point will not be escaped - copy byte to buffer | |
| 18589 string_buffer[bytes++] = s[i]; | |
| 18590 } | |
| 18591 ++undumped_chars; | |
| 18592 break; | |
| 18593 } | |
| 18594 } | |
| 18595 } | |
| 18596 | |
| 18597 // we finished processing the string | |
| 18598 if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT)) | |
| 18599 { | |
| 18600 // write buffer | |
| 18601 if (bytes > 0) | |
| 18602 { | |
| 18603 o->write_characters(string_buffer.data(), bytes); | |
| 18604 } | |
| 18605 } | |
| 18606 else | |
| 18607 { | |
| 18608 // we finish reading, but do not accept: string was incomplete | |
| 18609 switch (error_handler) | |
| 18610 { | |
| 18611 case error_handler_t::strict: | |
| 18612 { | |
| 18613 JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr)); | |
| 18614 } | |
| 18615 | |
| 18616 case error_handler_t::ignore: | |
| 18617 { | |
| 18618 // write all accepted bytes | |
| 18619 o->write_characters(string_buffer.data(), bytes_after_last_accept); | |
| 18620 break; | |
| 18621 } | |
| 18622 | |
| 18623 case error_handler_t::replace: | |
| 18624 { | |
| 18625 // write all accepted bytes | |
| 18626 o->write_characters(string_buffer.data(), bytes_after_last_accept); | |
| 18627 // add a replacement character | |
| 18628 if (ensure_ascii) | |
| 18629 { | |
| 18630 o->write_characters("\\ufffd", 6); | |
| 18631 } | |
| 18632 else | |
| 18633 { | |
| 18634 o->write_characters("\xEF\xBF\xBD", 3); | |
| 18635 } | |
| 18636 break; | |
| 18637 } | |
| 18638 | |
| 18639 default: // LCOV_EXCL_LINE | |
| 18640 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 18641 } | |
| 18642 } | |
| 18643 } | |
| 18644 | |
| 18645 private: | |
| 18646 /*! | |
| 18647 @brief count digits | |
| 18648 | |
| 18649 Count the number of decimal (base 10) digits for an input unsigned integer. | |
| 18650 | |
| 18651 @param[in] x unsigned integer number to count its digits | |
| 18652 @return number of decimal digits | |
| 18653 */ | |
| 18654 inline unsigned int count_digits(number_unsigned_t x) noexcept | |
| 18655 { | |
| 18656 unsigned int n_digits = 1; | |
| 18657 for (;;) | |
| 18658 { | |
| 18659 if (x < 10) | |
| 18660 { | |
| 18661 return n_digits; | |
| 18662 } | |
| 18663 if (x < 100) | |
| 18664 { | |
| 18665 return n_digits + 1; | |
| 18666 } | |
| 18667 if (x < 1000) | |
| 18668 { | |
| 18669 return n_digits + 2; | |
| 18670 } | |
| 18671 if (x < 10000) | |
| 18672 { | |
| 18673 return n_digits + 3; | |
| 18674 } | |
| 18675 x = x / 10000u; | |
| 18676 n_digits += 4; | |
| 18677 } | |
| 18678 } | |
| 18679 | |
| 18680 /*! | |
| 18681 * @brief convert a byte to a uppercase hex representation | |
| 18682 * @param[in] byte byte to represent | |
| 18683 * @return representation ("00".."FF") | |
| 18684 */ | |
| 18685 static std::string hex_bytes(std::uint8_t byte) | |
| 18686 { | |
| 18687 std::string result = "FF"; | |
| 18688 constexpr const char* nibble_to_hex = "0123456789ABCDEF"; | |
| 18689 result[0] = nibble_to_hex[byte / 16]; | |
| 18690 result[1] = nibble_to_hex[byte % 16]; | |
| 18691 return result; | |
| 18692 } | |
| 18693 | |
| 18694 // templates to avoid warnings about useless casts | |
| 18695 template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0> | |
| 18696 bool is_negative_number(NumberType x) | |
| 18697 { | |
| 18698 return x < 0; | |
| 18699 } | |
| 18700 | |
| 18701 template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 > | |
| 18702 bool is_negative_number(NumberType /*unused*/) | |
| 18703 { | |
| 18704 return false; | |
| 18705 } | |
| 18706 | |
| 18707 /*! | |
| 18708 @brief dump an integer | |
| 18709 | |
| 18710 Dump a given integer to output stream @a o. Works internally with | |
| 18711 @a number_buffer. | |
| 18712 | |
| 18713 @param[in] x integer number (signed or unsigned) to dump | |
| 18714 @tparam NumberType either @a number_integer_t or @a number_unsigned_t | |
| 18715 */ | |
| 18716 template < typename NumberType, detail::enable_if_t < | |
| 18717 std::is_integral<NumberType>::value || | |
| 18718 std::is_same<NumberType, number_unsigned_t>::value || | |
| 18719 std::is_same<NumberType, number_integer_t>::value || | |
| 18720 std::is_same<NumberType, binary_char_t>::value, | |
| 18721 int > = 0 > | |
| 18722 void dump_integer(NumberType x) | |
| 18723 { | |
| 18724 static constexpr std::array<std::array<char, 2>, 100> digits_to_99 | |
| 18725 { | |
| 18726 { | |
| 18727 {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}}, | |
| 18728 {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}}, | |
| 18729 {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}}, | |
| 18730 {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}}, | |
| 18731 {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}}, | |
| 18732 {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}}, | |
| 18733 {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}}, | |
| 18734 {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}}, | |
| 18735 {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}}, | |
| 18736 {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}}, | |
| 18737 } | |
| 18738 }; | |
| 18739 | |
| 18740 // special case for "0" | |
| 18741 if (x == 0) | |
| 18742 { | |
| 18743 o->write_character('0'); | |
| 18744 return; | |
| 18745 } | |
| 18746 | |
| 18747 // use a pointer to fill the buffer | |
| 18748 auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 18749 | |
| 18750 number_unsigned_t abs_value; | |
| 18751 | |
| 18752 unsigned int n_chars{}; | |
| 18753 | |
| 18754 if (is_negative_number(x)) | |
| 18755 { | |
| 18756 *buffer_ptr = '-'; | |
| 18757 abs_value = remove_sign(static_cast<number_integer_t>(x)); | |
| 18758 | |
| 18759 // account one more byte for the minus sign | |
| 18760 n_chars = 1 + count_digits(abs_value); | |
| 18761 } | |
| 18762 else | |
| 18763 { | |
| 18764 abs_value = static_cast<number_unsigned_t>(x); | |
| 18765 n_chars = count_digits(abs_value); | |
| 18766 } | |
| 18767 | |
| 18768 // spare 1 byte for '\0' | |
| 18769 JSON_ASSERT(n_chars < number_buffer.size() - 1); | |
| 18770 | |
| 18771 // jump to the end to generate the string from backward, | |
| 18772 // so we later avoid reversing the result | |
| 18773 buffer_ptr += n_chars; | |
| 18774 | |
| 18775 // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu | |
| 18776 // See: https://www.youtube.com/watch?v=o4-CwDo2zpg | |
| 18777 while (abs_value >= 100) | |
| 18778 { | |
| 18779 const auto digits_index = static_cast<unsigned>((abs_value % 100)); | |
| 18780 abs_value /= 100; | |
| 18781 *(--buffer_ptr) = digits_to_99[digits_index][1]; | |
| 18782 *(--buffer_ptr) = digits_to_99[digits_index][0]; | |
| 18783 } | |
| 18784 | |
| 18785 if (abs_value >= 10) | |
| 18786 { | |
| 18787 const auto digits_index = static_cast<unsigned>(abs_value); | |
| 18788 *(--buffer_ptr) = digits_to_99[digits_index][1]; | |
| 18789 *(--buffer_ptr) = digits_to_99[digits_index][0]; | |
| 18790 } | |
| 18791 else | |
| 18792 { | |
| 18793 *(--buffer_ptr) = static_cast<char>('0' + abs_value); | |
| 18794 } | |
| 18795 | |
| 18796 o->write_characters(number_buffer.data(), n_chars); | |
| 18797 } | |
| 18798 | |
| 18799 /*! | |
| 18800 @brief dump a floating-point number | |
| 18801 | |
| 18802 Dump a given floating-point number to output stream @a o. Works internally | |
| 18803 with @a number_buffer. | |
| 18804 | |
| 18805 @param[in] x floating-point number to dump | |
| 18806 */ | |
| 18807 void dump_float(number_float_t x) | |
| 18808 { | |
| 18809 // NaN / inf | |
| 18810 if (!std::isfinite(x)) | |
| 18811 { | |
| 18812 o->write_characters("null", 4); | |
| 18813 return; | |
| 18814 } | |
| 18815 | |
| 18816 // If number_float_t is an IEEE-754 single or double precision number, | |
| 18817 // use the Grisu2 algorithm to produce short numbers which are | |
| 18818 // guaranteed to round-trip, using strtof and strtod, resp. | |
| 18819 // | |
| 18820 // NB: The test below works if <long double> == <double>. | |
| 18821 static constexpr bool is_ieee_single_or_double | |
| 18822 = (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) || | |
| 18823 (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); | |
| 18824 | |
| 18825 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>()); | |
| 18826 } | |
| 18827 | |
| 18828 void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/) | |
| 18829 { | |
| 18830 auto* begin = number_buffer.data(); | |
| 18831 auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x); | |
| 18832 | |
| 18833 o->write_characters(begin, static_cast<size_t>(end - begin)); | |
| 18834 } | |
| 18835 | |
| 18836 void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/) | |
| 18837 { | |
| 18838 // get number of digits for a float -> text -> float round-trip | |
| 18839 static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10; | |
| 18840 | |
| 18841 // the actual conversion | |
| 18842 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg) | |
| 18843 std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x); | |
| 18844 | |
| 18845 // negative value indicates an error | |
| 18846 JSON_ASSERT(len > 0); | |
| 18847 // check if buffer was large enough | |
| 18848 JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size()); | |
| 18849 | |
| 18850 // erase thousands separator | |
| 18851 if (thousands_sep != '\0') | |
| 18852 { | |
| 18853 // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081 | |
| 18854 const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep); | |
| 18855 std::fill(end, number_buffer.end(), '\0'); | |
| 18856 JSON_ASSERT((end - number_buffer.begin()) <= len); | |
| 18857 len = (end - number_buffer.begin()); | |
| 18858 } | |
| 18859 | |
| 18860 // convert decimal point to '.' | |
| 18861 if (decimal_point != '\0' && decimal_point != '.') | |
| 18862 { | |
| 18863 // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081 | |
| 18864 const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point); | |
| 18865 if (dec_pos != number_buffer.end()) | |
| 18866 { | |
| 18867 *dec_pos = '.'; | |
| 18868 } | |
| 18869 } | |
| 18870 | |
| 18871 o->write_characters(number_buffer.data(), static_cast<std::size_t>(len)); | |
| 18872 | |
| 18873 // determine if we need to append ".0" | |
| 18874 const bool value_is_int_like = | |
| 18875 std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1, | |
| 18876 [](char c) | |
| 18877 { | |
| 18878 return c == '.' || c == 'e'; | |
| 18879 }); | |
| 18880 | |
| 18881 if (value_is_int_like) | |
| 18882 { | |
| 18883 o->write_characters(".0", 2); | |
| 18884 } | |
| 18885 } | |
| 18886 | |
| 18887 /*! | |
| 18888 @brief check whether a string is UTF-8 encoded | |
| 18889 | |
| 18890 The function checks each byte of a string whether it is UTF-8 encoded. The | |
| 18891 result of the check is stored in the @a state parameter. The function must | |
| 18892 be called initially with state 0 (accept). State 1 means the string must | |
| 18893 be rejected, because the current byte is not allowed. If the string is | |
| 18894 completely processed, but the state is non-zero, the string ended | |
| 18895 prematurely; that is, the last byte indicated more bytes should have | |
| 18896 followed. | |
| 18897 | |
| 18898 @param[in,out] state the state of the decoding | |
| 18899 @param[in,out] codep codepoint (valid only if resulting state is UTF8_ACCEPT) | |
| 18900 @param[in] byte next byte to decode | |
| 18901 @return new state | |
| 18902 | |
| 18903 @note The function has been edited: a std::array is used. | |
| 18904 | |
| 18905 @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de> | |
| 18906 @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ | |
| 18907 */ | |
| 18908 static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept | |
| 18909 { | |
| 18910 static const std::array<std::uint8_t, 400> utf8d = | |
| 18911 { | |
| 18912 { | |
| 18913 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 | |
| 18914 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 | |
| 18915 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 | |
| 18916 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 | |
| 18917 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 | |
| 18918 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 | |
| 18919 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 | |
| 18920 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF | |
| 18921 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF | |
| 18922 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0 | |
| 18923 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 | |
| 18924 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 | |
| 18925 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 | |
| 18926 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 | |
| 18927 } | |
| 18928 }; | |
| 18929 | |
| 18930 JSON_ASSERT(byte < utf8d.size()); | |
| 18931 const std::uint8_t type = utf8d[byte]; | |
| 18932 | |
| 18933 codep = (state != UTF8_ACCEPT) | |
| 18934 ? (byte & 0x3fu) | (codep << 6u) | |
| 18935 : (0xFFu >> type) & (byte); | |
| 18936 | |
| 18937 const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type); | |
| 18938 JSON_ASSERT(index < utf8d.size()); | |
| 18939 state = utf8d[index]; | |
| 18940 return state; | |
| 18941 } | |
| 18942 | |
| 18943 /* | |
| 18944 * Overload to make the compiler happy while it is instantiating | |
| 18945 * dump_integer for number_unsigned_t. | |
| 18946 * Must never be called. | |
| 18947 */ | |
| 18948 number_unsigned_t remove_sign(number_unsigned_t x) | |
| 18949 { | |
| 18950 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 18951 return x; // LCOV_EXCL_LINE | |
| 18952 } | |
| 18953 | |
| 18954 /* | |
| 18955 * Helper function for dump_integer | |
| 18956 * | |
| 18957 * This function takes a negative signed integer and returns its absolute | |
| 18958 * value as unsigned integer. The plus/minus shuffling is necessary as we can | |
| 18959 * not directly remove the sign of an arbitrary signed integer as the | |
| 18960 * absolute values of INT_MIN and INT_MAX are usually not the same. See | |
| 18961 * #1708 for details. | |
| 18962 */ | |
| 18963 inline number_unsigned_t remove_sign(number_integer_t x) noexcept | |
| 18964 { | |
| 18965 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression) | |
| 18966 return static_cast<number_unsigned_t>(-(x + 1)) + 1; | |
| 18967 } | |
| 18968 | |
| 18969 private: | |
| 18970 /// the output of the serializer | |
| 18971 output_adapter_t<char> o = nullptr; | |
| 18972 | |
| 18973 /// a (hopefully) large enough character buffer | |
| 18974 std::array<char, 64> number_buffer{{}}; | |
| 18975 | |
| 18976 /// the locale | |
| 18977 const std::lconv* loc = nullptr; | |
| 18978 /// the locale's thousand separator character | |
| 18979 const char thousands_sep = '\0'; | |
| 18980 /// the locale's decimal point character | |
| 18981 const char decimal_point = '\0'; | |
| 18982 | |
| 18983 /// string buffer | |
| 18984 std::array<char, 512> string_buffer{{}}; | |
| 18985 | |
| 18986 /// the indentation character | |
| 18987 const char indent_char; | |
| 18988 /// the indentation string | |
| 18989 string_t indent_string; | |
| 18990 | |
| 18991 /// error_handler how to react on decoding errors | |
| 18992 const error_handler_t error_handler; | |
| 18993 }; | |
| 18994 | |
| 18995 } // namespace detail | |
| 18996 NLOHMANN_JSON_NAMESPACE_END | |
| 18997 | |
| 18998 // #include <nlohmann/detail/value_t.hpp> | |
| 18999 | |
| 19000 // #include <nlohmann/json_fwd.hpp> | |
| 19001 | |
| 19002 // #include <nlohmann/ordered_map.hpp> | |
| 19003 // __ _____ _____ _____ | |
| 19004 // __| | __| | | | JSON for Modern C++ | |
| 19005 // | | |__ | | | | | | version 3.11.3 | |
| 19006 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 19007 // | |
| 19008 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 19009 // SPDX-License-Identifier: MIT | |
| 19010 | |
| 19011 | |
| 19012 | |
| 19013 #include <functional> // equal_to, less | |
| 19014 #include <initializer_list> // initializer_list | |
| 19015 #include <iterator> // input_iterator_tag, iterator_traits | |
| 19016 #include <memory> // allocator | |
| 19017 #include <stdexcept> // for out_of_range | |
| 19018 #include <type_traits> // enable_if, is_convertible | |
| 19019 #include <utility> // pair | |
| 19020 #include <vector> // vector | |
| 19021 | |
| 19022 // #include <nlohmann/detail/macro_scope.hpp> | |
| 19023 | |
| 19024 // #include <nlohmann/detail/meta/type_traits.hpp> | |
| 19025 | |
| 19026 | |
| 19027 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 19028 | |
| 19029 /// ordered_map: a minimal map-like container that preserves insertion order | |
| 19030 /// for use within nlohmann::basic_json<ordered_map> | |
| 19031 template <class Key, class T, class IgnoredLess = std::less<Key>, | |
| 19032 class Allocator = std::allocator<std::pair<const Key, T>>> | |
| 19033 struct ordered_map : std::vector<std::pair<const Key, T>, Allocator> | |
| 19034 { | |
| 19035 using key_type = Key; | |
| 19036 using mapped_type = T; | |
| 19037 using Container = std::vector<std::pair<const Key, T>, Allocator>; | |
| 19038 using iterator = typename Container::iterator; | |
| 19039 using const_iterator = typename Container::const_iterator; | |
| 19040 using size_type = typename Container::size_type; | |
| 19041 using value_type = typename Container::value_type; | |
| 19042 #ifdef JSON_HAS_CPP_14 | |
| 19043 using key_compare = std::equal_to<>; | |
| 19044 #else | |
| 19045 using key_compare = std::equal_to<Key>; | |
| 19046 #endif | |
| 19047 | |
| 19048 // Explicit constructors instead of `using Container::Container` | |
| 19049 // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4) | |
| 19050 ordered_map() noexcept(noexcept(Container())) : Container{} {} | |
| 19051 explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {} | |
| 19052 template <class It> | |
| 19053 ordered_map(It first, It last, const Allocator& alloc = Allocator()) | |
| 19054 : Container{first, last, alloc} {} | |
| 19055 ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() ) | |
| 19056 : Container{init, alloc} {} | |
| 19057 | |
| 19058 std::pair<iterator, bool> emplace(const key_type& key, T&& t) | |
| 19059 { | |
| 19060 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19061 { | |
| 19062 if (m_compare(it->first, key)) | |
| 19063 { | |
| 19064 return {it, false}; | |
| 19065 } | |
| 19066 } | |
| 19067 Container::emplace_back(key, std::forward<T>(t)); | |
| 19068 return {std::prev(this->end()), true}; | |
| 19069 } | |
| 19070 | |
| 19071 template<class KeyType, detail::enable_if_t< | |
| 19072 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19073 std::pair<iterator, bool> emplace(KeyType && key, T && t) | |
| 19074 { | |
| 19075 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19076 { | |
| 19077 if (m_compare(it->first, key)) | |
| 19078 { | |
| 19079 return {it, false}; | |
| 19080 } | |
| 19081 } | |
| 19082 Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t)); | |
| 19083 return {std::prev(this->end()), true}; | |
| 19084 } | |
| 19085 | |
| 19086 T& operator[](const key_type& key) | |
| 19087 { | |
| 19088 return emplace(key, T{}).first->second; | |
| 19089 } | |
| 19090 | |
| 19091 template<class KeyType, detail::enable_if_t< | |
| 19092 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19093 T & operator[](KeyType && key) | |
| 19094 { | |
| 19095 return emplace(std::forward<KeyType>(key), T{}).first->second; | |
| 19096 } | |
| 19097 | |
| 19098 const T& operator[](const key_type& key) const | |
| 19099 { | |
| 19100 return at(key); | |
| 19101 } | |
| 19102 | |
| 19103 template<class KeyType, detail::enable_if_t< | |
| 19104 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19105 const T & operator[](KeyType && key) const | |
| 19106 { | |
| 19107 return at(std::forward<KeyType>(key)); | |
| 19108 } | |
| 19109 | |
| 19110 T& at(const key_type& key) | |
| 19111 { | |
| 19112 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19113 { | |
| 19114 if (m_compare(it->first, key)) | |
| 19115 { | |
| 19116 return it->second; | |
| 19117 } | |
| 19118 } | |
| 19119 | |
| 19120 JSON_THROW(std::out_of_range("key not found")); | |
| 19121 } | |
| 19122 | |
| 19123 template<class KeyType, detail::enable_if_t< | |
| 19124 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19125 T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward) | |
| 19126 { | |
| 19127 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19128 { | |
| 19129 if (m_compare(it->first, key)) | |
| 19130 { | |
| 19131 return it->second; | |
| 19132 } | |
| 19133 } | |
| 19134 | |
| 19135 JSON_THROW(std::out_of_range("key not found")); | |
| 19136 } | |
| 19137 | |
| 19138 const T& at(const key_type& key) const | |
| 19139 { | |
| 19140 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19141 { | |
| 19142 if (m_compare(it->first, key)) | |
| 19143 { | |
| 19144 return it->second; | |
| 19145 } | |
| 19146 } | |
| 19147 | |
| 19148 JSON_THROW(std::out_of_range("key not found")); | |
| 19149 } | |
| 19150 | |
| 19151 template<class KeyType, detail::enable_if_t< | |
| 19152 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19153 const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward) | |
| 19154 { | |
| 19155 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19156 { | |
| 19157 if (m_compare(it->first, key)) | |
| 19158 { | |
| 19159 return it->second; | |
| 19160 } | |
| 19161 } | |
| 19162 | |
| 19163 JSON_THROW(std::out_of_range("key not found")); | |
| 19164 } | |
| 19165 | |
| 19166 size_type erase(const key_type& key) | |
| 19167 { | |
| 19168 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19169 { | |
| 19170 if (m_compare(it->first, key)) | |
| 19171 { | |
| 19172 // Since we cannot move const Keys, re-construct them in place | |
| 19173 for (auto next = it; ++next != this->end(); ++it) | |
| 19174 { | |
| 19175 it->~value_type(); // Destroy but keep allocation | |
| 19176 new (&*it) value_type{std::move(*next)}; | |
| 19177 } | |
| 19178 Container::pop_back(); | |
| 19179 return 1; | |
| 19180 } | |
| 19181 } | |
| 19182 return 0; | |
| 19183 } | |
| 19184 | |
| 19185 template<class KeyType, detail::enable_if_t< | |
| 19186 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19187 size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward) | |
| 19188 { | |
| 19189 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19190 { | |
| 19191 if (m_compare(it->first, key)) | |
| 19192 { | |
| 19193 // Since we cannot move const Keys, re-construct them in place | |
| 19194 for (auto next = it; ++next != this->end(); ++it) | |
| 19195 { | |
| 19196 it->~value_type(); // Destroy but keep allocation | |
| 19197 new (&*it) value_type{std::move(*next)}; | |
| 19198 } | |
| 19199 Container::pop_back(); | |
| 19200 return 1; | |
| 19201 } | |
| 19202 } | |
| 19203 return 0; | |
| 19204 } | |
| 19205 | |
| 19206 iterator erase(iterator pos) | |
| 19207 { | |
| 19208 return erase(pos, std::next(pos)); | |
| 19209 } | |
| 19210 | |
| 19211 iterator erase(iterator first, iterator last) | |
| 19212 { | |
| 19213 if (first == last) | |
| 19214 { | |
| 19215 return first; | |
| 19216 } | |
| 19217 | |
| 19218 const auto elements_affected = std::distance(first, last); | |
| 19219 const auto offset = std::distance(Container::begin(), first); | |
| 19220 | |
| 19221 // This is the start situation. We need to delete elements_affected | |
| 19222 // elements (3 in this example: e, f, g), and need to return an | |
| 19223 // iterator past the last deleted element (h in this example). | |
| 19224 // Note that offset is the distance from the start of the vector | |
| 19225 // to first. We will need this later. | |
| 19226 | |
| 19227 // [ a, b, c, d, e, f, g, h, i, j ] | |
| 19228 // ^ ^ | |
| 19229 // first last | |
| 19230 | |
| 19231 // Since we cannot move const Keys, we re-construct them in place. | |
| 19232 // We start at first and re-construct (viz. copy) the elements from | |
| 19233 // the back of the vector. Example for first iteration: | |
| 19234 | |
| 19235 // ,--------. | |
| 19236 // v | destroy e and re-construct with h | |
| 19237 // [ a, b, c, d, e, f, g, h, i, j ] | |
| 19238 // ^ ^ | |
| 19239 // it it + elements_affected | |
| 19240 | |
| 19241 for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it) | |
| 19242 { | |
| 19243 it->~value_type(); // destroy but keep allocation | |
| 19244 new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it | |
| 19245 } | |
| 19246 | |
| 19247 // [ a, b, c, d, h, i, j, h, i, j ] | |
| 19248 // ^ ^ | |
| 19249 // first last | |
| 19250 | |
| 19251 // remove the unneeded elements at the end of the vector | |
| 19252 Container::resize(this->size() - static_cast<size_type>(elements_affected)); | |
| 19253 | |
| 19254 // [ a, b, c, d, h, i, j ] | |
| 19255 // ^ ^ | |
| 19256 // first last | |
| 19257 | |
| 19258 // first is now pointing past the last deleted element, but we cannot | |
| 19259 // use this iterator, because it may have been invalidated by the | |
| 19260 // resize call. Instead, we can return begin() + offset. | |
| 19261 return Container::begin() + offset; | |
| 19262 } | |
| 19263 | |
| 19264 size_type count(const key_type& key) const | |
| 19265 { | |
| 19266 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19267 { | |
| 19268 if (m_compare(it->first, key)) | |
| 19269 { | |
| 19270 return 1; | |
| 19271 } | |
| 19272 } | |
| 19273 return 0; | |
| 19274 } | |
| 19275 | |
| 19276 template<class KeyType, detail::enable_if_t< | |
| 19277 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19278 size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward) | |
| 19279 { | |
| 19280 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19281 { | |
| 19282 if (m_compare(it->first, key)) | |
| 19283 { | |
| 19284 return 1; | |
| 19285 } | |
| 19286 } | |
| 19287 return 0; | |
| 19288 } | |
| 19289 | |
| 19290 iterator find(const key_type& key) | |
| 19291 { | |
| 19292 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19293 { | |
| 19294 if (m_compare(it->first, key)) | |
| 19295 { | |
| 19296 return it; | |
| 19297 } | |
| 19298 } | |
| 19299 return Container::end(); | |
| 19300 } | |
| 19301 | |
| 19302 template<class KeyType, detail::enable_if_t< | |
| 19303 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0> | |
| 19304 iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward) | |
| 19305 { | |
| 19306 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19307 { | |
| 19308 if (m_compare(it->first, key)) | |
| 19309 { | |
| 19310 return it; | |
| 19311 } | |
| 19312 } | |
| 19313 return Container::end(); | |
| 19314 } | |
| 19315 | |
| 19316 const_iterator find(const key_type& key) const | |
| 19317 { | |
| 19318 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19319 { | |
| 19320 if (m_compare(it->first, key)) | |
| 19321 { | |
| 19322 return it; | |
| 19323 } | |
| 19324 } | |
| 19325 return Container::end(); | |
| 19326 } | |
| 19327 | |
| 19328 std::pair<iterator, bool> insert( value_type&& value ) | |
| 19329 { | |
| 19330 return emplace(value.first, std::move(value.second)); | |
| 19331 } | |
| 19332 | |
| 19333 std::pair<iterator, bool> insert( const value_type& value ) | |
| 19334 { | |
| 19335 for (auto it = this->begin(); it != this->end(); ++it) | |
| 19336 { | |
| 19337 if (m_compare(it->first, value.first)) | |
| 19338 { | |
| 19339 return {it, false}; | |
| 19340 } | |
| 19341 } | |
| 19342 Container::push_back(value); | |
| 19343 return {--this->end(), true}; | |
| 19344 } | |
| 19345 | |
| 19346 template<typename InputIt> | |
| 19347 using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category, | |
| 19348 std::input_iterator_tag>::value>::type; | |
| 19349 | |
| 19350 template<typename InputIt, typename = require_input_iter<InputIt>> | |
| 19351 void insert(InputIt first, InputIt last) | |
| 19352 { | |
| 19353 for (auto it = first; it != last; ++it) | |
| 19354 { | |
| 19355 insert(*it); | |
| 19356 } | |
| 19357 } | |
| 19358 | |
| 19359 private: | |
| 19360 JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare(); | |
| 19361 }; | |
| 19362 | |
| 19363 NLOHMANN_JSON_NAMESPACE_END | |
| 19364 | |
| 19365 | |
| 19366 #if defined(JSON_HAS_CPP_17) | |
| 19367 #if JSON_HAS_STATIC_RTTI | |
| 19368 #include <any> | |
| 19369 #endif | |
| 19370 #include <string_view> | |
| 19371 #endif | |
| 19372 | |
| 19373 /*! | |
| 19374 @brief namespace for Niels Lohmann | |
| 19375 @see https://github.com/nlohmann | |
| 19376 @since version 1.0.0 | |
| 19377 */ | |
| 19378 NLOHMANN_JSON_NAMESPACE_BEGIN | |
| 19379 | |
| 19380 /*! | |
| 19381 @brief a class to store JSON values | |
| 19382 | |
| 19383 @internal | |
| 19384 @invariant The member variables @a m_value and @a m_type have the following | |
| 19385 relationship: | |
| 19386 - If `m_type == value_t::object`, then `m_value.object != nullptr`. | |
| 19387 - If `m_type == value_t::array`, then `m_value.array != nullptr`. | |
| 19388 - If `m_type == value_t::string`, then `m_value.string != nullptr`. | |
| 19389 The invariants are checked by member function assert_invariant(). | |
| 19390 | |
| 19391 @note ObjectType trick from https://stackoverflow.com/a/9860911 | |
| 19392 @endinternal | |
| 19393 | |
| 19394 @since version 1.0.0 | |
| 19395 | |
| 19396 @nosubgrouping | |
| 19397 */ | |
| 19398 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 19399 class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions) | |
| 19400 : public ::nlohmann::detail::json_base_class<CustomBaseClass> | |
| 19401 { | |
| 19402 private: | |
| 19403 template<detail::value_t> friend struct detail::external_constructor; | |
| 19404 | |
| 19405 template<typename> | |
| 19406 friend class ::nlohmann::json_pointer; | |
| 19407 // can be restored when json_pointer backwards compatibility is removed | |
| 19408 // friend ::nlohmann::json_pointer<StringType>; | |
| 19409 | |
| 19410 template<typename BasicJsonType, typename InputType> | |
| 19411 friend class ::nlohmann::detail::parser; | |
| 19412 friend ::nlohmann::detail::serializer<basic_json>; | |
| 19413 template<typename BasicJsonType> | |
| 19414 friend class ::nlohmann::detail::iter_impl; | |
| 19415 template<typename BasicJsonType, typename CharType> | |
| 19416 friend class ::nlohmann::detail::binary_writer; | |
| 19417 template<typename BasicJsonType, typename InputType, typename SAX> | |
| 19418 friend class ::nlohmann::detail::binary_reader; | |
| 19419 template<typename BasicJsonType> | |
| 19420 friend class ::nlohmann::detail::json_sax_dom_parser; | |
| 19421 template<typename BasicJsonType> | |
| 19422 friend class ::nlohmann::detail::json_sax_dom_callback_parser; | |
| 19423 friend class ::nlohmann::detail::exception; | |
| 19424 | |
| 19425 /// workaround type for MSVC | |
| 19426 using basic_json_t = NLOHMANN_BASIC_JSON_TPL; | |
| 19427 using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>; | |
| 19428 | |
| 19429 JSON_PRIVATE_UNLESS_TESTED: | |
| 19430 // convenience aliases for types residing in namespace detail; | |
| 19431 using lexer = ::nlohmann::detail::lexer_base<basic_json>; | |
| 19432 | |
| 19433 template<typename InputAdapterType> | |
| 19434 static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser( | |
| 19435 InputAdapterType adapter, | |
| 19436 detail::parser_callback_t<basic_json>cb = nullptr, | |
| 19437 const bool allow_exceptions = true, | |
| 19438 const bool ignore_comments = false | |
| 19439 ) | |
| 19440 { | |
| 19441 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter), | |
| 19442 std::move(cb), allow_exceptions, ignore_comments); | |
| 19443 } | |
| 19444 | |
| 19445 private: | |
| 19446 using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t; | |
| 19447 template<typename BasicJsonType> | |
| 19448 using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>; | |
| 19449 template<typename BasicJsonType> | |
| 19450 using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>; | |
| 19451 template<typename Iterator> | |
| 19452 using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>; | |
| 19453 template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>; | |
| 19454 | |
| 19455 template<typename CharType> | |
| 19456 using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>; | |
| 19457 | |
| 19458 template<typename InputType> | |
| 19459 using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>; | |
| 19460 template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>; | |
| 19461 | |
| 19462 JSON_PRIVATE_UNLESS_TESTED: | |
| 19463 using serializer = ::nlohmann::detail::serializer<basic_json>; | |
| 19464 | |
| 19465 public: | |
| 19466 using value_t = detail::value_t; | |
| 19467 /// JSON Pointer, see @ref nlohmann::json_pointer | |
| 19468 using json_pointer = ::nlohmann::json_pointer<StringType>; | |
| 19469 template<typename T, typename SFINAE> | |
| 19470 using json_serializer = JSONSerializer<T, SFINAE>; | |
| 19471 /// how to treat decoding errors | |
| 19472 using error_handler_t = detail::error_handler_t; | |
| 19473 /// how to treat CBOR tags | |
| 19474 using cbor_tag_handler_t = detail::cbor_tag_handler_t; | |
| 19475 /// helper type for initializer lists of basic_json values | |
| 19476 using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>; | |
| 19477 | |
| 19478 using input_format_t = detail::input_format_t; | |
| 19479 /// SAX interface type, see @ref nlohmann::json_sax | |
| 19480 using json_sax_t = json_sax<basic_json>; | |
| 19481 | |
| 19482 //////////////// | |
| 19483 // exceptions // | |
| 19484 //////////////// | |
| 19485 | |
| 19486 /// @name exceptions | |
| 19487 /// Classes to implement user-defined exceptions. | |
| 19488 /// @{ | |
| 19489 | |
| 19490 using exception = detail::exception; | |
| 19491 using parse_error = detail::parse_error; | |
| 19492 using invalid_iterator = detail::invalid_iterator; | |
| 19493 using type_error = detail::type_error; | |
| 19494 using out_of_range = detail::out_of_range; | |
| 19495 using other_error = detail::other_error; | |
| 19496 | |
| 19497 /// @} | |
| 19498 | |
| 19499 ///////////////////// | |
| 19500 // container types // | |
| 19501 ///////////////////// | |
| 19502 | |
| 19503 /// @name container types | |
| 19504 /// The canonic container types to use @ref basic_json like any other STL | |
| 19505 /// container. | |
| 19506 /// @{ | |
| 19507 | |
| 19508 /// the type of elements in a basic_json container | |
| 19509 using value_type = basic_json; | |
| 19510 | |
| 19511 /// the type of an element reference | |
| 19512 using reference = value_type&; | |
| 19513 /// the type of an element const reference | |
| 19514 using const_reference = const value_type&; | |
| 19515 | |
| 19516 /// a type to represent differences between iterators | |
| 19517 using difference_type = std::ptrdiff_t; | |
| 19518 /// a type to represent container sizes | |
| 19519 using size_type = std::size_t; | |
| 19520 | |
| 19521 /// the allocator type | |
| 19522 using allocator_type = AllocatorType<basic_json>; | |
| 19523 | |
| 19524 /// the type of an element pointer | |
| 19525 using pointer = typename std::allocator_traits<allocator_type>::pointer; | |
| 19526 /// the type of an element const pointer | |
| 19527 using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer; | |
| 19528 | |
| 19529 /// an iterator for a basic_json container | |
| 19530 using iterator = iter_impl<basic_json>; | |
| 19531 /// a const iterator for a basic_json container | |
| 19532 using const_iterator = iter_impl<const basic_json>; | |
| 19533 /// a reverse iterator for a basic_json container | |
| 19534 using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>; | |
| 19535 /// a const reverse iterator for a basic_json container | |
| 19536 using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>; | |
| 19537 | |
| 19538 /// @} | |
| 19539 | |
| 19540 /// @brief returns the allocator associated with the container | |
| 19541 /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/ | |
| 19542 static allocator_type get_allocator() | |
| 19543 { | |
| 19544 return allocator_type(); | |
| 19545 } | |
| 19546 | |
| 19547 /// @brief returns version information on the library | |
| 19548 /// @sa https://json.nlohmann.me/api/basic_json/meta/ | |
| 19549 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 19550 static basic_json meta() | |
| 19551 { | |
| 19552 basic_json result; | |
| 19553 | |
| 19554 result["copyright"] = "(C) 2013-2023 Niels Lohmann"; | |
| 19555 result["name"] = "JSON for Modern C++"; | |
| 19556 result["url"] = "https://github.com/nlohmann/json"; | |
| 19557 result["version"]["string"] = | |
| 19558 detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.', | |
| 19559 std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.', | |
| 19560 std::to_string(NLOHMANN_JSON_VERSION_PATCH)); | |
| 19561 result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR; | |
| 19562 result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR; | |
| 19563 result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH; | |
| 19564 | |
| 19565 #ifdef _WIN32 | |
| 19566 result["platform"] = "win32"; | |
| 19567 #elif defined __linux__ | |
| 19568 result["platform"] = "linux"; | |
| 19569 #elif defined __APPLE__ | |
| 19570 result["platform"] = "apple"; | |
| 19571 #elif defined __unix__ | |
| 19572 result["platform"] = "unix"; | |
| 19573 #else | |
| 19574 result["platform"] = "unknown"; | |
| 19575 #endif | |
| 19576 | |
| 19577 #if defined(__ICC) || defined(__INTEL_COMPILER) | |
| 19578 result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}}; | |
| 19579 #elif defined(__clang__) | |
| 19580 result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}}; | |
| 19581 #elif defined(__GNUC__) || defined(__GNUG__) | |
| 19582 result["compiler"] = {{"family", "gcc"}, {"version", detail::concat( | |
| 19583 std::to_string(__GNUC__), '.', | |
| 19584 std::to_string(__GNUC_MINOR__), '.', | |
| 19585 std::to_string(__GNUC_PATCHLEVEL__)) | |
| 19586 } | |
| 19587 }; | |
| 19588 #elif defined(__HP_cc) || defined(__HP_aCC) | |
| 19589 result["compiler"] = "hp" | |
| 19590 #elif defined(__IBMCPP__) | |
| 19591 result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}}; | |
| 19592 #elif defined(_MSC_VER) | |
| 19593 result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}}; | |
| 19594 #elif defined(__PGI) | |
| 19595 result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}}; | |
| 19596 #elif defined(__SUNPRO_CC) | |
| 19597 result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}}; | |
| 19598 #else | |
| 19599 result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}}; | |
| 19600 #endif | |
| 19601 | |
| 19602 #if defined(_MSVC_LANG) | |
| 19603 result["compiler"]["c++"] = std::to_string(_MSVC_LANG); | |
| 19604 #elif defined(__cplusplus) | |
| 19605 result["compiler"]["c++"] = std::to_string(__cplusplus); | |
| 19606 #else | |
| 19607 result["compiler"]["c++"] = "unknown"; | |
| 19608 #endif | |
| 19609 return result; | |
| 19610 } | |
| 19611 | |
| 19612 /////////////////////////// | |
| 19613 // JSON value data types // | |
| 19614 /////////////////////////// | |
| 19615 | |
| 19616 /// @name JSON value data types | |
| 19617 /// The data types to store a JSON value. These types are derived from | |
| 19618 /// the template arguments passed to class @ref basic_json. | |
| 19619 /// @{ | |
| 19620 | |
| 19621 /// @brief default object key comparator type | |
| 19622 /// The actual object key comparator type (@ref object_comparator_t) may be | |
| 19623 /// different. | |
| 19624 /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/ | |
| 19625 #if defined(JSON_HAS_CPP_14) | |
| 19626 // use of transparent comparator avoids unnecessary repeated construction of temporaries | |
| 19627 // in functions involving lookup by key with types other than object_t::key_type (aka. StringType) | |
| 19628 using default_object_comparator_t = std::less<>; | |
| 19629 #else | |
| 19630 using default_object_comparator_t = std::less<StringType>; | |
| 19631 #endif | |
| 19632 | |
| 19633 /// @brief a type for an object | |
| 19634 /// @sa https://json.nlohmann.me/api/basic_json/object_t/ | |
| 19635 using object_t = ObjectType<StringType, | |
| 19636 basic_json, | |
| 19637 default_object_comparator_t, | |
| 19638 AllocatorType<std::pair<const StringType, | |
| 19639 basic_json>>>; | |
| 19640 | |
| 19641 /// @brief a type for an array | |
| 19642 /// @sa https://json.nlohmann.me/api/basic_json/array_t/ | |
| 19643 using array_t = ArrayType<basic_json, AllocatorType<basic_json>>; | |
| 19644 | |
| 19645 /// @brief a type for a string | |
| 19646 /// @sa https://json.nlohmann.me/api/basic_json/string_t/ | |
| 19647 using string_t = StringType; | |
| 19648 | |
| 19649 /// @brief a type for a boolean | |
| 19650 /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/ | |
| 19651 using boolean_t = BooleanType; | |
| 19652 | |
| 19653 /// @brief a type for a number (integer) | |
| 19654 /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/ | |
| 19655 using number_integer_t = NumberIntegerType; | |
| 19656 | |
| 19657 /// @brief a type for a number (unsigned) | |
| 19658 /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/ | |
| 19659 using number_unsigned_t = NumberUnsignedType; | |
| 19660 | |
| 19661 /// @brief a type for a number (floating-point) | |
| 19662 /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/ | |
| 19663 using number_float_t = NumberFloatType; | |
| 19664 | |
| 19665 /// @brief a type for a packed binary type | |
| 19666 /// @sa https://json.nlohmann.me/api/basic_json/binary_t/ | |
| 19667 using binary_t = nlohmann::byte_container_with_subtype<BinaryType>; | |
| 19668 | |
| 19669 /// @brief object key comparator type | |
| 19670 /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/ | |
| 19671 using object_comparator_t = detail::actual_object_comparator_t<basic_json>; | |
| 19672 | |
| 19673 /// @} | |
| 19674 | |
| 19675 private: | |
| 19676 | |
| 19677 /// helper for exception-safe object creation | |
| 19678 template<typename T, typename... Args> | |
| 19679 JSON_HEDLEY_RETURNS_NON_NULL | |
| 19680 static T* create(Args&& ... args) | |
| 19681 { | |
| 19682 AllocatorType<T> alloc; | |
| 19683 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>; | |
| 19684 | |
| 19685 auto deleter = [&](T * obj) | |
| 19686 { | |
| 19687 AllocatorTraits::deallocate(alloc, obj, 1); | |
| 19688 }; | |
| 19689 std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter); | |
| 19690 AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...); | |
| 19691 JSON_ASSERT(obj != nullptr); | |
| 19692 return obj.release(); | |
| 19693 } | |
| 19694 | |
| 19695 //////////////////////// | |
| 19696 // JSON value storage // | |
| 19697 //////////////////////// | |
| 19698 | |
| 19699 JSON_PRIVATE_UNLESS_TESTED: | |
| 19700 /*! | |
| 19701 @brief a JSON value | |
| 19702 | |
| 19703 The actual storage for a JSON value of the @ref basic_json class. This | |
| 19704 union combines the different storage types for the JSON value types | |
| 19705 defined in @ref value_t. | |
| 19706 | |
| 19707 JSON type | value_t type | used type | |
| 19708 --------- | --------------- | ------------------------ | |
| 19709 object | object | pointer to @ref object_t | |
| 19710 array | array | pointer to @ref array_t | |
| 19711 string | string | pointer to @ref string_t | |
| 19712 boolean | boolean | @ref boolean_t | |
| 19713 number | number_integer | @ref number_integer_t | |
| 19714 number | number_unsigned | @ref number_unsigned_t | |
| 19715 number | number_float | @ref number_float_t | |
| 19716 binary | binary | pointer to @ref binary_t | |
| 19717 null | null | *no value is stored* | |
| 19718 | |
| 19719 @note Variable-length types (objects, arrays, and strings) are stored as | |
| 19720 pointers. The size of the union should not exceed 64 bits if the default | |
| 19721 value types are used. | |
| 19722 | |
| 19723 @since version 1.0.0 | |
| 19724 */ | |
| 19725 union json_value | |
| 19726 { | |
| 19727 /// object (stored with pointer to save storage) | |
| 19728 object_t* object; | |
| 19729 /// array (stored with pointer to save storage) | |
| 19730 array_t* array; | |
| 19731 /// string (stored with pointer to save storage) | |
| 19732 string_t* string; | |
| 19733 /// binary (stored with pointer to save storage) | |
| 19734 binary_t* binary; | |
| 19735 /// boolean | |
| 19736 boolean_t boolean; | |
| 19737 /// number (integer) | |
| 19738 number_integer_t number_integer; | |
| 19739 /// number (unsigned integer) | |
| 19740 number_unsigned_t number_unsigned; | |
| 19741 /// number (floating-point) | |
| 19742 number_float_t number_float; | |
| 19743 | |
| 19744 /// default constructor (for null values) | |
| 19745 json_value() = default; | |
| 19746 /// constructor for booleans | |
| 19747 json_value(boolean_t v) noexcept : boolean(v) {} | |
| 19748 /// constructor for numbers (integer) | |
| 19749 json_value(number_integer_t v) noexcept : number_integer(v) {} | |
| 19750 /// constructor for numbers (unsigned) | |
| 19751 json_value(number_unsigned_t v) noexcept : number_unsigned(v) {} | |
| 19752 /// constructor for numbers (floating-point) | |
| 19753 json_value(number_float_t v) noexcept : number_float(v) {} | |
| 19754 /// constructor for empty values of a given type | |
| 19755 json_value(value_t t) | |
| 19756 { | |
| 19757 switch (t) | |
| 19758 { | |
| 19759 case value_t::object: | |
| 19760 { | |
| 19761 object = create<object_t>(); | |
| 19762 break; | |
| 19763 } | |
| 19764 | |
| 19765 case value_t::array: | |
| 19766 { | |
| 19767 array = create<array_t>(); | |
| 19768 break; | |
| 19769 } | |
| 19770 | |
| 19771 case value_t::string: | |
| 19772 { | |
| 19773 string = create<string_t>(""); | |
| 19774 break; | |
| 19775 } | |
| 19776 | |
| 19777 case value_t::binary: | |
| 19778 { | |
| 19779 binary = create<binary_t>(); | |
| 19780 break; | |
| 19781 } | |
| 19782 | |
| 19783 case value_t::boolean: | |
| 19784 { | |
| 19785 boolean = static_cast<boolean_t>(false); | |
| 19786 break; | |
| 19787 } | |
| 19788 | |
| 19789 case value_t::number_integer: | |
| 19790 { | |
| 19791 number_integer = static_cast<number_integer_t>(0); | |
| 19792 break; | |
| 19793 } | |
| 19794 | |
| 19795 case value_t::number_unsigned: | |
| 19796 { | |
| 19797 number_unsigned = static_cast<number_unsigned_t>(0); | |
| 19798 break; | |
| 19799 } | |
| 19800 | |
| 19801 case value_t::number_float: | |
| 19802 { | |
| 19803 number_float = static_cast<number_float_t>(0.0); | |
| 19804 break; | |
| 19805 } | |
| 19806 | |
| 19807 case value_t::null: | |
| 19808 { | |
| 19809 object = nullptr; // silence warning, see #821 | |
| 19810 break; | |
| 19811 } | |
| 19812 | |
| 19813 case value_t::discarded: | |
| 19814 default: | |
| 19815 { | |
| 19816 object = nullptr; // silence warning, see #821 | |
| 19817 if (JSON_HEDLEY_UNLIKELY(t == value_t::null)) | |
| 19818 { | |
| 19819 JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE | |
| 19820 } | |
| 19821 break; | |
| 19822 } | |
| 19823 } | |
| 19824 } | |
| 19825 | |
| 19826 /// constructor for strings | |
| 19827 json_value(const string_t& value) : string(create<string_t>(value)) {} | |
| 19828 | |
| 19829 /// constructor for rvalue strings | |
| 19830 json_value(string_t&& value) : string(create<string_t>(std::move(value))) {} | |
| 19831 | |
| 19832 /// constructor for objects | |
| 19833 json_value(const object_t& value) : object(create<object_t>(value)) {} | |
| 19834 | |
| 19835 /// constructor for rvalue objects | |
| 19836 json_value(object_t&& value) : object(create<object_t>(std::move(value))) {} | |
| 19837 | |
| 19838 /// constructor for arrays | |
| 19839 json_value(const array_t& value) : array(create<array_t>(value)) {} | |
| 19840 | |
| 19841 /// constructor for rvalue arrays | |
| 19842 json_value(array_t&& value) : array(create<array_t>(std::move(value))) {} | |
| 19843 | |
| 19844 /// constructor for binary arrays | |
| 19845 json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {} | |
| 19846 | |
| 19847 /// constructor for rvalue binary arrays | |
| 19848 json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {} | |
| 19849 | |
| 19850 /// constructor for binary arrays (internal type) | |
| 19851 json_value(const binary_t& value) : binary(create<binary_t>(value)) {} | |
| 19852 | |
| 19853 /// constructor for rvalue binary arrays (internal type) | |
| 19854 json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {} | |
| 19855 | |
| 19856 void destroy(value_t t) | |
| 19857 { | |
| 19858 if ( | |
| 19859 (t == value_t::object && object == nullptr) || | |
| 19860 (t == value_t::array && array == nullptr) || | |
| 19861 (t == value_t::string && string == nullptr) || | |
| 19862 (t == value_t::binary && binary == nullptr) | |
| 19863 ) | |
| 19864 { | |
| 19865 //not initialized (e.g. due to exception in the ctor) | |
| 19866 return; | |
| 19867 } | |
| 19868 if (t == value_t::array || t == value_t::object) | |
| 19869 { | |
| 19870 // flatten the current json_value to a heap-allocated stack | |
| 19871 std::vector<basic_json> stack; | |
| 19872 | |
| 19873 // move the top-level items to stack | |
| 19874 if (t == value_t::array) | |
| 19875 { | |
| 19876 stack.reserve(array->size()); | |
| 19877 std::move(array->begin(), array->end(), std::back_inserter(stack)); | |
| 19878 } | |
| 19879 else | |
| 19880 { | |
| 19881 stack.reserve(object->size()); | |
| 19882 for (auto&& it : *object) | |
| 19883 { | |
| 19884 stack.push_back(std::move(it.second)); | |
| 19885 } | |
| 19886 } | |
| 19887 | |
| 19888 while (!stack.empty()) | |
| 19889 { | |
| 19890 // move the last item to local variable to be processed | |
| 19891 basic_json current_item(std::move(stack.back())); | |
| 19892 stack.pop_back(); | |
| 19893 | |
| 19894 // if current_item is array/object, move | |
| 19895 // its children to the stack to be processed later | |
| 19896 if (current_item.is_array()) | |
| 19897 { | |
| 19898 std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack)); | |
| 19899 | |
| 19900 current_item.m_data.m_value.array->clear(); | |
| 19901 } | |
| 19902 else if (current_item.is_object()) | |
| 19903 { | |
| 19904 for (auto&& it : *current_item.m_data.m_value.object) | |
| 19905 { | |
| 19906 stack.push_back(std::move(it.second)); | |
| 19907 } | |
| 19908 | |
| 19909 current_item.m_data.m_value.object->clear(); | |
| 19910 } | |
| 19911 | |
| 19912 // it's now safe that current_item get destructed | |
| 19913 // since it doesn't have any children | |
| 19914 } | |
| 19915 } | |
| 19916 | |
| 19917 switch (t) | |
| 19918 { | |
| 19919 case value_t::object: | |
| 19920 { | |
| 19921 AllocatorType<object_t> alloc; | |
| 19922 std::allocator_traits<decltype(alloc)>::destroy(alloc, object); | |
| 19923 std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1); | |
| 19924 break; | |
| 19925 } | |
| 19926 | |
| 19927 case value_t::array: | |
| 19928 { | |
| 19929 AllocatorType<array_t> alloc; | |
| 19930 std::allocator_traits<decltype(alloc)>::destroy(alloc, array); | |
| 19931 std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1); | |
| 19932 break; | |
| 19933 } | |
| 19934 | |
| 19935 case value_t::string: | |
| 19936 { | |
| 19937 AllocatorType<string_t> alloc; | |
| 19938 std::allocator_traits<decltype(alloc)>::destroy(alloc, string); | |
| 19939 std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1); | |
| 19940 break; | |
| 19941 } | |
| 19942 | |
| 19943 case value_t::binary: | |
| 19944 { | |
| 19945 AllocatorType<binary_t> alloc; | |
| 19946 std::allocator_traits<decltype(alloc)>::destroy(alloc, binary); | |
| 19947 std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1); | |
| 19948 break; | |
| 19949 } | |
| 19950 | |
| 19951 case value_t::null: | |
| 19952 case value_t::boolean: | |
| 19953 case value_t::number_integer: | |
| 19954 case value_t::number_unsigned: | |
| 19955 case value_t::number_float: | |
| 19956 case value_t::discarded: | |
| 19957 default: | |
| 19958 { | |
| 19959 break; | |
| 19960 } | |
| 19961 } | |
| 19962 } | |
| 19963 }; | |
| 19964 | |
| 19965 private: | |
| 19966 /*! | |
| 19967 @brief checks the class invariants | |
| 19968 | |
| 19969 This function asserts the class invariants. It needs to be called at the | |
| 19970 end of every constructor to make sure that created objects respect the | |
| 19971 invariant. Furthermore, it has to be called each time the type of a JSON | |
| 19972 value is changed, because the invariant expresses a relationship between | |
| 19973 @a m_type and @a m_value. | |
| 19974 | |
| 19975 Furthermore, the parent relation is checked for arrays and objects: If | |
| 19976 @a check_parents true and the value is an array or object, then the | |
| 19977 container's elements must have the current value as parent. | |
| 19978 | |
| 19979 @param[in] check_parents whether the parent relation should be checked. | |
| 19980 The value is true by default and should only be set to false | |
| 19981 during destruction of objects when the invariant does not | |
| 19982 need to hold. | |
| 19983 */ | |
| 19984 void assert_invariant(bool check_parents = true) const noexcept | |
| 19985 { | |
| 19986 JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr); | |
| 19987 JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr); | |
| 19988 JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr); | |
| 19989 JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr); | |
| 19990 | |
| 19991 #if JSON_DIAGNOSTICS | |
| 19992 JSON_TRY | |
| 19993 { | |
| 19994 // cppcheck-suppress assertWithSideEffect | |
| 19995 JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j) | |
| 19996 { | |
| 19997 return j.m_parent == this; | |
| 19998 })); | |
| 19999 } | |
| 20000 JSON_CATCH(...) {} // LCOV_EXCL_LINE | |
| 20001 #endif | |
| 20002 static_cast<void>(check_parents); | |
| 20003 } | |
| 20004 | |
| 20005 void set_parents() | |
| 20006 { | |
| 20007 #if JSON_DIAGNOSTICS | |
| 20008 switch (m_data.m_type) | |
| 20009 { | |
| 20010 case value_t::array: | |
| 20011 { | |
| 20012 for (auto& element : *m_data.m_value.array) | |
| 20013 { | |
| 20014 element.m_parent = this; | |
| 20015 } | |
| 20016 break; | |
| 20017 } | |
| 20018 | |
| 20019 case value_t::object: | |
| 20020 { | |
| 20021 for (auto& element : *m_data.m_value.object) | |
| 20022 { | |
| 20023 element.second.m_parent = this; | |
| 20024 } | |
| 20025 break; | |
| 20026 } | |
| 20027 | |
| 20028 case value_t::null: | |
| 20029 case value_t::string: | |
| 20030 case value_t::boolean: | |
| 20031 case value_t::number_integer: | |
| 20032 case value_t::number_unsigned: | |
| 20033 case value_t::number_float: | |
| 20034 case value_t::binary: | |
| 20035 case value_t::discarded: | |
| 20036 default: | |
| 20037 break; | |
| 20038 } | |
| 20039 #endif | |
| 20040 } | |
| 20041 | |
| 20042 iterator set_parents(iterator it, typename iterator::difference_type count_set_parents) | |
| 20043 { | |
| 20044 #if JSON_DIAGNOSTICS | |
| 20045 for (typename iterator::difference_type i = 0; i < count_set_parents; ++i) | |
| 20046 { | |
| 20047 (it + i)->m_parent = this; | |
| 20048 } | |
| 20049 #else | |
| 20050 static_cast<void>(count_set_parents); | |
| 20051 #endif | |
| 20052 return it; | |
| 20053 } | |
| 20054 | |
| 20055 reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1)) | |
| 20056 { | |
| 20057 #if JSON_DIAGNOSTICS | |
| 20058 if (old_capacity != static_cast<std::size_t>(-1)) | |
| 20059 { | |
| 20060 // see https://github.com/nlohmann/json/issues/2838 | |
| 20061 JSON_ASSERT(type() == value_t::array); | |
| 20062 if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity)) | |
| 20063 { | |
| 20064 // capacity has changed: update all parents | |
| 20065 set_parents(); | |
| 20066 return j; | |
| 20067 } | |
| 20068 } | |
| 20069 | |
| 20070 // ordered_json uses a vector internally, so pointers could have | |
| 20071 // been invalidated; see https://github.com/nlohmann/json/issues/2962 | |
| 20072 #ifdef JSON_HEDLEY_MSVC_VERSION | |
| 20073 #pragma warning(push ) | |
| 20074 #pragma warning(disable : 4127) // ignore warning to replace if with if constexpr | |
| 20075 #endif | |
| 20076 if (detail::is_ordered_map<object_t>::value) | |
| 20077 { | |
| 20078 set_parents(); | |
| 20079 return j; | |
| 20080 } | |
| 20081 #ifdef JSON_HEDLEY_MSVC_VERSION | |
| 20082 #pragma warning( pop ) | |
| 20083 #endif | |
| 20084 | |
| 20085 j.m_parent = this; | |
| 20086 #else | |
| 20087 static_cast<void>(j); | |
| 20088 static_cast<void>(old_capacity); | |
| 20089 #endif | |
| 20090 return j; | |
| 20091 } | |
| 20092 | |
| 20093 public: | |
| 20094 ////////////////////////// | |
| 20095 // JSON parser callback // | |
| 20096 ////////////////////////// | |
| 20097 | |
| 20098 /// @brief parser event types | |
| 20099 /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/ | |
| 20100 using parse_event_t = detail::parse_event_t; | |
| 20101 | |
| 20102 /// @brief per-element parser callback type | |
| 20103 /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/ | |
| 20104 using parser_callback_t = detail::parser_callback_t<basic_json>; | |
| 20105 | |
| 20106 ////////////////// | |
| 20107 // constructors // | |
| 20108 ////////////////// | |
| 20109 | |
| 20110 /// @name constructors and destructors | |
| 20111 /// Constructors of class @ref basic_json, copy/move constructor, copy | |
| 20112 /// assignment, static functions creating objects, and the destructor. | |
| 20113 /// @{ | |
| 20114 | |
| 20115 /// @brief create an empty value with a given type | |
| 20116 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20117 basic_json(const value_t v) | |
| 20118 : m_data(v) | |
| 20119 { | |
| 20120 assert_invariant(); | |
| 20121 } | |
| 20122 | |
| 20123 /// @brief create a null object | |
| 20124 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20125 basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape) | |
| 20126 : basic_json(value_t::null) | |
| 20127 { | |
| 20128 assert_invariant(); | |
| 20129 } | |
| 20130 | |
| 20131 /// @brief create a JSON value from compatible types | |
| 20132 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20133 template < typename CompatibleType, | |
| 20134 typename U = detail::uncvref_t<CompatibleType>, | |
| 20135 detail::enable_if_t < | |
| 20136 !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 > | |
| 20137 basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape) | |
| 20138 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(), | |
| 20139 std::forward<CompatibleType>(val)))) | |
| 20140 { | |
| 20141 JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val)); | |
| 20142 set_parents(); | |
| 20143 assert_invariant(); | |
| 20144 } | |
| 20145 | |
| 20146 /// @brief create a JSON value from an existing one | |
| 20147 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20148 template < typename BasicJsonType, | |
| 20149 detail::enable_if_t < | |
| 20150 detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 > | |
| 20151 basic_json(const BasicJsonType& val) | |
| 20152 { | |
| 20153 using other_boolean_t = typename BasicJsonType::boolean_t; | |
| 20154 using other_number_float_t = typename BasicJsonType::number_float_t; | |
| 20155 using other_number_integer_t = typename BasicJsonType::number_integer_t; | |
| 20156 using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t; | |
| 20157 using other_string_t = typename BasicJsonType::string_t; | |
| 20158 using other_object_t = typename BasicJsonType::object_t; | |
| 20159 using other_array_t = typename BasicJsonType::array_t; | |
| 20160 using other_binary_t = typename BasicJsonType::binary_t; | |
| 20161 | |
| 20162 switch (val.type()) | |
| 20163 { | |
| 20164 case value_t::boolean: | |
| 20165 JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>()); | |
| 20166 break; | |
| 20167 case value_t::number_float: | |
| 20168 JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>()); | |
| 20169 break; | |
| 20170 case value_t::number_integer: | |
| 20171 JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>()); | |
| 20172 break; | |
| 20173 case value_t::number_unsigned: | |
| 20174 JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>()); | |
| 20175 break; | |
| 20176 case value_t::string: | |
| 20177 JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>()); | |
| 20178 break; | |
| 20179 case value_t::object: | |
| 20180 JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>()); | |
| 20181 break; | |
| 20182 case value_t::array: | |
| 20183 JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>()); | |
| 20184 break; | |
| 20185 case value_t::binary: | |
| 20186 JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>()); | |
| 20187 break; | |
| 20188 case value_t::null: | |
| 20189 *this = nullptr; | |
| 20190 break; | |
| 20191 case value_t::discarded: | |
| 20192 m_data.m_type = value_t::discarded; | |
| 20193 break; | |
| 20194 default: // LCOV_EXCL_LINE | |
| 20195 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 20196 } | |
| 20197 JSON_ASSERT(m_data.m_type == val.type()); | |
| 20198 set_parents(); | |
| 20199 assert_invariant(); | |
| 20200 } | |
| 20201 | |
| 20202 /// @brief create a container (array or object) from an initializer list | |
| 20203 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20204 basic_json(initializer_list_t init, | |
| 20205 bool type_deduction = true, | |
| 20206 value_t manual_type = value_t::array) | |
| 20207 { | |
| 20208 // check if each element is an array with two elements whose first | |
| 20209 // element is a string | |
| 20210 bool is_an_object = std::all_of(init.begin(), init.end(), | |
| 20211 [](const detail::json_ref<basic_json>& element_ref) | |
| 20212 { | |
| 20213 // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int; | |
| 20214 // (many string types can be constructed from 0 via its null-pointer guise, so we get a | |
| 20215 // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows) | |
| 20216 return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string(); | |
| 20217 }); | |
| 20218 | |
| 20219 // adjust type if type deduction is not wanted | |
| 20220 if (!type_deduction) | |
| 20221 { | |
| 20222 // if array is wanted, do not create an object though possible | |
| 20223 if (manual_type == value_t::array) | |
| 20224 { | |
| 20225 is_an_object = false; | |
| 20226 } | |
| 20227 | |
| 20228 // if object is wanted but impossible, throw an exception | |
| 20229 if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object)) | |
| 20230 { | |
| 20231 JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr)); | |
| 20232 } | |
| 20233 } | |
| 20234 | |
| 20235 if (is_an_object) | |
| 20236 { | |
| 20237 // the initializer list is a list of pairs -> create object | |
| 20238 m_data.m_type = value_t::object; | |
| 20239 m_data.m_value = value_t::object; | |
| 20240 | |
| 20241 for (auto& element_ref : init) | |
| 20242 { | |
| 20243 auto element = element_ref.moved_or_copied(); | |
| 20244 m_data.m_value.object->emplace( | |
| 20245 std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)), | |
| 20246 std::move((*element.m_data.m_value.array)[1])); | |
| 20247 } | |
| 20248 } | |
| 20249 else | |
| 20250 { | |
| 20251 // the initializer list describes an array -> create array | |
| 20252 m_data.m_type = value_t::array; | |
| 20253 m_data.m_value.array = create<array_t>(init.begin(), init.end()); | |
| 20254 } | |
| 20255 | |
| 20256 set_parents(); | |
| 20257 assert_invariant(); | |
| 20258 } | |
| 20259 | |
| 20260 /// @brief explicitly create a binary array (without subtype) | |
| 20261 /// @sa https://json.nlohmann.me/api/basic_json/binary/ | |
| 20262 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 20263 static basic_json binary(const typename binary_t::container_type& init) | |
| 20264 { | |
| 20265 auto res = basic_json(); | |
| 20266 res.m_data.m_type = value_t::binary; | |
| 20267 res.m_data.m_value = init; | |
| 20268 return res; | |
| 20269 } | |
| 20270 | |
| 20271 /// @brief explicitly create a binary array (with subtype) | |
| 20272 /// @sa https://json.nlohmann.me/api/basic_json/binary/ | |
| 20273 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 20274 static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype) | |
| 20275 { | |
| 20276 auto res = basic_json(); | |
| 20277 res.m_data.m_type = value_t::binary; | |
| 20278 res.m_data.m_value = binary_t(init, subtype); | |
| 20279 return res; | |
| 20280 } | |
| 20281 | |
| 20282 /// @brief explicitly create a binary array | |
| 20283 /// @sa https://json.nlohmann.me/api/basic_json/binary/ | |
| 20284 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 20285 static basic_json binary(typename binary_t::container_type&& init) | |
| 20286 { | |
| 20287 auto res = basic_json(); | |
| 20288 res.m_data.m_type = value_t::binary; | |
| 20289 res.m_data.m_value = std::move(init); | |
| 20290 return res; | |
| 20291 } | |
| 20292 | |
| 20293 /// @brief explicitly create a binary array (with subtype) | |
| 20294 /// @sa https://json.nlohmann.me/api/basic_json/binary/ | |
| 20295 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 20296 static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype) | |
| 20297 { | |
| 20298 auto res = basic_json(); | |
| 20299 res.m_data.m_type = value_t::binary; | |
| 20300 res.m_data.m_value = binary_t(std::move(init), subtype); | |
| 20301 return res; | |
| 20302 } | |
| 20303 | |
| 20304 /// @brief explicitly create an array from an initializer list | |
| 20305 /// @sa https://json.nlohmann.me/api/basic_json/array/ | |
| 20306 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 20307 static basic_json array(initializer_list_t init = {}) | |
| 20308 { | |
| 20309 return basic_json(init, false, value_t::array); | |
| 20310 } | |
| 20311 | |
| 20312 /// @brief explicitly create an object from an initializer list | |
| 20313 /// @sa https://json.nlohmann.me/api/basic_json/object/ | |
| 20314 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 20315 static basic_json object(initializer_list_t init = {}) | |
| 20316 { | |
| 20317 return basic_json(init, false, value_t::object); | |
| 20318 } | |
| 20319 | |
| 20320 /// @brief construct an array with count copies of given value | |
| 20321 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20322 basic_json(size_type cnt, const basic_json& val): | |
| 20323 m_data{cnt, val} | |
| 20324 { | |
| 20325 set_parents(); | |
| 20326 assert_invariant(); | |
| 20327 } | |
| 20328 | |
| 20329 /// @brief construct a JSON container given an iterator range | |
| 20330 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20331 template < class InputIT, typename std::enable_if < | |
| 20332 std::is_same<InputIT, typename basic_json_t::iterator>::value || | |
| 20333 std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 > | |
| 20334 basic_json(InputIT first, InputIT last) | |
| 20335 { | |
| 20336 JSON_ASSERT(first.m_object != nullptr); | |
| 20337 JSON_ASSERT(last.m_object != nullptr); | |
| 20338 | |
| 20339 // make sure iterator fits the current value | |
| 20340 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) | |
| 20341 { | |
| 20342 JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr)); | |
| 20343 } | |
| 20344 | |
| 20345 // copy type from first iterator | |
| 20346 m_data.m_type = first.m_object->m_data.m_type; | |
| 20347 | |
| 20348 // check if iterator range is complete for primitive values | |
| 20349 switch (m_data.m_type) | |
| 20350 { | |
| 20351 case value_t::boolean: | |
| 20352 case value_t::number_float: | |
| 20353 case value_t::number_integer: | |
| 20354 case value_t::number_unsigned: | |
| 20355 case value_t::string: | |
| 20356 { | |
| 20357 if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin() | |
| 20358 || !last.m_it.primitive_iterator.is_end())) | |
| 20359 { | |
| 20360 JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object)); | |
| 20361 } | |
| 20362 break; | |
| 20363 } | |
| 20364 | |
| 20365 case value_t::null: | |
| 20366 case value_t::object: | |
| 20367 case value_t::array: | |
| 20368 case value_t::binary: | |
| 20369 case value_t::discarded: | |
| 20370 default: | |
| 20371 break; | |
| 20372 } | |
| 20373 | |
| 20374 switch (m_data.m_type) | |
| 20375 { | |
| 20376 case value_t::number_integer: | |
| 20377 { | |
| 20378 m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer; | |
| 20379 break; | |
| 20380 } | |
| 20381 | |
| 20382 case value_t::number_unsigned: | |
| 20383 { | |
| 20384 m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned; | |
| 20385 break; | |
| 20386 } | |
| 20387 | |
| 20388 case value_t::number_float: | |
| 20389 { | |
| 20390 m_data.m_value.number_float = first.m_object->m_data.m_value.number_float; | |
| 20391 break; | |
| 20392 } | |
| 20393 | |
| 20394 case value_t::boolean: | |
| 20395 { | |
| 20396 m_data.m_value.boolean = first.m_object->m_data.m_value.boolean; | |
| 20397 break; | |
| 20398 } | |
| 20399 | |
| 20400 case value_t::string: | |
| 20401 { | |
| 20402 m_data.m_value = *first.m_object->m_data.m_value.string; | |
| 20403 break; | |
| 20404 } | |
| 20405 | |
| 20406 case value_t::object: | |
| 20407 { | |
| 20408 m_data.m_value.object = create<object_t>(first.m_it.object_iterator, | |
| 20409 last.m_it.object_iterator); | |
| 20410 break; | |
| 20411 } | |
| 20412 | |
| 20413 case value_t::array: | |
| 20414 { | |
| 20415 m_data.m_value.array = create<array_t>(first.m_it.array_iterator, | |
| 20416 last.m_it.array_iterator); | |
| 20417 break; | |
| 20418 } | |
| 20419 | |
| 20420 case value_t::binary: | |
| 20421 { | |
| 20422 m_data.m_value = *first.m_object->m_data.m_value.binary; | |
| 20423 break; | |
| 20424 } | |
| 20425 | |
| 20426 case value_t::null: | |
| 20427 case value_t::discarded: | |
| 20428 default: | |
| 20429 JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object)); | |
| 20430 } | |
| 20431 | |
| 20432 set_parents(); | |
| 20433 assert_invariant(); | |
| 20434 } | |
| 20435 | |
| 20436 /////////////////////////////////////// | |
| 20437 // other constructors and destructor // | |
| 20438 /////////////////////////////////////// | |
| 20439 | |
| 20440 template<typename JsonRef, | |
| 20441 detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>, | |
| 20442 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 > | |
| 20443 basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {} | |
| 20444 | |
| 20445 /// @brief copy constructor | |
| 20446 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20447 basic_json(const basic_json& other) | |
| 20448 : json_base_class_t(other) | |
| 20449 { | |
| 20450 m_data.m_type = other.m_data.m_type; | |
| 20451 // check of passed value is valid | |
| 20452 other.assert_invariant(); | |
| 20453 | |
| 20454 switch (m_data.m_type) | |
| 20455 { | |
| 20456 case value_t::object: | |
| 20457 { | |
| 20458 m_data.m_value = *other.m_data.m_value.object; | |
| 20459 break; | |
| 20460 } | |
| 20461 | |
| 20462 case value_t::array: | |
| 20463 { | |
| 20464 m_data.m_value = *other.m_data.m_value.array; | |
| 20465 break; | |
| 20466 } | |
| 20467 | |
| 20468 case value_t::string: | |
| 20469 { | |
| 20470 m_data.m_value = *other.m_data.m_value.string; | |
| 20471 break; | |
| 20472 } | |
| 20473 | |
| 20474 case value_t::boolean: | |
| 20475 { | |
| 20476 m_data.m_value = other.m_data.m_value.boolean; | |
| 20477 break; | |
| 20478 } | |
| 20479 | |
| 20480 case value_t::number_integer: | |
| 20481 { | |
| 20482 m_data.m_value = other.m_data.m_value.number_integer; | |
| 20483 break; | |
| 20484 } | |
| 20485 | |
| 20486 case value_t::number_unsigned: | |
| 20487 { | |
| 20488 m_data.m_value = other.m_data.m_value.number_unsigned; | |
| 20489 break; | |
| 20490 } | |
| 20491 | |
| 20492 case value_t::number_float: | |
| 20493 { | |
| 20494 m_data.m_value = other.m_data.m_value.number_float; | |
| 20495 break; | |
| 20496 } | |
| 20497 | |
| 20498 case value_t::binary: | |
| 20499 { | |
| 20500 m_data.m_value = *other.m_data.m_value.binary; | |
| 20501 break; | |
| 20502 } | |
| 20503 | |
| 20504 case value_t::null: | |
| 20505 case value_t::discarded: | |
| 20506 default: | |
| 20507 break; | |
| 20508 } | |
| 20509 | |
| 20510 set_parents(); | |
| 20511 assert_invariant(); | |
| 20512 } | |
| 20513 | |
| 20514 /// @brief move constructor | |
| 20515 /// @sa https://json.nlohmann.me/api/basic_json/basic_json/ | |
| 20516 basic_json(basic_json&& other) noexcept | |
| 20517 : json_base_class_t(std::forward<json_base_class_t>(other)), | |
| 20518 m_data(std::move(other.m_data)) | |
| 20519 { | |
| 20520 // check that passed value is valid | |
| 20521 other.assert_invariant(false); | |
| 20522 | |
| 20523 // invalidate payload | |
| 20524 other.m_data.m_type = value_t::null; | |
| 20525 other.m_data.m_value = {}; | |
| 20526 | |
| 20527 set_parents(); | |
| 20528 assert_invariant(); | |
| 20529 } | |
| 20530 | |
| 20531 /// @brief copy assignment | |
| 20532 /// @sa https://json.nlohmann.me/api/basic_json/operator=/ | |
| 20533 basic_json& operator=(basic_json other) noexcept ( | |
| 20534 std::is_nothrow_move_constructible<value_t>::value&& | |
| 20535 std::is_nothrow_move_assignable<value_t>::value&& | |
| 20536 std::is_nothrow_move_constructible<json_value>::value&& | |
| 20537 std::is_nothrow_move_assignable<json_value>::value&& | |
| 20538 std::is_nothrow_move_assignable<json_base_class_t>::value | |
| 20539 ) | |
| 20540 { | |
| 20541 // check that passed value is valid | |
| 20542 other.assert_invariant(); | |
| 20543 | |
| 20544 using std::swap; | |
| 20545 swap(m_data.m_type, other.m_data.m_type); | |
| 20546 swap(m_data.m_value, other.m_data.m_value); | |
| 20547 json_base_class_t::operator=(std::move(other)); | |
| 20548 | |
| 20549 set_parents(); | |
| 20550 assert_invariant(); | |
| 20551 return *this; | |
| 20552 } | |
| 20553 | |
| 20554 /// @brief destructor | |
| 20555 /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/ | |
| 20556 ~basic_json() noexcept | |
| 20557 { | |
| 20558 assert_invariant(false); | |
| 20559 } | |
| 20560 | |
| 20561 /// @} | |
| 20562 | |
| 20563 public: | |
| 20564 /////////////////////// | |
| 20565 // object inspection // | |
| 20566 /////////////////////// | |
| 20567 | |
| 20568 /// @name object inspection | |
| 20569 /// Functions to inspect the type of a JSON value. | |
| 20570 /// @{ | |
| 20571 | |
| 20572 /// @brief serialization | |
| 20573 /// @sa https://json.nlohmann.me/api/basic_json/dump/ | |
| 20574 string_t dump(const int indent = -1, | |
| 20575 const char indent_char = ' ', | |
| 20576 const bool ensure_ascii = false, | |
| 20577 const error_handler_t error_handler = error_handler_t::strict) const | |
| 20578 { | |
| 20579 string_t result; | |
| 20580 serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler); | |
| 20581 | |
| 20582 if (indent >= 0) | |
| 20583 { | |
| 20584 s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent)); | |
| 20585 } | |
| 20586 else | |
| 20587 { | |
| 20588 s.dump(*this, false, ensure_ascii, 0); | |
| 20589 } | |
| 20590 | |
| 20591 return result; | |
| 20592 } | |
| 20593 | |
| 20594 /// @brief return the type of the JSON value (explicit) | |
| 20595 /// @sa https://json.nlohmann.me/api/basic_json/type/ | |
| 20596 constexpr value_t type() const noexcept | |
| 20597 { | |
| 20598 return m_data.m_type; | |
| 20599 } | |
| 20600 | |
| 20601 /// @brief return whether type is primitive | |
| 20602 /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/ | |
| 20603 constexpr bool is_primitive() const noexcept | |
| 20604 { | |
| 20605 return is_null() || is_string() || is_boolean() || is_number() || is_binary(); | |
| 20606 } | |
| 20607 | |
| 20608 /// @brief return whether type is structured | |
| 20609 /// @sa https://json.nlohmann.me/api/basic_json/is_structured/ | |
| 20610 constexpr bool is_structured() const noexcept | |
| 20611 { | |
| 20612 return is_array() || is_object(); | |
| 20613 } | |
| 20614 | |
| 20615 /// @brief return whether value is null | |
| 20616 /// @sa https://json.nlohmann.me/api/basic_json/is_null/ | |
| 20617 constexpr bool is_null() const noexcept | |
| 20618 { | |
| 20619 return m_data.m_type == value_t::null; | |
| 20620 } | |
| 20621 | |
| 20622 /// @brief return whether value is a boolean | |
| 20623 /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/ | |
| 20624 constexpr bool is_boolean() const noexcept | |
| 20625 { | |
| 20626 return m_data.m_type == value_t::boolean; | |
| 20627 } | |
| 20628 | |
| 20629 /// @brief return whether value is a number | |
| 20630 /// @sa https://json.nlohmann.me/api/basic_json/is_number/ | |
| 20631 constexpr bool is_number() const noexcept | |
| 20632 { | |
| 20633 return is_number_integer() || is_number_float(); | |
| 20634 } | |
| 20635 | |
| 20636 /// @brief return whether value is an integer number | |
| 20637 /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/ | |
| 20638 constexpr bool is_number_integer() const noexcept | |
| 20639 { | |
| 20640 return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned; | |
| 20641 } | |
| 20642 | |
| 20643 /// @brief return whether value is an unsigned integer number | |
| 20644 /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/ | |
| 20645 constexpr bool is_number_unsigned() const noexcept | |
| 20646 { | |
| 20647 return m_data.m_type == value_t::number_unsigned; | |
| 20648 } | |
| 20649 | |
| 20650 /// @brief return whether value is a floating-point number | |
| 20651 /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/ | |
| 20652 constexpr bool is_number_float() const noexcept | |
| 20653 { | |
| 20654 return m_data.m_type == value_t::number_float; | |
| 20655 } | |
| 20656 | |
| 20657 /// @brief return whether value is an object | |
| 20658 /// @sa https://json.nlohmann.me/api/basic_json/is_object/ | |
| 20659 constexpr bool is_object() const noexcept | |
| 20660 { | |
| 20661 return m_data.m_type == value_t::object; | |
| 20662 } | |
| 20663 | |
| 20664 /// @brief return whether value is an array | |
| 20665 /// @sa https://json.nlohmann.me/api/basic_json/is_array/ | |
| 20666 constexpr bool is_array() const noexcept | |
| 20667 { | |
| 20668 return m_data.m_type == value_t::array; | |
| 20669 } | |
| 20670 | |
| 20671 /// @brief return whether value is a string | |
| 20672 /// @sa https://json.nlohmann.me/api/basic_json/is_string/ | |
| 20673 constexpr bool is_string() const noexcept | |
| 20674 { | |
| 20675 return m_data.m_type == value_t::string; | |
| 20676 } | |
| 20677 | |
| 20678 /// @brief return whether value is a binary array | |
| 20679 /// @sa https://json.nlohmann.me/api/basic_json/is_binary/ | |
| 20680 constexpr bool is_binary() const noexcept | |
| 20681 { | |
| 20682 return m_data.m_type == value_t::binary; | |
| 20683 } | |
| 20684 | |
| 20685 /// @brief return whether value is discarded | |
| 20686 /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/ | |
| 20687 constexpr bool is_discarded() const noexcept | |
| 20688 { | |
| 20689 return m_data.m_type == value_t::discarded; | |
| 20690 } | |
| 20691 | |
| 20692 /// @brief return the type of the JSON value (implicit) | |
| 20693 /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/ | |
| 20694 constexpr operator value_t() const noexcept | |
| 20695 { | |
| 20696 return m_data.m_type; | |
| 20697 } | |
| 20698 | |
| 20699 /// @} | |
| 20700 | |
| 20701 private: | |
| 20702 ////////////////// | |
| 20703 // value access // | |
| 20704 ////////////////// | |
| 20705 | |
| 20706 /// get a boolean (explicit) | |
| 20707 boolean_t get_impl(boolean_t* /*unused*/) const | |
| 20708 { | |
| 20709 if (JSON_HEDLEY_LIKELY(is_boolean())) | |
| 20710 { | |
| 20711 return m_data.m_value.boolean; | |
| 20712 } | |
| 20713 | |
| 20714 JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this)); | |
| 20715 } | |
| 20716 | |
| 20717 /// get a pointer to the value (object) | |
| 20718 object_t* get_impl_ptr(object_t* /*unused*/) noexcept | |
| 20719 { | |
| 20720 return is_object() ? m_data.m_value.object : nullptr; | |
| 20721 } | |
| 20722 | |
| 20723 /// get a pointer to the value (object) | |
| 20724 constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept | |
| 20725 { | |
| 20726 return is_object() ? m_data.m_value.object : nullptr; | |
| 20727 } | |
| 20728 | |
| 20729 /// get a pointer to the value (array) | |
| 20730 array_t* get_impl_ptr(array_t* /*unused*/) noexcept | |
| 20731 { | |
| 20732 return is_array() ? m_data.m_value.array : nullptr; | |
| 20733 } | |
| 20734 | |
| 20735 /// get a pointer to the value (array) | |
| 20736 constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept | |
| 20737 { | |
| 20738 return is_array() ? m_data.m_value.array : nullptr; | |
| 20739 } | |
| 20740 | |
| 20741 /// get a pointer to the value (string) | |
| 20742 string_t* get_impl_ptr(string_t* /*unused*/) noexcept | |
| 20743 { | |
| 20744 return is_string() ? m_data.m_value.string : nullptr; | |
| 20745 } | |
| 20746 | |
| 20747 /// get a pointer to the value (string) | |
| 20748 constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept | |
| 20749 { | |
| 20750 return is_string() ? m_data.m_value.string : nullptr; | |
| 20751 } | |
| 20752 | |
| 20753 /// get a pointer to the value (boolean) | |
| 20754 boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept | |
| 20755 { | |
| 20756 return is_boolean() ? &m_data.m_value.boolean : nullptr; | |
| 20757 } | |
| 20758 | |
| 20759 /// get a pointer to the value (boolean) | |
| 20760 constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept | |
| 20761 { | |
| 20762 return is_boolean() ? &m_data.m_value.boolean : nullptr; | |
| 20763 } | |
| 20764 | |
| 20765 /// get a pointer to the value (integer number) | |
| 20766 number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept | |
| 20767 { | |
| 20768 return is_number_integer() ? &m_data.m_value.number_integer : nullptr; | |
| 20769 } | |
| 20770 | |
| 20771 /// get a pointer to the value (integer number) | |
| 20772 constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept | |
| 20773 { | |
| 20774 return is_number_integer() ? &m_data.m_value.number_integer : nullptr; | |
| 20775 } | |
| 20776 | |
| 20777 /// get a pointer to the value (unsigned number) | |
| 20778 number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept | |
| 20779 { | |
| 20780 return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr; | |
| 20781 } | |
| 20782 | |
| 20783 /// get a pointer to the value (unsigned number) | |
| 20784 constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept | |
| 20785 { | |
| 20786 return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr; | |
| 20787 } | |
| 20788 | |
| 20789 /// get a pointer to the value (floating-point number) | |
| 20790 number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept | |
| 20791 { | |
| 20792 return is_number_float() ? &m_data.m_value.number_float : nullptr; | |
| 20793 } | |
| 20794 | |
| 20795 /// get a pointer to the value (floating-point number) | |
| 20796 constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept | |
| 20797 { | |
| 20798 return is_number_float() ? &m_data.m_value.number_float : nullptr; | |
| 20799 } | |
| 20800 | |
| 20801 /// get a pointer to the value (binary) | |
| 20802 binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept | |
| 20803 { | |
| 20804 return is_binary() ? m_data.m_value.binary : nullptr; | |
| 20805 } | |
| 20806 | |
| 20807 /// get a pointer to the value (binary) | |
| 20808 constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept | |
| 20809 { | |
| 20810 return is_binary() ? m_data.m_value.binary : nullptr; | |
| 20811 } | |
| 20812 | |
| 20813 /*! | |
| 20814 @brief helper function to implement get_ref() | |
| 20815 | |
| 20816 This function helps to implement get_ref() without code duplication for | |
| 20817 const and non-const overloads | |
| 20818 | |
| 20819 @tparam ThisType will be deduced as `basic_json` or `const basic_json` | |
| 20820 | |
| 20821 @throw type_error.303 if ReferenceType does not match underlying value | |
| 20822 type of the current JSON | |
| 20823 */ | |
| 20824 template<typename ReferenceType, typename ThisType> | |
| 20825 static ReferenceType get_ref_impl(ThisType& obj) | |
| 20826 { | |
| 20827 // delegate the call to get_ptr<>() | |
| 20828 auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>(); | |
| 20829 | |
| 20830 if (JSON_HEDLEY_LIKELY(ptr != nullptr)) | |
| 20831 { | |
| 20832 return *ptr; | |
| 20833 } | |
| 20834 | |
| 20835 JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj)); | |
| 20836 } | |
| 20837 | |
| 20838 public: | |
| 20839 /// @name value access | |
| 20840 /// Direct access to the stored value of a JSON value. | |
| 20841 /// @{ | |
| 20842 | |
| 20843 /// @brief get a pointer value (implicit) | |
| 20844 /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/ | |
| 20845 template<typename PointerType, typename std::enable_if< | |
| 20846 std::is_pointer<PointerType>::value, int>::type = 0> | |
| 20847 auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>())) | |
| 20848 { | |
| 20849 // delegate the call to get_impl_ptr<>() | |
| 20850 return get_impl_ptr(static_cast<PointerType>(nullptr)); | |
| 20851 } | |
| 20852 | |
| 20853 /// @brief get a pointer value (implicit) | |
| 20854 /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/ | |
| 20855 template < typename PointerType, typename std::enable_if < | |
| 20856 std::is_pointer<PointerType>::value&& | |
| 20857 std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 > | |
| 20858 constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>())) | |
| 20859 { | |
| 20860 // delegate the call to get_impl_ptr<>() const | |
| 20861 return get_impl_ptr(static_cast<PointerType>(nullptr)); | |
| 20862 } | |
| 20863 | |
| 20864 private: | |
| 20865 /*! | |
| 20866 @brief get a value (explicit) | |
| 20867 | |
| 20868 Explicit type conversion between the JSON value and a compatible value | |
| 20869 which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible) | |
| 20870 and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible). | |
| 20871 The value is converted by calling the @ref json_serializer<ValueType> | |
| 20872 `from_json()` method. | |
| 20873 | |
| 20874 The function is equivalent to executing | |
| 20875 @code {.cpp} | |
| 20876 ValueType ret; | |
| 20877 JSONSerializer<ValueType>::from_json(*this, ret); | |
| 20878 return ret; | |
| 20879 @endcode | |
| 20880 | |
| 20881 This overloads is chosen if: | |
| 20882 - @a ValueType is not @ref basic_json, | |
| 20883 - @ref json_serializer<ValueType> has a `from_json()` method of the form | |
| 20884 `void from_json(const basic_json&, ValueType&)`, and | |
| 20885 - @ref json_serializer<ValueType> does not have a `from_json()` method of | |
| 20886 the form `ValueType from_json(const basic_json&)` | |
| 20887 | |
| 20888 @tparam ValueType the returned value type | |
| 20889 | |
| 20890 @return copy of the JSON value, converted to @a ValueType | |
| 20891 | |
| 20892 @throw what @ref json_serializer<ValueType> `from_json()` method throws | |
| 20893 | |
| 20894 @liveexample{The example below shows several conversions from JSON values | |
| 20895 to other types. There a few things to note: (1) Floating-point numbers can | |
| 20896 be converted to integers\, (2) A JSON array can be converted to a standard | |
| 20897 `std::vector<short>`\, (3) A JSON object can be converted to C++ | |
| 20898 associative containers such as `std::unordered_map<std::string\, | |
| 20899 json>`.,get__ValueType_const} | |
| 20900 | |
| 20901 @since version 2.1.0 | |
| 20902 */ | |
| 20903 template < typename ValueType, | |
| 20904 detail::enable_if_t < | |
| 20905 detail::is_default_constructible<ValueType>::value&& | |
| 20906 detail::has_from_json<basic_json_t, ValueType>::value, | |
| 20907 int > = 0 > | |
| 20908 ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept( | |
| 20909 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>()))) | |
| 20910 { | |
| 20911 auto ret = ValueType(); | |
| 20912 JSONSerializer<ValueType>::from_json(*this, ret); | |
| 20913 return ret; | |
| 20914 } | |
| 20915 | |
| 20916 /*! | |
| 20917 @brief get a value (explicit); special case | |
| 20918 | |
| 20919 Explicit type conversion between the JSON value and a compatible value | |
| 20920 which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible) | |
| 20921 and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible). | |
| 20922 The value is converted by calling the @ref json_serializer<ValueType> | |
| 20923 `from_json()` method. | |
| 20924 | |
| 20925 The function is equivalent to executing | |
| 20926 @code {.cpp} | |
| 20927 return JSONSerializer<ValueType>::from_json(*this); | |
| 20928 @endcode | |
| 20929 | |
| 20930 This overloads is chosen if: | |
| 20931 - @a ValueType is not @ref basic_json and | |
| 20932 - @ref json_serializer<ValueType> has a `from_json()` method of the form | |
| 20933 `ValueType from_json(const basic_json&)` | |
| 20934 | |
| 20935 @note If @ref json_serializer<ValueType> has both overloads of | |
| 20936 `from_json()`, this one is chosen. | |
| 20937 | |
| 20938 @tparam ValueType the returned value type | |
| 20939 | |
| 20940 @return copy of the JSON value, converted to @a ValueType | |
| 20941 | |
| 20942 @throw what @ref json_serializer<ValueType> `from_json()` method throws | |
| 20943 | |
| 20944 @since version 2.1.0 | |
| 20945 */ | |
| 20946 template < typename ValueType, | |
| 20947 detail::enable_if_t < | |
| 20948 detail::has_non_default_from_json<basic_json_t, ValueType>::value, | |
| 20949 int > = 0 > | |
| 20950 ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept( | |
| 20951 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>()))) | |
| 20952 { | |
| 20953 return JSONSerializer<ValueType>::from_json(*this); | |
| 20954 } | |
| 20955 | |
| 20956 /*! | |
| 20957 @brief get special-case overload | |
| 20958 | |
| 20959 This overloads converts the current @ref basic_json in a different | |
| 20960 @ref basic_json type | |
| 20961 | |
| 20962 @tparam BasicJsonType == @ref basic_json | |
| 20963 | |
| 20964 @return a copy of *this, converted into @a BasicJsonType | |
| 20965 | |
| 20966 @complexity Depending on the implementation of the called `from_json()` | |
| 20967 method. | |
| 20968 | |
| 20969 @since version 3.2.0 | |
| 20970 */ | |
| 20971 template < typename BasicJsonType, | |
| 20972 detail::enable_if_t < | |
| 20973 detail::is_basic_json<BasicJsonType>::value, | |
| 20974 int > = 0 > | |
| 20975 BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const | |
| 20976 { | |
| 20977 return *this; | |
| 20978 } | |
| 20979 | |
| 20980 /*! | |
| 20981 @brief get special-case overload | |
| 20982 | |
| 20983 This overloads avoids a lot of template boilerplate, it can be seen as the | |
| 20984 identity method | |
| 20985 | |
| 20986 @tparam BasicJsonType == @ref basic_json | |
| 20987 | |
| 20988 @return a copy of *this | |
| 20989 | |
| 20990 @complexity Constant. | |
| 20991 | |
| 20992 @since version 2.1.0 | |
| 20993 */ | |
| 20994 template<typename BasicJsonType, | |
| 20995 detail::enable_if_t< | |
| 20996 std::is_same<BasicJsonType, basic_json_t>::value, | |
| 20997 int> = 0> | |
| 20998 basic_json get_impl(detail::priority_tag<3> /*unused*/) const | |
| 20999 { | |
| 21000 return *this; | |
| 21001 } | |
| 21002 | |
| 21003 /*! | |
| 21004 @brief get a pointer value (explicit) | |
| 21005 @copydoc get() | |
| 21006 */ | |
| 21007 template<typename PointerType, | |
| 21008 detail::enable_if_t< | |
| 21009 std::is_pointer<PointerType>::value, | |
| 21010 int> = 0> | |
| 21011 constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept | |
| 21012 -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>()) | |
| 21013 { | |
| 21014 // delegate the call to get_ptr | |
| 21015 return get_ptr<PointerType>(); | |
| 21016 } | |
| 21017 | |
| 21018 public: | |
| 21019 /*! | |
| 21020 @brief get a (pointer) value (explicit) | |
| 21021 | |
| 21022 Performs explicit type conversion between the JSON value and a compatible value if required. | |
| 21023 | |
| 21024 - If the requested type is a pointer to the internally stored JSON value that pointer is returned. | |
| 21025 No copies are made. | |
| 21026 | |
| 21027 - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible | |
| 21028 from the current @ref basic_json. | |
| 21029 | |
| 21030 - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()` | |
| 21031 method. | |
| 21032 | |
| 21033 @tparam ValueTypeCV the provided value type | |
| 21034 @tparam ValueType the returned value type | |
| 21035 | |
| 21036 @return copy of the JSON value, converted to @tparam ValueType if necessary | |
| 21037 | |
| 21038 @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required | |
| 21039 | |
| 21040 @since version 2.1.0 | |
| 21041 */ | |
| 21042 template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>> | |
| 21043 #if defined(JSON_HAS_CPP_14) | |
| 21044 constexpr | |
| 21045 #endif | |
| 21046 auto get() const noexcept( | |
| 21047 noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))) | |
| 21048 -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})) | |
| 21049 { | |
| 21050 // we cannot static_assert on ValueTypeCV being non-const, because | |
| 21051 // there is support for get<const basic_json_t>(), which is why we | |
| 21052 // still need the uncvref | |
| 21053 static_assert(!std::is_reference<ValueTypeCV>::value, | |
| 21054 "get() cannot be used with reference types, you might want to use get_ref()"); | |
| 21055 return get_impl<ValueType>(detail::priority_tag<4> {}); | |
| 21056 } | |
| 21057 | |
| 21058 /*! | |
| 21059 @brief get a pointer value (explicit) | |
| 21060 | |
| 21061 Explicit pointer access to the internally stored JSON value. No copies are | |
| 21062 made. | |
| 21063 | |
| 21064 @warning The pointer becomes invalid if the underlying JSON object | |
| 21065 changes. | |
| 21066 | |
| 21067 @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref | |
| 21068 object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, | |
| 21069 @ref number_unsigned_t, or @ref number_float_t. | |
| 21070 | |
| 21071 @return pointer to the internally stored JSON value if the requested | |
| 21072 pointer type @a PointerType fits to the JSON value; `nullptr` otherwise | |
| 21073 | |
| 21074 @complexity Constant. | |
| 21075 | |
| 21076 @liveexample{The example below shows how pointers to internal values of a | |
| 21077 JSON value can be requested. Note that no type conversions are made and a | |
| 21078 `nullptr` is returned if the value and the requested pointer type does not | |
| 21079 match.,get__PointerType} | |
| 21080 | |
| 21081 @sa see @ref get_ptr() for explicit pointer-member access | |
| 21082 | |
| 21083 @since version 1.0.0 | |
| 21084 */ | |
| 21085 template<typename PointerType, typename std::enable_if< | |
| 21086 std::is_pointer<PointerType>::value, int>::type = 0> | |
| 21087 auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>()) | |
| 21088 { | |
| 21089 // delegate the call to get_ptr | |
| 21090 return get_ptr<PointerType>(); | |
| 21091 } | |
| 21092 | |
| 21093 /// @brief get a value (explicit) | |
| 21094 /// @sa https://json.nlohmann.me/api/basic_json/get_to/ | |
| 21095 template < typename ValueType, | |
| 21096 detail::enable_if_t < | |
| 21097 !detail::is_basic_json<ValueType>::value&& | |
| 21098 detail::has_from_json<basic_json_t, ValueType>::value, | |
| 21099 int > = 0 > | |
| 21100 ValueType & get_to(ValueType& v) const noexcept(noexcept( | |
| 21101 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v))) | |
| 21102 { | |
| 21103 JSONSerializer<ValueType>::from_json(*this, v); | |
| 21104 return v; | |
| 21105 } | |
| 21106 | |
| 21107 // specialization to allow calling get_to with a basic_json value | |
| 21108 // see https://github.com/nlohmann/json/issues/2175 | |
| 21109 template<typename ValueType, | |
| 21110 detail::enable_if_t < | |
| 21111 detail::is_basic_json<ValueType>::value, | |
| 21112 int> = 0> | |
| 21113 ValueType & get_to(ValueType& v) const | |
| 21114 { | |
| 21115 v = *this; | |
| 21116 return v; | |
| 21117 } | |
| 21118 | |
| 21119 template < | |
| 21120 typename T, std::size_t N, | |
| 21121 typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) | |
| 21122 detail::enable_if_t < | |
| 21123 detail::has_from_json<basic_json_t, Array>::value, int > = 0 > | |
| 21124 Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) | |
| 21125 noexcept(noexcept(JSONSerializer<Array>::from_json( | |
| 21126 std::declval<const basic_json_t&>(), v))) | |
| 21127 { | |
| 21128 JSONSerializer<Array>::from_json(*this, v); | |
| 21129 return v; | |
| 21130 } | |
| 21131 | |
| 21132 /// @brief get a reference value (implicit) | |
| 21133 /// @sa https://json.nlohmann.me/api/basic_json/get_ref/ | |
| 21134 template<typename ReferenceType, typename std::enable_if< | |
| 21135 std::is_reference<ReferenceType>::value, int>::type = 0> | |
| 21136 ReferenceType get_ref() | |
| 21137 { | |
| 21138 // delegate call to get_ref_impl | |
| 21139 return get_ref_impl<ReferenceType>(*this); | |
| 21140 } | |
| 21141 | |
| 21142 /// @brief get a reference value (implicit) | |
| 21143 /// @sa https://json.nlohmann.me/api/basic_json/get_ref/ | |
| 21144 template < typename ReferenceType, typename std::enable_if < | |
| 21145 std::is_reference<ReferenceType>::value&& | |
| 21146 std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 > | |
| 21147 ReferenceType get_ref() const | |
| 21148 { | |
| 21149 // delegate call to get_ref_impl | |
| 21150 return get_ref_impl<ReferenceType>(*this); | |
| 21151 } | |
| 21152 | |
| 21153 /*! | |
| 21154 @brief get a value (implicit) | |
| 21155 | |
| 21156 Implicit type conversion between the JSON value and a compatible value. | |
| 21157 The call is realized by calling @ref get() const. | |
| 21158 | |
| 21159 @tparam ValueType non-pointer type compatible to the JSON value, for | |
| 21160 instance `int` for JSON integer numbers, `bool` for JSON booleans, or | |
| 21161 `std::vector` types for JSON arrays. The character type of @ref string_t | |
| 21162 as well as an initializer list of this type is excluded to avoid | |
| 21163 ambiguities as these types implicitly convert to `std::string`. | |
| 21164 | |
| 21165 @return copy of the JSON value, converted to type @a ValueType | |
| 21166 | |
| 21167 @throw type_error.302 in case passed type @a ValueType is incompatible | |
| 21168 to the JSON value type (e.g., the JSON value is of type boolean, but a | |
| 21169 string is requested); see example below | |
| 21170 | |
| 21171 @complexity Linear in the size of the JSON value. | |
| 21172 | |
| 21173 @liveexample{The example below shows several conversions from JSON values | |
| 21174 to other types. There a few things to note: (1) Floating-point numbers can | |
| 21175 be converted to integers\, (2) A JSON array can be converted to a standard | |
| 21176 `std::vector<short>`\, (3) A JSON object can be converted to C++ | |
| 21177 associative containers such as `std::unordered_map<std::string\, | |
| 21178 json>`.,operator__ValueType} | |
| 21179 | |
| 21180 @since version 1.0.0 | |
| 21181 */ | |
| 21182 template < typename ValueType, typename std::enable_if < | |
| 21183 detail::conjunction < | |
| 21184 detail::negation<std::is_pointer<ValueType>>, | |
| 21185 detail::negation<std::is_same<ValueType, std::nullptr_t>>, | |
| 21186 detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>, | |
| 21187 detail::negation<std::is_same<ValueType, typename string_t::value_type>>, | |
| 21188 detail::negation<detail::is_basic_json<ValueType>>, | |
| 21189 detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>, | |
| 21190 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914)) | |
| 21191 detail::negation<std::is_same<ValueType, std::string_view>>, | |
| 21192 #endif | |
| 21193 #if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI | |
| 21194 detail::negation<std::is_same<ValueType, std::any>>, | |
| 21195 #endif | |
| 21196 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType> | |
| 21197 >::value, int >::type = 0 > | |
| 21198 JSON_EXPLICIT operator ValueType() const | |
| 21199 { | |
| 21200 // delegate the call to get<>() const | |
| 21201 return get<ValueType>(); | |
| 21202 } | |
| 21203 | |
| 21204 /// @brief get a binary value | |
| 21205 /// @sa https://json.nlohmann.me/api/basic_json/get_binary/ | |
| 21206 binary_t& get_binary() | |
| 21207 { | |
| 21208 if (!is_binary()) | |
| 21209 { | |
| 21210 JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this)); | |
| 21211 } | |
| 21212 | |
| 21213 return *get_ptr<binary_t*>(); | |
| 21214 } | |
| 21215 | |
| 21216 /// @brief get a binary value | |
| 21217 /// @sa https://json.nlohmann.me/api/basic_json/get_binary/ | |
| 21218 const binary_t& get_binary() const | |
| 21219 { | |
| 21220 if (!is_binary()) | |
| 21221 { | |
| 21222 JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this)); | |
| 21223 } | |
| 21224 | |
| 21225 return *get_ptr<const binary_t*>(); | |
| 21226 } | |
| 21227 | |
| 21228 /// @} | |
| 21229 | |
| 21230 //////////////////// | |
| 21231 // element access // | |
| 21232 //////////////////// | |
| 21233 | |
| 21234 /// @name element access | |
| 21235 /// Access to the JSON value. | |
| 21236 /// @{ | |
| 21237 | |
| 21238 /// @brief access specified array element with bounds checking | |
| 21239 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 21240 reference at(size_type idx) | |
| 21241 { | |
| 21242 // at only works for arrays | |
| 21243 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 21244 { | |
| 21245 JSON_TRY | |
| 21246 { | |
| 21247 return set_parent(m_data.m_value.array->at(idx)); | |
| 21248 } | |
| 21249 JSON_CATCH (std::out_of_range&) | |
| 21250 { | |
| 21251 // create better exception explanation | |
| 21252 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this)); | |
| 21253 } | |
| 21254 } | |
| 21255 else | |
| 21256 { | |
| 21257 JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this)); | |
| 21258 } | |
| 21259 } | |
| 21260 | |
| 21261 /// @brief access specified array element with bounds checking | |
| 21262 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 21263 const_reference at(size_type idx) const | |
| 21264 { | |
| 21265 // at only works for arrays | |
| 21266 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 21267 { | |
| 21268 JSON_TRY | |
| 21269 { | |
| 21270 return m_data.m_value.array->at(idx); | |
| 21271 } | |
| 21272 JSON_CATCH (std::out_of_range&) | |
| 21273 { | |
| 21274 // create better exception explanation | |
| 21275 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this)); | |
| 21276 } | |
| 21277 } | |
| 21278 else | |
| 21279 { | |
| 21280 JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this)); | |
| 21281 } | |
| 21282 } | |
| 21283 | |
| 21284 /// @brief access specified object element with bounds checking | |
| 21285 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 21286 reference at(const typename object_t::key_type& key) | |
| 21287 { | |
| 21288 // at only works for objects | |
| 21289 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 21290 { | |
| 21291 JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this)); | |
| 21292 } | |
| 21293 | |
| 21294 auto it = m_data.m_value.object->find(key); | |
| 21295 if (it == m_data.m_value.object->end()) | |
| 21296 { | |
| 21297 JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this)); | |
| 21298 } | |
| 21299 return set_parent(it->second); | |
| 21300 } | |
| 21301 | |
| 21302 /// @brief access specified object element with bounds checking | |
| 21303 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 21304 template<class KeyType, detail::enable_if_t< | |
| 21305 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 21306 reference at(KeyType && key) | |
| 21307 { | |
| 21308 // at only works for objects | |
| 21309 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 21310 { | |
| 21311 JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this)); | |
| 21312 } | |
| 21313 | |
| 21314 auto it = m_data.m_value.object->find(std::forward<KeyType>(key)); | |
| 21315 if (it == m_data.m_value.object->end()) | |
| 21316 { | |
| 21317 JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this)); | |
| 21318 } | |
| 21319 return set_parent(it->second); | |
| 21320 } | |
| 21321 | |
| 21322 /// @brief access specified object element with bounds checking | |
| 21323 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 21324 const_reference at(const typename object_t::key_type& key) const | |
| 21325 { | |
| 21326 // at only works for objects | |
| 21327 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 21328 { | |
| 21329 JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this)); | |
| 21330 } | |
| 21331 | |
| 21332 auto it = m_data.m_value.object->find(key); | |
| 21333 if (it == m_data.m_value.object->end()) | |
| 21334 { | |
| 21335 JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this)); | |
| 21336 } | |
| 21337 return it->second; | |
| 21338 } | |
| 21339 | |
| 21340 /// @brief access specified object element with bounds checking | |
| 21341 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 21342 template<class KeyType, detail::enable_if_t< | |
| 21343 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 21344 const_reference at(KeyType && key) const | |
| 21345 { | |
| 21346 // at only works for objects | |
| 21347 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 21348 { | |
| 21349 JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this)); | |
| 21350 } | |
| 21351 | |
| 21352 auto it = m_data.m_value.object->find(std::forward<KeyType>(key)); | |
| 21353 if (it == m_data.m_value.object->end()) | |
| 21354 { | |
| 21355 JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this)); | |
| 21356 } | |
| 21357 return it->second; | |
| 21358 } | |
| 21359 | |
| 21360 /// @brief access specified array element | |
| 21361 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 21362 reference operator[](size_type idx) | |
| 21363 { | |
| 21364 // implicitly convert null value to an empty array | |
| 21365 if (is_null()) | |
| 21366 { | |
| 21367 m_data.m_type = value_t::array; | |
| 21368 m_data.m_value.array = create<array_t>(); | |
| 21369 assert_invariant(); | |
| 21370 } | |
| 21371 | |
| 21372 // operator[] only works for arrays | |
| 21373 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 21374 { | |
| 21375 // fill up array with null values if given idx is outside range | |
| 21376 if (idx >= m_data.m_value.array->size()) | |
| 21377 { | |
| 21378 #if JSON_DIAGNOSTICS | |
| 21379 // remember array size & capacity before resizing | |
| 21380 const auto old_size = m_data.m_value.array->size(); | |
| 21381 const auto old_capacity = m_data.m_value.array->capacity(); | |
| 21382 #endif | |
| 21383 m_data.m_value.array->resize(idx + 1); | |
| 21384 | |
| 21385 #if JSON_DIAGNOSTICS | |
| 21386 if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity)) | |
| 21387 { | |
| 21388 // capacity has changed: update all parents | |
| 21389 set_parents(); | |
| 21390 } | |
| 21391 else | |
| 21392 { | |
| 21393 // set parent for values added above | |
| 21394 set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size)); | |
| 21395 } | |
| 21396 #endif | |
| 21397 assert_invariant(); | |
| 21398 } | |
| 21399 | |
| 21400 return m_data.m_value.array->operator[](idx); | |
| 21401 } | |
| 21402 | |
| 21403 JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this)); | |
| 21404 } | |
| 21405 | |
| 21406 /// @brief access specified array element | |
| 21407 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 21408 const_reference operator[](size_type idx) const | |
| 21409 { | |
| 21410 // const operator[] only works for arrays | |
| 21411 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 21412 { | |
| 21413 return m_data.m_value.array->operator[](idx); | |
| 21414 } | |
| 21415 | |
| 21416 JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this)); | |
| 21417 } | |
| 21418 | |
| 21419 /// @brief access specified object element | |
| 21420 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 21421 reference operator[](typename object_t::key_type key) | |
| 21422 { | |
| 21423 // implicitly convert null value to an empty object | |
| 21424 if (is_null()) | |
| 21425 { | |
| 21426 m_data.m_type = value_t::object; | |
| 21427 m_data.m_value.object = create<object_t>(); | |
| 21428 assert_invariant(); | |
| 21429 } | |
| 21430 | |
| 21431 // operator[] only works for objects | |
| 21432 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21433 { | |
| 21434 auto result = m_data.m_value.object->emplace(std::move(key), nullptr); | |
| 21435 return set_parent(result.first->second); | |
| 21436 } | |
| 21437 | |
| 21438 JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this)); | |
| 21439 } | |
| 21440 | |
| 21441 /// @brief access specified object element | |
| 21442 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 21443 const_reference operator[](const typename object_t::key_type& key) const | |
| 21444 { | |
| 21445 // const operator[] only works for objects | |
| 21446 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21447 { | |
| 21448 auto it = m_data.m_value.object->find(key); | |
| 21449 JSON_ASSERT(it != m_data.m_value.object->end()); | |
| 21450 return it->second; | |
| 21451 } | |
| 21452 | |
| 21453 JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this)); | |
| 21454 } | |
| 21455 | |
| 21456 // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC | |
| 21457 // (they seemingly cannot be constrained to resolve the ambiguity) | |
| 21458 template<typename T> | |
| 21459 reference operator[](T* key) | |
| 21460 { | |
| 21461 return operator[](typename object_t::key_type(key)); | |
| 21462 } | |
| 21463 | |
| 21464 template<typename T> | |
| 21465 const_reference operator[](T* key) const | |
| 21466 { | |
| 21467 return operator[](typename object_t::key_type(key)); | |
| 21468 } | |
| 21469 | |
| 21470 /// @brief access specified object element | |
| 21471 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 21472 template<class KeyType, detail::enable_if_t< | |
| 21473 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 > | |
| 21474 reference operator[](KeyType && key) | |
| 21475 { | |
| 21476 // implicitly convert null value to an empty object | |
| 21477 if (is_null()) | |
| 21478 { | |
| 21479 m_data.m_type = value_t::object; | |
| 21480 m_data.m_value.object = create<object_t>(); | |
| 21481 assert_invariant(); | |
| 21482 } | |
| 21483 | |
| 21484 // operator[] only works for objects | |
| 21485 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21486 { | |
| 21487 auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr); | |
| 21488 return set_parent(result.first->second); | |
| 21489 } | |
| 21490 | |
| 21491 JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this)); | |
| 21492 } | |
| 21493 | |
| 21494 /// @brief access specified object element | |
| 21495 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 21496 template<class KeyType, detail::enable_if_t< | |
| 21497 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 > | |
| 21498 const_reference operator[](KeyType && key) const | |
| 21499 { | |
| 21500 // const operator[] only works for objects | |
| 21501 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21502 { | |
| 21503 auto it = m_data.m_value.object->find(std::forward<KeyType>(key)); | |
| 21504 JSON_ASSERT(it != m_data.m_value.object->end()); | |
| 21505 return it->second; | |
| 21506 } | |
| 21507 | |
| 21508 JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this)); | |
| 21509 } | |
| 21510 | |
| 21511 private: | |
| 21512 template<typename KeyType> | |
| 21513 using is_comparable_with_object_key = detail::is_comparable < | |
| 21514 object_comparator_t, const typename object_t::key_type&, KeyType >; | |
| 21515 | |
| 21516 template<typename ValueType> | |
| 21517 using value_return_type = std::conditional < | |
| 21518 detail::is_c_string_uncvref<ValueType>::value, | |
| 21519 string_t, typename std::decay<ValueType>::type >; | |
| 21520 | |
| 21521 public: | |
| 21522 /// @brief access specified object element with default value | |
| 21523 /// @sa https://json.nlohmann.me/api/basic_json/value/ | |
| 21524 template < class ValueType, detail::enable_if_t < | |
| 21525 !detail::is_transparent<object_comparator_t>::value | |
| 21526 && detail::is_getable<basic_json_t, ValueType>::value | |
| 21527 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21528 ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const | |
| 21529 { | |
| 21530 // value only works for objects | |
| 21531 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21532 { | |
| 21533 // if key is found, return value and given default value otherwise | |
| 21534 const auto it = find(key); | |
| 21535 if (it != end()) | |
| 21536 { | |
| 21537 return it->template get<ValueType>(); | |
| 21538 } | |
| 21539 | |
| 21540 return default_value; | |
| 21541 } | |
| 21542 | |
| 21543 JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this)); | |
| 21544 } | |
| 21545 | |
| 21546 /// @brief access specified object element with default value | |
| 21547 /// @sa https://json.nlohmann.me/api/basic_json/value/ | |
| 21548 template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type, | |
| 21549 detail::enable_if_t < | |
| 21550 !detail::is_transparent<object_comparator_t>::value | |
| 21551 && detail::is_getable<basic_json_t, ReturnType>::value | |
| 21552 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21553 ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const | |
| 21554 { | |
| 21555 // value only works for objects | |
| 21556 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21557 { | |
| 21558 // if key is found, return value and given default value otherwise | |
| 21559 const auto it = find(key); | |
| 21560 if (it != end()) | |
| 21561 { | |
| 21562 return it->template get<ReturnType>(); | |
| 21563 } | |
| 21564 | |
| 21565 return std::forward<ValueType>(default_value); | |
| 21566 } | |
| 21567 | |
| 21568 JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this)); | |
| 21569 } | |
| 21570 | |
| 21571 /// @brief access specified object element with default value | |
| 21572 /// @sa https://json.nlohmann.me/api/basic_json/value/ | |
| 21573 template < class ValueType, class KeyType, detail::enable_if_t < | |
| 21574 detail::is_transparent<object_comparator_t>::value | |
| 21575 && !detail::is_json_pointer<KeyType>::value | |
| 21576 && is_comparable_with_object_key<KeyType>::value | |
| 21577 && detail::is_getable<basic_json_t, ValueType>::value | |
| 21578 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21579 ValueType value(KeyType && key, const ValueType& default_value) const | |
| 21580 { | |
| 21581 // value only works for objects | |
| 21582 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21583 { | |
| 21584 // if key is found, return value and given default value otherwise | |
| 21585 const auto it = find(std::forward<KeyType>(key)); | |
| 21586 if (it != end()) | |
| 21587 { | |
| 21588 return it->template get<ValueType>(); | |
| 21589 } | |
| 21590 | |
| 21591 return default_value; | |
| 21592 } | |
| 21593 | |
| 21594 JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this)); | |
| 21595 } | |
| 21596 | |
| 21597 /// @brief access specified object element via JSON Pointer with default value | |
| 21598 /// @sa https://json.nlohmann.me/api/basic_json/value/ | |
| 21599 template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type, | |
| 21600 detail::enable_if_t < | |
| 21601 detail::is_transparent<object_comparator_t>::value | |
| 21602 && !detail::is_json_pointer<KeyType>::value | |
| 21603 && is_comparable_with_object_key<KeyType>::value | |
| 21604 && detail::is_getable<basic_json_t, ReturnType>::value | |
| 21605 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21606 ReturnType value(KeyType && key, ValueType && default_value) const | |
| 21607 { | |
| 21608 // value only works for objects | |
| 21609 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21610 { | |
| 21611 // if key is found, return value and given default value otherwise | |
| 21612 const auto it = find(std::forward<KeyType>(key)); | |
| 21613 if (it != end()) | |
| 21614 { | |
| 21615 return it->template get<ReturnType>(); | |
| 21616 } | |
| 21617 | |
| 21618 return std::forward<ValueType>(default_value); | |
| 21619 } | |
| 21620 | |
| 21621 JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this)); | |
| 21622 } | |
| 21623 | |
| 21624 /// @brief access specified object element via JSON Pointer with default value | |
| 21625 /// @sa https://json.nlohmann.me/api/basic_json/value/ | |
| 21626 template < class ValueType, detail::enable_if_t < | |
| 21627 detail::is_getable<basic_json_t, ValueType>::value | |
| 21628 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21629 ValueType value(const json_pointer& ptr, const ValueType& default_value) const | |
| 21630 { | |
| 21631 // value only works for objects | |
| 21632 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21633 { | |
| 21634 // if pointer resolves a value, return it or use default value | |
| 21635 JSON_TRY | |
| 21636 { | |
| 21637 return ptr.get_checked(this).template get<ValueType>(); | |
| 21638 } | |
| 21639 JSON_INTERNAL_CATCH (out_of_range&) | |
| 21640 { | |
| 21641 return default_value; | |
| 21642 } | |
| 21643 } | |
| 21644 | |
| 21645 JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this)); | |
| 21646 } | |
| 21647 | |
| 21648 /// @brief access specified object element via JSON Pointer with default value | |
| 21649 /// @sa https://json.nlohmann.me/api/basic_json/value/ | |
| 21650 template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type, | |
| 21651 detail::enable_if_t < | |
| 21652 detail::is_getable<basic_json_t, ReturnType>::value | |
| 21653 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21654 ReturnType value(const json_pointer& ptr, ValueType && default_value) const | |
| 21655 { | |
| 21656 // value only works for objects | |
| 21657 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 21658 { | |
| 21659 // if pointer resolves a value, return it or use default value | |
| 21660 JSON_TRY | |
| 21661 { | |
| 21662 return ptr.get_checked(this).template get<ReturnType>(); | |
| 21663 } | |
| 21664 JSON_INTERNAL_CATCH (out_of_range&) | |
| 21665 { | |
| 21666 return std::forward<ValueType>(default_value); | |
| 21667 } | |
| 21668 } | |
| 21669 | |
| 21670 JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this)); | |
| 21671 } | |
| 21672 | |
| 21673 template < class ValueType, class BasicJsonType, detail::enable_if_t < | |
| 21674 detail::is_basic_json<BasicJsonType>::value | |
| 21675 && detail::is_getable<basic_json_t, ValueType>::value | |
| 21676 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21677 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 21678 ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const | |
| 21679 { | |
| 21680 return value(ptr.convert(), default_value); | |
| 21681 } | |
| 21682 | |
| 21683 template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type, | |
| 21684 detail::enable_if_t < | |
| 21685 detail::is_basic_json<BasicJsonType>::value | |
| 21686 && detail::is_getable<basic_json_t, ReturnType>::value | |
| 21687 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 > | |
| 21688 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 21689 ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const | |
| 21690 { | |
| 21691 return value(ptr.convert(), std::forward<ValueType>(default_value)); | |
| 21692 } | |
| 21693 | |
| 21694 /// @brief access the first element | |
| 21695 /// @sa https://json.nlohmann.me/api/basic_json/front/ | |
| 21696 reference front() | |
| 21697 { | |
| 21698 return *begin(); | |
| 21699 } | |
| 21700 | |
| 21701 /// @brief access the first element | |
| 21702 /// @sa https://json.nlohmann.me/api/basic_json/front/ | |
| 21703 const_reference front() const | |
| 21704 { | |
| 21705 return *cbegin(); | |
| 21706 } | |
| 21707 | |
| 21708 /// @brief access the last element | |
| 21709 /// @sa https://json.nlohmann.me/api/basic_json/back/ | |
| 21710 reference back() | |
| 21711 { | |
| 21712 auto tmp = end(); | |
| 21713 --tmp; | |
| 21714 return *tmp; | |
| 21715 } | |
| 21716 | |
| 21717 /// @brief access the last element | |
| 21718 /// @sa https://json.nlohmann.me/api/basic_json/back/ | |
| 21719 const_reference back() const | |
| 21720 { | |
| 21721 auto tmp = cend(); | |
| 21722 --tmp; | |
| 21723 return *tmp; | |
| 21724 } | |
| 21725 | |
| 21726 /// @brief remove element given an iterator | |
| 21727 /// @sa https://json.nlohmann.me/api/basic_json/erase/ | |
| 21728 template < class IteratorType, detail::enable_if_t < | |
| 21729 std::is_same<IteratorType, typename basic_json_t::iterator>::value || | |
| 21730 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 > | |
| 21731 IteratorType erase(IteratorType pos) | |
| 21732 { | |
| 21733 // make sure iterator fits the current value | |
| 21734 if (JSON_HEDLEY_UNLIKELY(this != pos.m_object)) | |
| 21735 { | |
| 21736 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this)); | |
| 21737 } | |
| 21738 | |
| 21739 IteratorType result = end(); | |
| 21740 | |
| 21741 switch (m_data.m_type) | |
| 21742 { | |
| 21743 case value_t::boolean: | |
| 21744 case value_t::number_float: | |
| 21745 case value_t::number_integer: | |
| 21746 case value_t::number_unsigned: | |
| 21747 case value_t::string: | |
| 21748 case value_t::binary: | |
| 21749 { | |
| 21750 if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin())) | |
| 21751 { | |
| 21752 JSON_THROW(invalid_iterator::create(205, "iterator out of range", this)); | |
| 21753 } | |
| 21754 | |
| 21755 if (is_string()) | |
| 21756 { | |
| 21757 AllocatorType<string_t> alloc; | |
| 21758 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string); | |
| 21759 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1); | |
| 21760 m_data.m_value.string = nullptr; | |
| 21761 } | |
| 21762 else if (is_binary()) | |
| 21763 { | |
| 21764 AllocatorType<binary_t> alloc; | |
| 21765 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary); | |
| 21766 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1); | |
| 21767 m_data.m_value.binary = nullptr; | |
| 21768 } | |
| 21769 | |
| 21770 m_data.m_type = value_t::null; | |
| 21771 assert_invariant(); | |
| 21772 break; | |
| 21773 } | |
| 21774 | |
| 21775 case value_t::object: | |
| 21776 { | |
| 21777 result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator); | |
| 21778 break; | |
| 21779 } | |
| 21780 | |
| 21781 case value_t::array: | |
| 21782 { | |
| 21783 result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator); | |
| 21784 break; | |
| 21785 } | |
| 21786 | |
| 21787 case value_t::null: | |
| 21788 case value_t::discarded: | |
| 21789 default: | |
| 21790 JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this)); | |
| 21791 } | |
| 21792 | |
| 21793 return result; | |
| 21794 } | |
| 21795 | |
| 21796 /// @brief remove elements given an iterator range | |
| 21797 /// @sa https://json.nlohmann.me/api/basic_json/erase/ | |
| 21798 template < class IteratorType, detail::enable_if_t < | |
| 21799 std::is_same<IteratorType, typename basic_json_t::iterator>::value || | |
| 21800 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 > | |
| 21801 IteratorType erase(IteratorType first, IteratorType last) | |
| 21802 { | |
| 21803 // make sure iterator fits the current value | |
| 21804 if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object)) | |
| 21805 { | |
| 21806 JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this)); | |
| 21807 } | |
| 21808 | |
| 21809 IteratorType result = end(); | |
| 21810 | |
| 21811 switch (m_data.m_type) | |
| 21812 { | |
| 21813 case value_t::boolean: | |
| 21814 case value_t::number_float: | |
| 21815 case value_t::number_integer: | |
| 21816 case value_t::number_unsigned: | |
| 21817 case value_t::string: | |
| 21818 case value_t::binary: | |
| 21819 { | |
| 21820 if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin() | |
| 21821 || !last.m_it.primitive_iterator.is_end())) | |
| 21822 { | |
| 21823 JSON_THROW(invalid_iterator::create(204, "iterators out of range", this)); | |
| 21824 } | |
| 21825 | |
| 21826 if (is_string()) | |
| 21827 { | |
| 21828 AllocatorType<string_t> alloc; | |
| 21829 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string); | |
| 21830 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1); | |
| 21831 m_data.m_value.string = nullptr; | |
| 21832 } | |
| 21833 else if (is_binary()) | |
| 21834 { | |
| 21835 AllocatorType<binary_t> alloc; | |
| 21836 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary); | |
| 21837 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1); | |
| 21838 m_data.m_value.binary = nullptr; | |
| 21839 } | |
| 21840 | |
| 21841 m_data.m_type = value_t::null; | |
| 21842 assert_invariant(); | |
| 21843 break; | |
| 21844 } | |
| 21845 | |
| 21846 case value_t::object: | |
| 21847 { | |
| 21848 result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator, | |
| 21849 last.m_it.object_iterator); | |
| 21850 break; | |
| 21851 } | |
| 21852 | |
| 21853 case value_t::array: | |
| 21854 { | |
| 21855 result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator, | |
| 21856 last.m_it.array_iterator); | |
| 21857 break; | |
| 21858 } | |
| 21859 | |
| 21860 case value_t::null: | |
| 21861 case value_t::discarded: | |
| 21862 default: | |
| 21863 JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this)); | |
| 21864 } | |
| 21865 | |
| 21866 return result; | |
| 21867 } | |
| 21868 | |
| 21869 private: | |
| 21870 template < typename KeyType, detail::enable_if_t < | |
| 21871 detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 > | |
| 21872 size_type erase_internal(KeyType && key) | |
| 21873 { | |
| 21874 // this erase only works for objects | |
| 21875 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 21876 { | |
| 21877 JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this)); | |
| 21878 } | |
| 21879 | |
| 21880 return m_data.m_value.object->erase(std::forward<KeyType>(key)); | |
| 21881 } | |
| 21882 | |
| 21883 template < typename KeyType, detail::enable_if_t < | |
| 21884 !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 > | |
| 21885 size_type erase_internal(KeyType && key) | |
| 21886 { | |
| 21887 // this erase only works for objects | |
| 21888 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 21889 { | |
| 21890 JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this)); | |
| 21891 } | |
| 21892 | |
| 21893 const auto it = m_data.m_value.object->find(std::forward<KeyType>(key)); | |
| 21894 if (it != m_data.m_value.object->end()) | |
| 21895 { | |
| 21896 m_data.m_value.object->erase(it); | |
| 21897 return 1; | |
| 21898 } | |
| 21899 return 0; | |
| 21900 } | |
| 21901 | |
| 21902 public: | |
| 21903 | |
| 21904 /// @brief remove element from a JSON object given a key | |
| 21905 /// @sa https://json.nlohmann.me/api/basic_json/erase/ | |
| 21906 size_type erase(const typename object_t::key_type& key) | |
| 21907 { | |
| 21908 // the indirection via erase_internal() is added to avoid making this | |
| 21909 // function a template and thus de-rank it during overload resolution | |
| 21910 return erase_internal(key); | |
| 21911 } | |
| 21912 | |
| 21913 /// @brief remove element from a JSON object given a key | |
| 21914 /// @sa https://json.nlohmann.me/api/basic_json/erase/ | |
| 21915 template<class KeyType, detail::enable_if_t< | |
| 21916 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 21917 size_type erase(KeyType && key) | |
| 21918 { | |
| 21919 return erase_internal(std::forward<KeyType>(key)); | |
| 21920 } | |
| 21921 | |
| 21922 /// @brief remove element from a JSON array given an index | |
| 21923 /// @sa https://json.nlohmann.me/api/basic_json/erase/ | |
| 21924 void erase(const size_type idx) | |
| 21925 { | |
| 21926 // this erase only works for arrays | |
| 21927 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 21928 { | |
| 21929 if (JSON_HEDLEY_UNLIKELY(idx >= size())) | |
| 21930 { | |
| 21931 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this)); | |
| 21932 } | |
| 21933 | |
| 21934 m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx)); | |
| 21935 } | |
| 21936 else | |
| 21937 { | |
| 21938 JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this)); | |
| 21939 } | |
| 21940 } | |
| 21941 | |
| 21942 /// @} | |
| 21943 | |
| 21944 //////////// | |
| 21945 // lookup // | |
| 21946 //////////// | |
| 21947 | |
| 21948 /// @name lookup | |
| 21949 /// @{ | |
| 21950 | |
| 21951 /// @brief find an element in a JSON object | |
| 21952 /// @sa https://json.nlohmann.me/api/basic_json/find/ | |
| 21953 iterator find(const typename object_t::key_type& key) | |
| 21954 { | |
| 21955 auto result = end(); | |
| 21956 | |
| 21957 if (is_object()) | |
| 21958 { | |
| 21959 result.m_it.object_iterator = m_data.m_value.object->find(key); | |
| 21960 } | |
| 21961 | |
| 21962 return result; | |
| 21963 } | |
| 21964 | |
| 21965 /// @brief find an element in a JSON object | |
| 21966 /// @sa https://json.nlohmann.me/api/basic_json/find/ | |
| 21967 const_iterator find(const typename object_t::key_type& key) const | |
| 21968 { | |
| 21969 auto result = cend(); | |
| 21970 | |
| 21971 if (is_object()) | |
| 21972 { | |
| 21973 result.m_it.object_iterator = m_data.m_value.object->find(key); | |
| 21974 } | |
| 21975 | |
| 21976 return result; | |
| 21977 } | |
| 21978 | |
| 21979 /// @brief find an element in a JSON object | |
| 21980 /// @sa https://json.nlohmann.me/api/basic_json/find/ | |
| 21981 template<class KeyType, detail::enable_if_t< | |
| 21982 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 21983 iterator find(KeyType && key) | |
| 21984 { | |
| 21985 auto result = end(); | |
| 21986 | |
| 21987 if (is_object()) | |
| 21988 { | |
| 21989 result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key)); | |
| 21990 } | |
| 21991 | |
| 21992 return result; | |
| 21993 } | |
| 21994 | |
| 21995 /// @brief find an element in a JSON object | |
| 21996 /// @sa https://json.nlohmann.me/api/basic_json/find/ | |
| 21997 template<class KeyType, detail::enable_if_t< | |
| 21998 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 21999 const_iterator find(KeyType && key) const | |
| 22000 { | |
| 22001 auto result = cend(); | |
| 22002 | |
| 22003 if (is_object()) | |
| 22004 { | |
| 22005 result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key)); | |
| 22006 } | |
| 22007 | |
| 22008 return result; | |
| 22009 } | |
| 22010 | |
| 22011 /// @brief returns the number of occurrences of a key in a JSON object | |
| 22012 /// @sa https://json.nlohmann.me/api/basic_json/count/ | |
| 22013 size_type count(const typename object_t::key_type& key) const | |
| 22014 { | |
| 22015 // return 0 for all nonobject types | |
| 22016 return is_object() ? m_data.m_value.object->count(key) : 0; | |
| 22017 } | |
| 22018 | |
| 22019 /// @brief returns the number of occurrences of a key in a JSON object | |
| 22020 /// @sa https://json.nlohmann.me/api/basic_json/count/ | |
| 22021 template<class KeyType, detail::enable_if_t< | |
| 22022 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 22023 size_type count(KeyType && key) const | |
| 22024 { | |
| 22025 // return 0 for all nonobject types | |
| 22026 return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0; | |
| 22027 } | |
| 22028 | |
| 22029 /// @brief check the existence of an element in a JSON object | |
| 22030 /// @sa https://json.nlohmann.me/api/basic_json/contains/ | |
| 22031 bool contains(const typename object_t::key_type& key) const | |
| 22032 { | |
| 22033 return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end(); | |
| 22034 } | |
| 22035 | |
| 22036 /// @brief check the existence of an element in a JSON object | |
| 22037 /// @sa https://json.nlohmann.me/api/basic_json/contains/ | |
| 22038 template<class KeyType, detail::enable_if_t< | |
| 22039 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0> | |
| 22040 bool contains(KeyType && key) const | |
| 22041 { | |
| 22042 return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end(); | |
| 22043 } | |
| 22044 | |
| 22045 /// @brief check the existence of an element in a JSON object given a JSON pointer | |
| 22046 /// @sa https://json.nlohmann.me/api/basic_json/contains/ | |
| 22047 bool contains(const json_pointer& ptr) const | |
| 22048 { | |
| 22049 return ptr.contains(this); | |
| 22050 } | |
| 22051 | |
| 22052 template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0> | |
| 22053 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 22054 bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const | |
| 22055 { | |
| 22056 return ptr.contains(this); | |
| 22057 } | |
| 22058 | |
| 22059 /// @} | |
| 22060 | |
| 22061 /////////////// | |
| 22062 // iterators // | |
| 22063 /////////////// | |
| 22064 | |
| 22065 /// @name iterators | |
| 22066 /// @{ | |
| 22067 | |
| 22068 /// @brief returns an iterator to the first element | |
| 22069 /// @sa https://json.nlohmann.me/api/basic_json/begin/ | |
| 22070 iterator begin() noexcept | |
| 22071 { | |
| 22072 iterator result(this); | |
| 22073 result.set_begin(); | |
| 22074 return result; | |
| 22075 } | |
| 22076 | |
| 22077 /// @brief returns an iterator to the first element | |
| 22078 /// @sa https://json.nlohmann.me/api/basic_json/begin/ | |
| 22079 const_iterator begin() const noexcept | |
| 22080 { | |
| 22081 return cbegin(); | |
| 22082 } | |
| 22083 | |
| 22084 /// @brief returns a const iterator to the first element | |
| 22085 /// @sa https://json.nlohmann.me/api/basic_json/cbegin/ | |
| 22086 const_iterator cbegin() const noexcept | |
| 22087 { | |
| 22088 const_iterator result(this); | |
| 22089 result.set_begin(); | |
| 22090 return result; | |
| 22091 } | |
| 22092 | |
| 22093 /// @brief returns an iterator to one past the last element | |
| 22094 /// @sa https://json.nlohmann.me/api/basic_json/end/ | |
| 22095 iterator end() noexcept | |
| 22096 { | |
| 22097 iterator result(this); | |
| 22098 result.set_end(); | |
| 22099 return result; | |
| 22100 } | |
| 22101 | |
| 22102 /// @brief returns an iterator to one past the last element | |
| 22103 /// @sa https://json.nlohmann.me/api/basic_json/end/ | |
| 22104 const_iterator end() const noexcept | |
| 22105 { | |
| 22106 return cend(); | |
| 22107 } | |
| 22108 | |
| 22109 /// @brief returns an iterator to one past the last element | |
| 22110 /// @sa https://json.nlohmann.me/api/basic_json/cend/ | |
| 22111 const_iterator cend() const noexcept | |
| 22112 { | |
| 22113 const_iterator result(this); | |
| 22114 result.set_end(); | |
| 22115 return result; | |
| 22116 } | |
| 22117 | |
| 22118 /// @brief returns an iterator to the reverse-beginning | |
| 22119 /// @sa https://json.nlohmann.me/api/basic_json/rbegin/ | |
| 22120 reverse_iterator rbegin() noexcept | |
| 22121 { | |
| 22122 return reverse_iterator(end()); | |
| 22123 } | |
| 22124 | |
| 22125 /// @brief returns an iterator to the reverse-beginning | |
| 22126 /// @sa https://json.nlohmann.me/api/basic_json/rbegin/ | |
| 22127 const_reverse_iterator rbegin() const noexcept | |
| 22128 { | |
| 22129 return crbegin(); | |
| 22130 } | |
| 22131 | |
| 22132 /// @brief returns an iterator to the reverse-end | |
| 22133 /// @sa https://json.nlohmann.me/api/basic_json/rend/ | |
| 22134 reverse_iterator rend() noexcept | |
| 22135 { | |
| 22136 return reverse_iterator(begin()); | |
| 22137 } | |
| 22138 | |
| 22139 /// @brief returns an iterator to the reverse-end | |
| 22140 /// @sa https://json.nlohmann.me/api/basic_json/rend/ | |
| 22141 const_reverse_iterator rend() const noexcept | |
| 22142 { | |
| 22143 return crend(); | |
| 22144 } | |
| 22145 | |
| 22146 /// @brief returns a const reverse iterator to the last element | |
| 22147 /// @sa https://json.nlohmann.me/api/basic_json/crbegin/ | |
| 22148 const_reverse_iterator crbegin() const noexcept | |
| 22149 { | |
| 22150 return const_reverse_iterator(cend()); | |
| 22151 } | |
| 22152 | |
| 22153 /// @brief returns a const reverse iterator to one before the first | |
| 22154 /// @sa https://json.nlohmann.me/api/basic_json/crend/ | |
| 22155 const_reverse_iterator crend() const noexcept | |
| 22156 { | |
| 22157 return const_reverse_iterator(cbegin()); | |
| 22158 } | |
| 22159 | |
| 22160 public: | |
| 22161 /// @brief wrapper to access iterator member functions in range-based for | |
| 22162 /// @sa https://json.nlohmann.me/api/basic_json/items/ | |
| 22163 /// @deprecated This function is deprecated since 3.1.0 and will be removed in | |
| 22164 /// version 4.0.0 of the library. Please use @ref items() instead; | |
| 22165 /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. | |
| 22166 JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) | |
| 22167 static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept | |
| 22168 { | |
| 22169 return ref.items(); | |
| 22170 } | |
| 22171 | |
| 22172 /// @brief wrapper to access iterator member functions in range-based for | |
| 22173 /// @sa https://json.nlohmann.me/api/basic_json/items/ | |
| 22174 /// @deprecated This function is deprecated since 3.1.0 and will be removed in | |
| 22175 /// version 4.0.0 of the library. Please use @ref items() instead; | |
| 22176 /// that is, replace `json::iterator_wrapper(j)` with `j.items()`. | |
| 22177 JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items()) | |
| 22178 static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept | |
| 22179 { | |
| 22180 return ref.items(); | |
| 22181 } | |
| 22182 | |
| 22183 /// @brief helper to access iterator member functions in range-based for | |
| 22184 /// @sa https://json.nlohmann.me/api/basic_json/items/ | |
| 22185 iteration_proxy<iterator> items() noexcept | |
| 22186 { | |
| 22187 return iteration_proxy<iterator>(*this); | |
| 22188 } | |
| 22189 | |
| 22190 /// @brief helper to access iterator member functions in range-based for | |
| 22191 /// @sa https://json.nlohmann.me/api/basic_json/items/ | |
| 22192 iteration_proxy<const_iterator> items() const noexcept | |
| 22193 { | |
| 22194 return iteration_proxy<const_iterator>(*this); | |
| 22195 } | |
| 22196 | |
| 22197 /// @} | |
| 22198 | |
| 22199 ////////////// | |
| 22200 // capacity // | |
| 22201 ////////////// | |
| 22202 | |
| 22203 /// @name capacity | |
| 22204 /// @{ | |
| 22205 | |
| 22206 /// @brief checks whether the container is empty. | |
| 22207 /// @sa https://json.nlohmann.me/api/basic_json/empty/ | |
| 22208 bool empty() const noexcept | |
| 22209 { | |
| 22210 switch (m_data.m_type) | |
| 22211 { | |
| 22212 case value_t::null: | |
| 22213 { | |
| 22214 // null values are empty | |
| 22215 return true; | |
| 22216 } | |
| 22217 | |
| 22218 case value_t::array: | |
| 22219 { | |
| 22220 // delegate call to array_t::empty() | |
| 22221 return m_data.m_value.array->empty(); | |
| 22222 } | |
| 22223 | |
| 22224 case value_t::object: | |
| 22225 { | |
| 22226 // delegate call to object_t::empty() | |
| 22227 return m_data.m_value.object->empty(); | |
| 22228 } | |
| 22229 | |
| 22230 case value_t::string: | |
| 22231 case value_t::boolean: | |
| 22232 case value_t::number_integer: | |
| 22233 case value_t::number_unsigned: | |
| 22234 case value_t::number_float: | |
| 22235 case value_t::binary: | |
| 22236 case value_t::discarded: | |
| 22237 default: | |
| 22238 { | |
| 22239 // all other types are nonempty | |
| 22240 return false; | |
| 22241 } | |
| 22242 } | |
| 22243 } | |
| 22244 | |
| 22245 /// @brief returns the number of elements | |
| 22246 /// @sa https://json.nlohmann.me/api/basic_json/size/ | |
| 22247 size_type size() const noexcept | |
| 22248 { | |
| 22249 switch (m_data.m_type) | |
| 22250 { | |
| 22251 case value_t::null: | |
| 22252 { | |
| 22253 // null values are empty | |
| 22254 return 0; | |
| 22255 } | |
| 22256 | |
| 22257 case value_t::array: | |
| 22258 { | |
| 22259 // delegate call to array_t::size() | |
| 22260 return m_data.m_value.array->size(); | |
| 22261 } | |
| 22262 | |
| 22263 case value_t::object: | |
| 22264 { | |
| 22265 // delegate call to object_t::size() | |
| 22266 return m_data.m_value.object->size(); | |
| 22267 } | |
| 22268 | |
| 22269 case value_t::string: | |
| 22270 case value_t::boolean: | |
| 22271 case value_t::number_integer: | |
| 22272 case value_t::number_unsigned: | |
| 22273 case value_t::number_float: | |
| 22274 case value_t::binary: | |
| 22275 case value_t::discarded: | |
| 22276 default: | |
| 22277 { | |
| 22278 // all other types have size 1 | |
| 22279 return 1; | |
| 22280 } | |
| 22281 } | |
| 22282 } | |
| 22283 | |
| 22284 /// @brief returns the maximum possible number of elements | |
| 22285 /// @sa https://json.nlohmann.me/api/basic_json/max_size/ | |
| 22286 size_type max_size() const noexcept | |
| 22287 { | |
| 22288 switch (m_data.m_type) | |
| 22289 { | |
| 22290 case value_t::array: | |
| 22291 { | |
| 22292 // delegate call to array_t::max_size() | |
| 22293 return m_data.m_value.array->max_size(); | |
| 22294 } | |
| 22295 | |
| 22296 case value_t::object: | |
| 22297 { | |
| 22298 // delegate call to object_t::max_size() | |
| 22299 return m_data.m_value.object->max_size(); | |
| 22300 } | |
| 22301 | |
| 22302 case value_t::null: | |
| 22303 case value_t::string: | |
| 22304 case value_t::boolean: | |
| 22305 case value_t::number_integer: | |
| 22306 case value_t::number_unsigned: | |
| 22307 case value_t::number_float: | |
| 22308 case value_t::binary: | |
| 22309 case value_t::discarded: | |
| 22310 default: | |
| 22311 { | |
| 22312 // all other types have max_size() == size() | |
| 22313 return size(); | |
| 22314 } | |
| 22315 } | |
| 22316 } | |
| 22317 | |
| 22318 /// @} | |
| 22319 | |
| 22320 /////////////// | |
| 22321 // modifiers // | |
| 22322 /////////////// | |
| 22323 | |
| 22324 /// @name modifiers | |
| 22325 /// @{ | |
| 22326 | |
| 22327 /// @brief clears the contents | |
| 22328 /// @sa https://json.nlohmann.me/api/basic_json/clear/ | |
| 22329 void clear() noexcept | |
| 22330 { | |
| 22331 switch (m_data.m_type) | |
| 22332 { | |
| 22333 case value_t::number_integer: | |
| 22334 { | |
| 22335 m_data.m_value.number_integer = 0; | |
| 22336 break; | |
| 22337 } | |
| 22338 | |
| 22339 case value_t::number_unsigned: | |
| 22340 { | |
| 22341 m_data.m_value.number_unsigned = 0; | |
| 22342 break; | |
| 22343 } | |
| 22344 | |
| 22345 case value_t::number_float: | |
| 22346 { | |
| 22347 m_data.m_value.number_float = 0.0; | |
| 22348 break; | |
| 22349 } | |
| 22350 | |
| 22351 case value_t::boolean: | |
| 22352 { | |
| 22353 m_data.m_value.boolean = false; | |
| 22354 break; | |
| 22355 } | |
| 22356 | |
| 22357 case value_t::string: | |
| 22358 { | |
| 22359 m_data.m_value.string->clear(); | |
| 22360 break; | |
| 22361 } | |
| 22362 | |
| 22363 case value_t::binary: | |
| 22364 { | |
| 22365 m_data.m_value.binary->clear(); | |
| 22366 break; | |
| 22367 } | |
| 22368 | |
| 22369 case value_t::array: | |
| 22370 { | |
| 22371 m_data.m_value.array->clear(); | |
| 22372 break; | |
| 22373 } | |
| 22374 | |
| 22375 case value_t::object: | |
| 22376 { | |
| 22377 m_data.m_value.object->clear(); | |
| 22378 break; | |
| 22379 } | |
| 22380 | |
| 22381 case value_t::null: | |
| 22382 case value_t::discarded: | |
| 22383 default: | |
| 22384 break; | |
| 22385 } | |
| 22386 } | |
| 22387 | |
| 22388 /// @brief add an object to an array | |
| 22389 /// @sa https://json.nlohmann.me/api/basic_json/push_back/ | |
| 22390 void push_back(basic_json&& val) | |
| 22391 { | |
| 22392 // push_back only works for null objects or arrays | |
| 22393 if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array()))) | |
| 22394 { | |
| 22395 JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this)); | |
| 22396 } | |
| 22397 | |
| 22398 // transform null object into an array | |
| 22399 if (is_null()) | |
| 22400 { | |
| 22401 m_data.m_type = value_t::array; | |
| 22402 m_data.m_value = value_t::array; | |
| 22403 assert_invariant(); | |
| 22404 } | |
| 22405 | |
| 22406 // add element to array (move semantics) | |
| 22407 const auto old_capacity = m_data.m_value.array->capacity(); | |
| 22408 m_data.m_value.array->push_back(std::move(val)); | |
| 22409 set_parent(m_data.m_value.array->back(), old_capacity); | |
| 22410 // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor | |
| 22411 } | |
| 22412 | |
| 22413 /// @brief add an object to an array | |
| 22414 /// @sa https://json.nlohmann.me/api/basic_json/operator+=/ | |
| 22415 reference operator+=(basic_json&& val) | |
| 22416 { | |
| 22417 push_back(std::move(val)); | |
| 22418 return *this; | |
| 22419 } | |
| 22420 | |
| 22421 /// @brief add an object to an array | |
| 22422 /// @sa https://json.nlohmann.me/api/basic_json/push_back/ | |
| 22423 void push_back(const basic_json& val) | |
| 22424 { | |
| 22425 // push_back only works for null objects or arrays | |
| 22426 if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array()))) | |
| 22427 { | |
| 22428 JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this)); | |
| 22429 } | |
| 22430 | |
| 22431 // transform null object into an array | |
| 22432 if (is_null()) | |
| 22433 { | |
| 22434 m_data.m_type = value_t::array; | |
| 22435 m_data.m_value = value_t::array; | |
| 22436 assert_invariant(); | |
| 22437 } | |
| 22438 | |
| 22439 // add element to array | |
| 22440 const auto old_capacity = m_data.m_value.array->capacity(); | |
| 22441 m_data.m_value.array->push_back(val); | |
| 22442 set_parent(m_data.m_value.array->back(), old_capacity); | |
| 22443 } | |
| 22444 | |
| 22445 /// @brief add an object to an array | |
| 22446 /// @sa https://json.nlohmann.me/api/basic_json/operator+=/ | |
| 22447 reference operator+=(const basic_json& val) | |
| 22448 { | |
| 22449 push_back(val); | |
| 22450 return *this; | |
| 22451 } | |
| 22452 | |
| 22453 /// @brief add an object to an object | |
| 22454 /// @sa https://json.nlohmann.me/api/basic_json/push_back/ | |
| 22455 void push_back(const typename object_t::value_type& val) | |
| 22456 { | |
| 22457 // push_back only works for null objects or objects | |
| 22458 if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object()))) | |
| 22459 { | |
| 22460 JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this)); | |
| 22461 } | |
| 22462 | |
| 22463 // transform null object into an object | |
| 22464 if (is_null()) | |
| 22465 { | |
| 22466 m_data.m_type = value_t::object; | |
| 22467 m_data.m_value = value_t::object; | |
| 22468 assert_invariant(); | |
| 22469 } | |
| 22470 | |
| 22471 // add element to object | |
| 22472 auto res = m_data.m_value.object->insert(val); | |
| 22473 set_parent(res.first->second); | |
| 22474 } | |
| 22475 | |
| 22476 /// @brief add an object to an object | |
| 22477 /// @sa https://json.nlohmann.me/api/basic_json/operator+=/ | |
| 22478 reference operator+=(const typename object_t::value_type& val) | |
| 22479 { | |
| 22480 push_back(val); | |
| 22481 return *this; | |
| 22482 } | |
| 22483 | |
| 22484 /// @brief add an object to an object | |
| 22485 /// @sa https://json.nlohmann.me/api/basic_json/push_back/ | |
| 22486 void push_back(initializer_list_t init) | |
| 22487 { | |
| 22488 if (is_object() && init.size() == 2 && (*init.begin())->is_string()) | |
| 22489 { | |
| 22490 basic_json&& key = init.begin()->moved_or_copied(); | |
| 22491 push_back(typename object_t::value_type( | |
| 22492 std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied())); | |
| 22493 } | |
| 22494 else | |
| 22495 { | |
| 22496 push_back(basic_json(init)); | |
| 22497 } | |
| 22498 } | |
| 22499 | |
| 22500 /// @brief add an object to an object | |
| 22501 /// @sa https://json.nlohmann.me/api/basic_json/operator+=/ | |
| 22502 reference operator+=(initializer_list_t init) | |
| 22503 { | |
| 22504 push_back(init); | |
| 22505 return *this; | |
| 22506 } | |
| 22507 | |
| 22508 /// @brief add an object to an array | |
| 22509 /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/ | |
| 22510 template<class... Args> | |
| 22511 reference emplace_back(Args&& ... args) | |
| 22512 { | |
| 22513 // emplace_back only works for null objects or arrays | |
| 22514 if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array()))) | |
| 22515 { | |
| 22516 JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this)); | |
| 22517 } | |
| 22518 | |
| 22519 // transform null object into an array | |
| 22520 if (is_null()) | |
| 22521 { | |
| 22522 m_data.m_type = value_t::array; | |
| 22523 m_data.m_value = value_t::array; | |
| 22524 assert_invariant(); | |
| 22525 } | |
| 22526 | |
| 22527 // add element to array (perfect forwarding) | |
| 22528 const auto old_capacity = m_data.m_value.array->capacity(); | |
| 22529 m_data.m_value.array->emplace_back(std::forward<Args>(args)...); | |
| 22530 return set_parent(m_data.m_value.array->back(), old_capacity); | |
| 22531 } | |
| 22532 | |
| 22533 /// @brief add an object to an object if key does not exist | |
| 22534 /// @sa https://json.nlohmann.me/api/basic_json/emplace/ | |
| 22535 template<class... Args> | |
| 22536 std::pair<iterator, bool> emplace(Args&& ... args) | |
| 22537 { | |
| 22538 // emplace only works for null objects or arrays | |
| 22539 if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object()))) | |
| 22540 { | |
| 22541 JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this)); | |
| 22542 } | |
| 22543 | |
| 22544 // transform null object into an object | |
| 22545 if (is_null()) | |
| 22546 { | |
| 22547 m_data.m_type = value_t::object; | |
| 22548 m_data.m_value = value_t::object; | |
| 22549 assert_invariant(); | |
| 22550 } | |
| 22551 | |
| 22552 // add element to array (perfect forwarding) | |
| 22553 auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...); | |
| 22554 set_parent(res.first->second); | |
| 22555 | |
| 22556 // create result iterator and set iterator to the result of emplace | |
| 22557 auto it = begin(); | |
| 22558 it.m_it.object_iterator = res.first; | |
| 22559 | |
| 22560 // return pair of iterator and boolean | |
| 22561 return {it, res.second}; | |
| 22562 } | |
| 22563 | |
| 22564 /// Helper for insertion of an iterator | |
| 22565 /// @note: This uses std::distance to support GCC 4.8, | |
| 22566 /// see https://github.com/nlohmann/json/pull/1257 | |
| 22567 template<typename... Args> | |
| 22568 iterator insert_iterator(const_iterator pos, Args&& ... args) | |
| 22569 { | |
| 22570 iterator result(this); | |
| 22571 JSON_ASSERT(m_data.m_value.array != nullptr); | |
| 22572 | |
| 22573 auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator); | |
| 22574 m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...); | |
| 22575 result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos; | |
| 22576 | |
| 22577 // This could have been written as: | |
| 22578 // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val); | |
| 22579 // but the return value of insert is missing in GCC 4.8, so it is written this way instead. | |
| 22580 | |
| 22581 set_parents(); | |
| 22582 return result; | |
| 22583 } | |
| 22584 | |
| 22585 /// @brief inserts element into array | |
| 22586 /// @sa https://json.nlohmann.me/api/basic_json/insert/ | |
| 22587 iterator insert(const_iterator pos, const basic_json& val) | |
| 22588 { | |
| 22589 // insert only works for arrays | |
| 22590 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 22591 { | |
| 22592 // check if iterator pos fits to this JSON value | |
| 22593 if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) | |
| 22594 { | |
| 22595 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this)); | |
| 22596 } | |
| 22597 | |
| 22598 // insert to array and return iterator | |
| 22599 return insert_iterator(pos, val); | |
| 22600 } | |
| 22601 | |
| 22602 JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this)); | |
| 22603 } | |
| 22604 | |
| 22605 /// @brief inserts element into array | |
| 22606 /// @sa https://json.nlohmann.me/api/basic_json/insert/ | |
| 22607 iterator insert(const_iterator pos, basic_json&& val) | |
| 22608 { | |
| 22609 return insert(pos, val); | |
| 22610 } | |
| 22611 | |
| 22612 /// @brief inserts copies of element into array | |
| 22613 /// @sa https://json.nlohmann.me/api/basic_json/insert/ | |
| 22614 iterator insert(const_iterator pos, size_type cnt, const basic_json& val) | |
| 22615 { | |
| 22616 // insert only works for arrays | |
| 22617 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 22618 { | |
| 22619 // check if iterator pos fits to this JSON value | |
| 22620 if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) | |
| 22621 { | |
| 22622 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this)); | |
| 22623 } | |
| 22624 | |
| 22625 // insert to array and return iterator | |
| 22626 return insert_iterator(pos, cnt, val); | |
| 22627 } | |
| 22628 | |
| 22629 JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this)); | |
| 22630 } | |
| 22631 | |
| 22632 /// @brief inserts range of elements into array | |
| 22633 /// @sa https://json.nlohmann.me/api/basic_json/insert/ | |
| 22634 iterator insert(const_iterator pos, const_iterator first, const_iterator last) | |
| 22635 { | |
| 22636 // insert only works for arrays | |
| 22637 if (JSON_HEDLEY_UNLIKELY(!is_array())) | |
| 22638 { | |
| 22639 JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this)); | |
| 22640 } | |
| 22641 | |
| 22642 // check if iterator pos fits to this JSON value | |
| 22643 if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) | |
| 22644 { | |
| 22645 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this)); | |
| 22646 } | |
| 22647 | |
| 22648 // check if range iterators belong to the same JSON object | |
| 22649 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) | |
| 22650 { | |
| 22651 JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this)); | |
| 22652 } | |
| 22653 | |
| 22654 if (JSON_HEDLEY_UNLIKELY(first.m_object == this)) | |
| 22655 { | |
| 22656 JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this)); | |
| 22657 } | |
| 22658 | |
| 22659 // insert to array and return iterator | |
| 22660 return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator); | |
| 22661 } | |
| 22662 | |
| 22663 /// @brief inserts elements from initializer list into array | |
| 22664 /// @sa https://json.nlohmann.me/api/basic_json/insert/ | |
| 22665 iterator insert(const_iterator pos, initializer_list_t ilist) | |
| 22666 { | |
| 22667 // insert only works for arrays | |
| 22668 if (JSON_HEDLEY_UNLIKELY(!is_array())) | |
| 22669 { | |
| 22670 JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this)); | |
| 22671 } | |
| 22672 | |
| 22673 // check if iterator pos fits to this JSON value | |
| 22674 if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) | |
| 22675 { | |
| 22676 JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this)); | |
| 22677 } | |
| 22678 | |
| 22679 // insert to array and return iterator | |
| 22680 return insert_iterator(pos, ilist.begin(), ilist.end()); | |
| 22681 } | |
| 22682 | |
| 22683 /// @brief inserts range of elements into object | |
| 22684 /// @sa https://json.nlohmann.me/api/basic_json/insert/ | |
| 22685 void insert(const_iterator first, const_iterator last) | |
| 22686 { | |
| 22687 // insert only works for objects | |
| 22688 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 22689 { | |
| 22690 JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this)); | |
| 22691 } | |
| 22692 | |
| 22693 // check if range iterators belong to the same JSON object | |
| 22694 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) | |
| 22695 { | |
| 22696 JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this)); | |
| 22697 } | |
| 22698 | |
| 22699 // passed iterators must belong to objects | |
| 22700 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object())) | |
| 22701 { | |
| 22702 JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this)); | |
| 22703 } | |
| 22704 | |
| 22705 m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator); | |
| 22706 } | |
| 22707 | |
| 22708 /// @brief updates a JSON object from another object, overwriting existing keys | |
| 22709 /// @sa https://json.nlohmann.me/api/basic_json/update/ | |
| 22710 void update(const_reference j, bool merge_objects = false) | |
| 22711 { | |
| 22712 update(j.begin(), j.end(), merge_objects); | |
| 22713 } | |
| 22714 | |
| 22715 /// @brief updates a JSON object from another object, overwriting existing keys | |
| 22716 /// @sa https://json.nlohmann.me/api/basic_json/update/ | |
| 22717 void update(const_iterator first, const_iterator last, bool merge_objects = false) | |
| 22718 { | |
| 22719 // implicitly convert null value to an empty object | |
| 22720 if (is_null()) | |
| 22721 { | |
| 22722 m_data.m_type = value_t::object; | |
| 22723 m_data.m_value.object = create<object_t>(); | |
| 22724 assert_invariant(); | |
| 22725 } | |
| 22726 | |
| 22727 if (JSON_HEDLEY_UNLIKELY(!is_object())) | |
| 22728 { | |
| 22729 JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this)); | |
| 22730 } | |
| 22731 | |
| 22732 // check if range iterators belong to the same JSON object | |
| 22733 if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object)) | |
| 22734 { | |
| 22735 JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this)); | |
| 22736 } | |
| 22737 | |
| 22738 // passed iterators must belong to objects | |
| 22739 if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object())) | |
| 22740 { | |
| 22741 JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object)); | |
| 22742 } | |
| 22743 | |
| 22744 for (auto it = first; it != last; ++it) | |
| 22745 { | |
| 22746 if (merge_objects && it.value().is_object()) | |
| 22747 { | |
| 22748 auto it2 = m_data.m_value.object->find(it.key()); | |
| 22749 if (it2 != m_data.m_value.object->end()) | |
| 22750 { | |
| 22751 it2->second.update(it.value(), true); | |
| 22752 continue; | |
| 22753 } | |
| 22754 } | |
| 22755 m_data.m_value.object->operator[](it.key()) = it.value(); | |
| 22756 #if JSON_DIAGNOSTICS | |
| 22757 m_data.m_value.object->operator[](it.key()).m_parent = this; | |
| 22758 #endif | |
| 22759 } | |
| 22760 } | |
| 22761 | |
| 22762 /// @brief exchanges the values | |
| 22763 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22764 void swap(reference other) noexcept ( | |
| 22765 std::is_nothrow_move_constructible<value_t>::value&& | |
| 22766 std::is_nothrow_move_assignable<value_t>::value&& | |
| 22767 std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 22768 std::is_nothrow_move_assignable<json_value>::value | |
| 22769 ) | |
| 22770 { | |
| 22771 std::swap(m_data.m_type, other.m_data.m_type); | |
| 22772 std::swap(m_data.m_value, other.m_data.m_value); | |
| 22773 | |
| 22774 set_parents(); | |
| 22775 other.set_parents(); | |
| 22776 assert_invariant(); | |
| 22777 } | |
| 22778 | |
| 22779 /// @brief exchanges the values | |
| 22780 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22781 friend void swap(reference left, reference right) noexcept ( | |
| 22782 std::is_nothrow_move_constructible<value_t>::value&& | |
| 22783 std::is_nothrow_move_assignable<value_t>::value&& | |
| 22784 std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 22785 std::is_nothrow_move_assignable<json_value>::value | |
| 22786 ) | |
| 22787 { | |
| 22788 left.swap(right); | |
| 22789 } | |
| 22790 | |
| 22791 /// @brief exchanges the values | |
| 22792 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22793 void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 22794 { | |
| 22795 // swap only works for arrays | |
| 22796 if (JSON_HEDLEY_LIKELY(is_array())) | |
| 22797 { | |
| 22798 using std::swap; | |
| 22799 swap(*(m_data.m_value.array), other); | |
| 22800 } | |
| 22801 else | |
| 22802 { | |
| 22803 JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this)); | |
| 22804 } | |
| 22805 } | |
| 22806 | |
| 22807 /// @brief exchanges the values | |
| 22808 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22809 void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 22810 { | |
| 22811 // swap only works for objects | |
| 22812 if (JSON_HEDLEY_LIKELY(is_object())) | |
| 22813 { | |
| 22814 using std::swap; | |
| 22815 swap(*(m_data.m_value.object), other); | |
| 22816 } | |
| 22817 else | |
| 22818 { | |
| 22819 JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this)); | |
| 22820 } | |
| 22821 } | |
| 22822 | |
| 22823 /// @brief exchanges the values | |
| 22824 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22825 void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 22826 { | |
| 22827 // swap only works for strings | |
| 22828 if (JSON_HEDLEY_LIKELY(is_string())) | |
| 22829 { | |
| 22830 using std::swap; | |
| 22831 swap(*(m_data.m_value.string), other); | |
| 22832 } | |
| 22833 else | |
| 22834 { | |
| 22835 JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this)); | |
| 22836 } | |
| 22837 } | |
| 22838 | |
| 22839 /// @brief exchanges the values | |
| 22840 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22841 void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 22842 { | |
| 22843 // swap only works for strings | |
| 22844 if (JSON_HEDLEY_LIKELY(is_binary())) | |
| 22845 { | |
| 22846 using std::swap; | |
| 22847 swap(*(m_data.m_value.binary), other); | |
| 22848 } | |
| 22849 else | |
| 22850 { | |
| 22851 JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this)); | |
| 22852 } | |
| 22853 } | |
| 22854 | |
| 22855 /// @brief exchanges the values | |
| 22856 /// @sa https://json.nlohmann.me/api/basic_json/swap/ | |
| 22857 void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape) | |
| 22858 { | |
| 22859 // swap only works for strings | |
| 22860 if (JSON_HEDLEY_LIKELY(is_binary())) | |
| 22861 { | |
| 22862 using std::swap; | |
| 22863 swap(*(m_data.m_value.binary), other); | |
| 22864 } | |
| 22865 else | |
| 22866 { | |
| 22867 JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this)); | |
| 22868 } | |
| 22869 } | |
| 22870 | |
| 22871 /// @} | |
| 22872 | |
| 22873 ////////////////////////////////////////// | |
| 22874 // lexicographical comparison operators // | |
| 22875 ////////////////////////////////////////// | |
| 22876 | |
| 22877 /// @name lexicographical comparison operators | |
| 22878 /// @{ | |
| 22879 | |
| 22880 // note parentheses around operands are necessary; see | |
| 22881 // https://github.com/nlohmann/json/issues/1530 | |
| 22882 #define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result) \ | |
| 22883 const auto lhs_type = lhs.type(); \ | |
| 22884 const auto rhs_type = rhs.type(); \ | |
| 22885 \ | |
| 22886 if (lhs_type == rhs_type) /* NOLINT(readability/braces) */ \ | |
| 22887 { \ | |
| 22888 switch (lhs_type) \ | |
| 22889 { \ | |
| 22890 case value_t::array: \ | |
| 22891 return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array); \ | |
| 22892 \ | |
| 22893 case value_t::object: \ | |
| 22894 return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object); \ | |
| 22895 \ | |
| 22896 case value_t::null: \ | |
| 22897 return (null_result); \ | |
| 22898 \ | |
| 22899 case value_t::string: \ | |
| 22900 return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string); \ | |
| 22901 \ | |
| 22902 case value_t::boolean: \ | |
| 22903 return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean); \ | |
| 22904 \ | |
| 22905 case value_t::number_integer: \ | |
| 22906 return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer); \ | |
| 22907 \ | |
| 22908 case value_t::number_unsigned: \ | |
| 22909 return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned); \ | |
| 22910 \ | |
| 22911 case value_t::number_float: \ | |
| 22912 return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float); \ | |
| 22913 \ | |
| 22914 case value_t::binary: \ | |
| 22915 return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary); \ | |
| 22916 \ | |
| 22917 case value_t::discarded: \ | |
| 22918 default: \ | |
| 22919 return (unordered_result); \ | |
| 22920 } \ | |
| 22921 } \ | |
| 22922 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float) \ | |
| 22923 { \ | |
| 22924 return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float; \ | |
| 22925 } \ | |
| 22926 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer) \ | |
| 22927 { \ | |
| 22928 return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer); \ | |
| 22929 } \ | |
| 22930 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float) \ | |
| 22931 { \ | |
| 22932 return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float; \ | |
| 22933 } \ | |
| 22934 else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned) \ | |
| 22935 { \ | |
| 22936 return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned); \ | |
| 22937 } \ | |
| 22938 else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer) \ | |
| 22939 { \ | |
| 22940 return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \ | |
| 22941 } \ | |
| 22942 else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned) \ | |
| 22943 { \ | |
| 22944 return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \ | |
| 22945 } \ | |
| 22946 else if(compares_unordered(lhs, rhs))\ | |
| 22947 {\ | |
| 22948 return (unordered_result);\ | |
| 22949 }\ | |
| 22950 \ | |
| 22951 return (default_result); | |
| 22952 | |
| 22953 JSON_PRIVATE_UNLESS_TESTED: | |
| 22954 // returns true if: | |
| 22955 // - any operand is NaN and the other operand is of number type | |
| 22956 // - any operand is discarded | |
| 22957 // in legacy mode, discarded values are considered ordered if | |
| 22958 // an operation is computed as an odd number of inverses of others | |
| 22959 static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept | |
| 22960 { | |
| 22961 if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number()) | |
| 22962 || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number())) | |
| 22963 { | |
| 22964 return true; | |
| 22965 } | |
| 22966 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON | |
| 22967 return (lhs.is_discarded() || rhs.is_discarded()) && !inverse; | |
| 22968 #else | |
| 22969 static_cast<void>(inverse); | |
| 22970 return lhs.is_discarded() || rhs.is_discarded(); | |
| 22971 #endif | |
| 22972 } | |
| 22973 | |
| 22974 private: | |
| 22975 bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept | |
| 22976 { | |
| 22977 return compares_unordered(*this, rhs, inverse); | |
| 22978 } | |
| 22979 | |
| 22980 public: | |
| 22981 #if JSON_HAS_THREE_WAY_COMPARISON | |
| 22982 /// @brief comparison: equal | |
| 22983 /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/ | |
| 22984 bool operator==(const_reference rhs) const noexcept | |
| 22985 { | |
| 22986 #ifdef __GNUC__ | |
| 22987 #pragma GCC diagnostic push | |
| 22988 #pragma GCC diagnostic ignored "-Wfloat-equal" | |
| 22989 #endif | |
| 22990 const_reference lhs = *this; | |
| 22991 JSON_IMPLEMENT_OPERATOR( ==, true, false, false) | |
| 22992 #ifdef __GNUC__ | |
| 22993 #pragma GCC diagnostic pop | |
| 22994 #endif | |
| 22995 } | |
| 22996 | |
| 22997 /// @brief comparison: equal | |
| 22998 /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/ | |
| 22999 template<typename ScalarType> | |
| 23000 requires std::is_scalar_v<ScalarType> | |
| 23001 bool operator==(ScalarType rhs) const noexcept | |
| 23002 { | |
| 23003 return *this == basic_json(rhs); | |
| 23004 } | |
| 23005 | |
| 23006 /// @brief comparison: not equal | |
| 23007 /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/ | |
| 23008 bool operator!=(const_reference rhs) const noexcept | |
| 23009 { | |
| 23010 if (compares_unordered(rhs, true)) | |
| 23011 { | |
| 23012 return false; | |
| 23013 } | |
| 23014 return !operator==(rhs); | |
| 23015 } | |
| 23016 | |
| 23017 /// @brief comparison: 3-way | |
| 23018 /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/ | |
| 23019 std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD* | |
| 23020 { | |
| 23021 const_reference lhs = *this; | |
| 23022 // default_result is used if we cannot compare values. In that case, | |
| 23023 // we compare types. | |
| 23024 JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD* | |
| 23025 std::partial_ordering::equivalent, | |
| 23026 std::partial_ordering::unordered, | |
| 23027 lhs_type <=> rhs_type) // *NOPAD* | |
| 23028 } | |
| 23029 | |
| 23030 /// @brief comparison: 3-way | |
| 23031 /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/ | |
| 23032 template<typename ScalarType> | |
| 23033 requires std::is_scalar_v<ScalarType> | |
| 23034 std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD* | |
| 23035 { | |
| 23036 return *this <=> basic_json(rhs); // *NOPAD* | |
| 23037 } | |
| 23038 | |
| 23039 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON | |
| 23040 // all operators that are computed as an odd number of inverses of others | |
| 23041 // need to be overloaded to emulate the legacy comparison behavior | |
| 23042 | |
| 23043 /// @brief comparison: less than or equal | |
| 23044 /// @sa https://json.nlohmann.me/api/basic_json/operator_le/ | |
| 23045 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON) | |
| 23046 bool operator<=(const_reference rhs) const noexcept | |
| 23047 { | |
| 23048 if (compares_unordered(rhs, true)) | |
| 23049 { | |
| 23050 return false; | |
| 23051 } | |
| 23052 return !(rhs < *this); | |
| 23053 } | |
| 23054 | |
| 23055 /// @brief comparison: less than or equal | |
| 23056 /// @sa https://json.nlohmann.me/api/basic_json/operator_le/ | |
| 23057 template<typename ScalarType> | |
| 23058 requires std::is_scalar_v<ScalarType> | |
| 23059 bool operator<=(ScalarType rhs) const noexcept | |
| 23060 { | |
| 23061 return *this <= basic_json(rhs); | |
| 23062 } | |
| 23063 | |
| 23064 /// @brief comparison: greater than or equal | |
| 23065 /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/ | |
| 23066 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON) | |
| 23067 bool operator>=(const_reference rhs) const noexcept | |
| 23068 { | |
| 23069 if (compares_unordered(rhs, true)) | |
| 23070 { | |
| 23071 return false; | |
| 23072 } | |
| 23073 return !(*this < rhs); | |
| 23074 } | |
| 23075 | |
| 23076 /// @brief comparison: greater than or equal | |
| 23077 /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/ | |
| 23078 template<typename ScalarType> | |
| 23079 requires std::is_scalar_v<ScalarType> | |
| 23080 bool operator>=(ScalarType rhs) const noexcept | |
| 23081 { | |
| 23082 return *this >= basic_json(rhs); | |
| 23083 } | |
| 23084 #endif | |
| 23085 #else | |
| 23086 /// @brief comparison: equal | |
| 23087 /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/ | |
| 23088 friend bool operator==(const_reference lhs, const_reference rhs) noexcept | |
| 23089 { | |
| 23090 #ifdef __GNUC__ | |
| 23091 #pragma GCC diagnostic push | |
| 23092 #pragma GCC diagnostic ignored "-Wfloat-equal" | |
| 23093 #endif | |
| 23094 JSON_IMPLEMENT_OPERATOR( ==, true, false, false) | |
| 23095 #ifdef __GNUC__ | |
| 23096 #pragma GCC diagnostic pop | |
| 23097 #endif | |
| 23098 } | |
| 23099 | |
| 23100 /// @brief comparison: equal | |
| 23101 /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/ | |
| 23102 template<typename ScalarType, typename std::enable_if< | |
| 23103 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23104 friend bool operator==(const_reference lhs, ScalarType rhs) noexcept | |
| 23105 { | |
| 23106 return lhs == basic_json(rhs); | |
| 23107 } | |
| 23108 | |
| 23109 /// @brief comparison: equal | |
| 23110 /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/ | |
| 23111 template<typename ScalarType, typename std::enable_if< | |
| 23112 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23113 friend bool operator==(ScalarType lhs, const_reference rhs) noexcept | |
| 23114 { | |
| 23115 return basic_json(lhs) == rhs; | |
| 23116 } | |
| 23117 | |
| 23118 /// @brief comparison: not equal | |
| 23119 /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/ | |
| 23120 friend bool operator!=(const_reference lhs, const_reference rhs) noexcept | |
| 23121 { | |
| 23122 if (compares_unordered(lhs, rhs, true)) | |
| 23123 { | |
| 23124 return false; | |
| 23125 } | |
| 23126 return !(lhs == rhs); | |
| 23127 } | |
| 23128 | |
| 23129 /// @brief comparison: not equal | |
| 23130 /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/ | |
| 23131 template<typename ScalarType, typename std::enable_if< | |
| 23132 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23133 friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept | |
| 23134 { | |
| 23135 return lhs != basic_json(rhs); | |
| 23136 } | |
| 23137 | |
| 23138 /// @brief comparison: not equal | |
| 23139 /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/ | |
| 23140 template<typename ScalarType, typename std::enable_if< | |
| 23141 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23142 friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept | |
| 23143 { | |
| 23144 return basic_json(lhs) != rhs; | |
| 23145 } | |
| 23146 | |
| 23147 /// @brief comparison: less than | |
| 23148 /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/ | |
| 23149 friend bool operator<(const_reference lhs, const_reference rhs) noexcept | |
| 23150 { | |
| 23151 // default_result is used if we cannot compare values. In that case, | |
| 23152 // we compare types. Note we have to call the operator explicitly, | |
| 23153 // because MSVC has problems otherwise. | |
| 23154 JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type)) | |
| 23155 } | |
| 23156 | |
| 23157 /// @brief comparison: less than | |
| 23158 /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/ | |
| 23159 template<typename ScalarType, typename std::enable_if< | |
| 23160 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23161 friend bool operator<(const_reference lhs, ScalarType rhs) noexcept | |
| 23162 { | |
| 23163 return lhs < basic_json(rhs); | |
| 23164 } | |
| 23165 | |
| 23166 /// @brief comparison: less than | |
| 23167 /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/ | |
| 23168 template<typename ScalarType, typename std::enable_if< | |
| 23169 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23170 friend bool operator<(ScalarType lhs, const_reference rhs) noexcept | |
| 23171 { | |
| 23172 return basic_json(lhs) < rhs; | |
| 23173 } | |
| 23174 | |
| 23175 /// @brief comparison: less than or equal | |
| 23176 /// @sa https://json.nlohmann.me/api/basic_json/operator_le/ | |
| 23177 friend bool operator<=(const_reference lhs, const_reference rhs) noexcept | |
| 23178 { | |
| 23179 if (compares_unordered(lhs, rhs, true)) | |
| 23180 { | |
| 23181 return false; | |
| 23182 } | |
| 23183 return !(rhs < lhs); | |
| 23184 } | |
| 23185 | |
| 23186 /// @brief comparison: less than or equal | |
| 23187 /// @sa https://json.nlohmann.me/api/basic_json/operator_le/ | |
| 23188 template<typename ScalarType, typename std::enable_if< | |
| 23189 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23190 friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept | |
| 23191 { | |
| 23192 return lhs <= basic_json(rhs); | |
| 23193 } | |
| 23194 | |
| 23195 /// @brief comparison: less than or equal | |
| 23196 /// @sa https://json.nlohmann.me/api/basic_json/operator_le/ | |
| 23197 template<typename ScalarType, typename std::enable_if< | |
| 23198 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23199 friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept | |
| 23200 { | |
| 23201 return basic_json(lhs) <= rhs; | |
| 23202 } | |
| 23203 | |
| 23204 /// @brief comparison: greater than | |
| 23205 /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/ | |
| 23206 friend bool operator>(const_reference lhs, const_reference rhs) noexcept | |
| 23207 { | |
| 23208 // double inverse | |
| 23209 if (compares_unordered(lhs, rhs)) | |
| 23210 { | |
| 23211 return false; | |
| 23212 } | |
| 23213 return !(lhs <= rhs); | |
| 23214 } | |
| 23215 | |
| 23216 /// @brief comparison: greater than | |
| 23217 /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/ | |
| 23218 template<typename ScalarType, typename std::enable_if< | |
| 23219 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23220 friend bool operator>(const_reference lhs, ScalarType rhs) noexcept | |
| 23221 { | |
| 23222 return lhs > basic_json(rhs); | |
| 23223 } | |
| 23224 | |
| 23225 /// @brief comparison: greater than | |
| 23226 /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/ | |
| 23227 template<typename ScalarType, typename std::enable_if< | |
| 23228 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23229 friend bool operator>(ScalarType lhs, const_reference rhs) noexcept | |
| 23230 { | |
| 23231 return basic_json(lhs) > rhs; | |
| 23232 } | |
| 23233 | |
| 23234 /// @brief comparison: greater than or equal | |
| 23235 /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/ | |
| 23236 friend bool operator>=(const_reference lhs, const_reference rhs) noexcept | |
| 23237 { | |
| 23238 if (compares_unordered(lhs, rhs, true)) | |
| 23239 { | |
| 23240 return false; | |
| 23241 } | |
| 23242 return !(lhs < rhs); | |
| 23243 } | |
| 23244 | |
| 23245 /// @brief comparison: greater than or equal | |
| 23246 /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/ | |
| 23247 template<typename ScalarType, typename std::enable_if< | |
| 23248 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23249 friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept | |
| 23250 { | |
| 23251 return lhs >= basic_json(rhs); | |
| 23252 } | |
| 23253 | |
| 23254 /// @brief comparison: greater than or equal | |
| 23255 /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/ | |
| 23256 template<typename ScalarType, typename std::enable_if< | |
| 23257 std::is_scalar<ScalarType>::value, int>::type = 0> | |
| 23258 friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept | |
| 23259 { | |
| 23260 return basic_json(lhs) >= rhs; | |
| 23261 } | |
| 23262 #endif | |
| 23263 | |
| 23264 #undef JSON_IMPLEMENT_OPERATOR | |
| 23265 | |
| 23266 /// @} | |
| 23267 | |
| 23268 /////////////////// | |
| 23269 // serialization // | |
| 23270 /////////////////// | |
| 23271 | |
| 23272 /// @name serialization | |
| 23273 /// @{ | |
| 23274 #ifndef JSON_NO_IO | |
| 23275 /// @brief serialize to stream | |
| 23276 /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/ | |
| 23277 friend std::ostream& operator<<(std::ostream& o, const basic_json& j) | |
| 23278 { | |
| 23279 // read width member and use it as indentation parameter if nonzero | |
| 23280 const bool pretty_print = o.width() > 0; | |
| 23281 const auto indentation = pretty_print ? o.width() : 0; | |
| 23282 | |
| 23283 // reset width to 0 for subsequent calls to this stream | |
| 23284 o.width(0); | |
| 23285 | |
| 23286 // do the actual serialization | |
| 23287 serializer s(detail::output_adapter<char>(o), o.fill()); | |
| 23288 s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation)); | |
| 23289 return o; | |
| 23290 } | |
| 23291 | |
| 23292 /// @brief serialize to stream | |
| 23293 /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/ | |
| 23294 /// @deprecated This function is deprecated since 3.0.0 and will be removed in | |
| 23295 /// version 4.0.0 of the library. Please use | |
| 23296 /// operator<<(std::ostream&, const basic_json&) instead; that is, | |
| 23297 /// replace calls like `j >> o;` with `o << j;`. | |
| 23298 JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&)) | |
| 23299 friend std::ostream& operator>>(const basic_json& j, std::ostream& o) | |
| 23300 { | |
| 23301 return o << j; | |
| 23302 } | |
| 23303 #endif // JSON_NO_IO | |
| 23304 /// @} | |
| 23305 | |
| 23306 ///////////////////// | |
| 23307 // deserialization // | |
| 23308 ///////////////////// | |
| 23309 | |
| 23310 /// @name deserialization | |
| 23311 /// @{ | |
| 23312 | |
| 23313 /// @brief deserialize from a compatible input | |
| 23314 /// @sa https://json.nlohmann.me/api/basic_json/parse/ | |
| 23315 template<typename InputType> | |
| 23316 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23317 static basic_json parse(InputType&& i, | |
| 23318 const parser_callback_t cb = nullptr, | |
| 23319 const bool allow_exceptions = true, | |
| 23320 const bool ignore_comments = false) | |
| 23321 { | |
| 23322 basic_json result; | |
| 23323 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result); | |
| 23324 return result; | |
| 23325 } | |
| 23326 | |
| 23327 /// @brief deserialize from a pair of character iterators | |
| 23328 /// @sa https://json.nlohmann.me/api/basic_json/parse/ | |
| 23329 template<typename IteratorType> | |
| 23330 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23331 static basic_json parse(IteratorType first, | |
| 23332 IteratorType last, | |
| 23333 const parser_callback_t cb = nullptr, | |
| 23334 const bool allow_exceptions = true, | |
| 23335 const bool ignore_comments = false) | |
| 23336 { | |
| 23337 basic_json result; | |
| 23338 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result); | |
| 23339 return result; | |
| 23340 } | |
| 23341 | |
| 23342 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23343 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len)) | |
| 23344 static basic_json parse(detail::span_input_adapter&& i, | |
| 23345 const parser_callback_t cb = nullptr, | |
| 23346 const bool allow_exceptions = true, | |
| 23347 const bool ignore_comments = false) | |
| 23348 { | |
| 23349 basic_json result; | |
| 23350 parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result); | |
| 23351 return result; | |
| 23352 } | |
| 23353 | |
| 23354 /// @brief check if the input is valid JSON | |
| 23355 /// @sa https://json.nlohmann.me/api/basic_json/accept/ | |
| 23356 template<typename InputType> | |
| 23357 static bool accept(InputType&& i, | |
| 23358 const bool ignore_comments = false) | |
| 23359 { | |
| 23360 return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true); | |
| 23361 } | |
| 23362 | |
| 23363 /// @brief check if the input is valid JSON | |
| 23364 /// @sa https://json.nlohmann.me/api/basic_json/accept/ | |
| 23365 template<typename IteratorType> | |
| 23366 static bool accept(IteratorType first, IteratorType last, | |
| 23367 const bool ignore_comments = false) | |
| 23368 { | |
| 23369 return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true); | |
| 23370 } | |
| 23371 | |
| 23372 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23373 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len)) | |
| 23374 static bool accept(detail::span_input_adapter&& i, | |
| 23375 const bool ignore_comments = false) | |
| 23376 { | |
| 23377 return parser(i.get(), nullptr, false, ignore_comments).accept(true); | |
| 23378 } | |
| 23379 | |
| 23380 /// @brief generate SAX events | |
| 23381 /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/ | |
| 23382 template <typename InputType, typename SAX> | |
| 23383 JSON_HEDLEY_NON_NULL(2) | |
| 23384 static bool sax_parse(InputType&& i, SAX* sax, | |
| 23385 input_format_t format = input_format_t::json, | |
| 23386 const bool strict = true, | |
| 23387 const bool ignore_comments = false) | |
| 23388 { | |
| 23389 auto ia = detail::input_adapter(std::forward<InputType>(i)); | |
| 23390 return format == input_format_t::json | |
| 23391 ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict) | |
| 23392 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict); | |
| 23393 } | |
| 23394 | |
| 23395 /// @brief generate SAX events | |
| 23396 /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/ | |
| 23397 template<class IteratorType, class SAX> | |
| 23398 JSON_HEDLEY_NON_NULL(3) | |
| 23399 static bool sax_parse(IteratorType first, IteratorType last, SAX* sax, | |
| 23400 input_format_t format = input_format_t::json, | |
| 23401 const bool strict = true, | |
| 23402 const bool ignore_comments = false) | |
| 23403 { | |
| 23404 auto ia = detail::input_adapter(std::move(first), std::move(last)); | |
| 23405 return format == input_format_t::json | |
| 23406 ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict) | |
| 23407 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict); | |
| 23408 } | |
| 23409 | |
| 23410 /// @brief generate SAX events | |
| 23411 /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/ | |
| 23412 /// @deprecated This function is deprecated since 3.8.0 and will be removed in | |
| 23413 /// version 4.0.0 of the library. Please use | |
| 23414 /// sax_parse(ptr, ptr + len) instead. | |
| 23415 template <typename SAX> | |
| 23416 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...)) | |
| 23417 JSON_HEDLEY_NON_NULL(2) | |
| 23418 static bool sax_parse(detail::span_input_adapter&& i, SAX* sax, | |
| 23419 input_format_t format = input_format_t::json, | |
| 23420 const bool strict = true, | |
| 23421 const bool ignore_comments = false) | |
| 23422 { | |
| 23423 auto ia = i.get(); | |
| 23424 return format == input_format_t::json | |
| 23425 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) | |
| 23426 ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict) | |
| 23427 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) | |
| 23428 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict); | |
| 23429 } | |
| 23430 #ifndef JSON_NO_IO | |
| 23431 /// @brief deserialize from stream | |
| 23432 /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/ | |
| 23433 /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in | |
| 23434 /// version 4.0.0 of the library. Please use | |
| 23435 /// operator>>(std::istream&, basic_json&) instead; that is, | |
| 23436 /// replace calls like `j << i;` with `i >> j;`. | |
| 23437 JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&)) | |
| 23438 friend std::istream& operator<<(basic_json& j, std::istream& i) | |
| 23439 { | |
| 23440 return operator>>(i, j); | |
| 23441 } | |
| 23442 | |
| 23443 /// @brief deserialize from stream | |
| 23444 /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/ | |
| 23445 friend std::istream& operator>>(std::istream& i, basic_json& j) | |
| 23446 { | |
| 23447 parser(detail::input_adapter(i)).parse(false, j); | |
| 23448 return i; | |
| 23449 } | |
| 23450 #endif // JSON_NO_IO | |
| 23451 /// @} | |
| 23452 | |
| 23453 /////////////////////////// | |
| 23454 // convenience functions // | |
| 23455 /////////////////////////// | |
| 23456 | |
| 23457 /// @brief return the type as string | |
| 23458 /// @sa https://json.nlohmann.me/api/basic_json/type_name/ | |
| 23459 JSON_HEDLEY_RETURNS_NON_NULL | |
| 23460 const char* type_name() const noexcept | |
| 23461 { | |
| 23462 switch (m_data.m_type) | |
| 23463 { | |
| 23464 case value_t::null: | |
| 23465 return "null"; | |
| 23466 case value_t::object: | |
| 23467 return "object"; | |
| 23468 case value_t::array: | |
| 23469 return "array"; | |
| 23470 case value_t::string: | |
| 23471 return "string"; | |
| 23472 case value_t::boolean: | |
| 23473 return "boolean"; | |
| 23474 case value_t::binary: | |
| 23475 return "binary"; | |
| 23476 case value_t::discarded: | |
| 23477 return "discarded"; | |
| 23478 case value_t::number_integer: | |
| 23479 case value_t::number_unsigned: | |
| 23480 case value_t::number_float: | |
| 23481 default: | |
| 23482 return "number"; | |
| 23483 } | |
| 23484 } | |
| 23485 | |
| 23486 JSON_PRIVATE_UNLESS_TESTED: | |
| 23487 ////////////////////// | |
| 23488 // member variables // | |
| 23489 ////////////////////// | |
| 23490 | |
| 23491 struct data | |
| 23492 { | |
| 23493 /// the type of the current element | |
| 23494 value_t m_type = value_t::null; | |
| 23495 | |
| 23496 /// the value of the current element | |
| 23497 json_value m_value = {}; | |
| 23498 | |
| 23499 data(const value_t v) | |
| 23500 : m_type(v), m_value(v) | |
| 23501 { | |
| 23502 } | |
| 23503 | |
| 23504 data(size_type cnt, const basic_json& val) | |
| 23505 : m_type(value_t::array) | |
| 23506 { | |
| 23507 m_value.array = create<array_t>(cnt, val); | |
| 23508 } | |
| 23509 | |
| 23510 data() noexcept = default; | |
| 23511 data(data&&) noexcept = default; | |
| 23512 data(const data&) noexcept = delete; | |
| 23513 data& operator=(data&&) noexcept = delete; | |
| 23514 data& operator=(const data&) noexcept = delete; | |
| 23515 | |
| 23516 ~data() noexcept | |
| 23517 { | |
| 23518 m_value.destroy(m_type); | |
| 23519 } | |
| 23520 }; | |
| 23521 | |
| 23522 data m_data = {}; | |
| 23523 | |
| 23524 #if JSON_DIAGNOSTICS | |
| 23525 /// a pointer to a parent value (for debugging purposes) | |
| 23526 basic_json* m_parent = nullptr; | |
| 23527 #endif | |
| 23528 | |
| 23529 ////////////////////////////////////////// | |
| 23530 // binary serialization/deserialization // | |
| 23531 ////////////////////////////////////////// | |
| 23532 | |
| 23533 /// @name binary serialization/deserialization support | |
| 23534 /// @{ | |
| 23535 | |
| 23536 public: | |
| 23537 /// @brief create a CBOR serialization of a given JSON value | |
| 23538 /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/ | |
| 23539 static std::vector<std::uint8_t> to_cbor(const basic_json& j) | |
| 23540 { | |
| 23541 std::vector<std::uint8_t> result; | |
| 23542 to_cbor(j, result); | |
| 23543 return result; | |
| 23544 } | |
| 23545 | |
| 23546 /// @brief create a CBOR serialization of a given JSON value | |
| 23547 /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/ | |
| 23548 static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o) | |
| 23549 { | |
| 23550 binary_writer<std::uint8_t>(o).write_cbor(j); | |
| 23551 } | |
| 23552 | |
| 23553 /// @brief create a CBOR serialization of a given JSON value | |
| 23554 /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/ | |
| 23555 static void to_cbor(const basic_json& j, detail::output_adapter<char> o) | |
| 23556 { | |
| 23557 binary_writer<char>(o).write_cbor(j); | |
| 23558 } | |
| 23559 | |
| 23560 /// @brief create a MessagePack serialization of a given JSON value | |
| 23561 /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/ | |
| 23562 static std::vector<std::uint8_t> to_msgpack(const basic_json& j) | |
| 23563 { | |
| 23564 std::vector<std::uint8_t> result; | |
| 23565 to_msgpack(j, result); | |
| 23566 return result; | |
| 23567 } | |
| 23568 | |
| 23569 /// @brief create a MessagePack serialization of a given JSON value | |
| 23570 /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/ | |
| 23571 static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o) | |
| 23572 { | |
| 23573 binary_writer<std::uint8_t>(o).write_msgpack(j); | |
| 23574 } | |
| 23575 | |
| 23576 /// @brief create a MessagePack serialization of a given JSON value | |
| 23577 /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/ | |
| 23578 static void to_msgpack(const basic_json& j, detail::output_adapter<char> o) | |
| 23579 { | |
| 23580 binary_writer<char>(o).write_msgpack(j); | |
| 23581 } | |
| 23582 | |
| 23583 /// @brief create a UBJSON serialization of a given JSON value | |
| 23584 /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/ | |
| 23585 static std::vector<std::uint8_t> to_ubjson(const basic_json& j, | |
| 23586 const bool use_size = false, | |
| 23587 const bool use_type = false) | |
| 23588 { | |
| 23589 std::vector<std::uint8_t> result; | |
| 23590 to_ubjson(j, result, use_size, use_type); | |
| 23591 return result; | |
| 23592 } | |
| 23593 | |
| 23594 /// @brief create a UBJSON serialization of a given JSON value | |
| 23595 /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/ | |
| 23596 static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o, | |
| 23597 const bool use_size = false, const bool use_type = false) | |
| 23598 { | |
| 23599 binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type); | |
| 23600 } | |
| 23601 | |
| 23602 /// @brief create a UBJSON serialization of a given JSON value | |
| 23603 /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/ | |
| 23604 static void to_ubjson(const basic_json& j, detail::output_adapter<char> o, | |
| 23605 const bool use_size = false, const bool use_type = false) | |
| 23606 { | |
| 23607 binary_writer<char>(o).write_ubjson(j, use_size, use_type); | |
| 23608 } | |
| 23609 | |
| 23610 /// @brief create a BJData serialization of a given JSON value | |
| 23611 /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/ | |
| 23612 static std::vector<std::uint8_t> to_bjdata(const basic_json& j, | |
| 23613 const bool use_size = false, | |
| 23614 const bool use_type = false) | |
| 23615 { | |
| 23616 std::vector<std::uint8_t> result; | |
| 23617 to_bjdata(j, result, use_size, use_type); | |
| 23618 return result; | |
| 23619 } | |
| 23620 | |
| 23621 /// @brief create a BJData serialization of a given JSON value | |
| 23622 /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/ | |
| 23623 static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o, | |
| 23624 const bool use_size = false, const bool use_type = false) | |
| 23625 { | |
| 23626 binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true); | |
| 23627 } | |
| 23628 | |
| 23629 /// @brief create a BJData serialization of a given JSON value | |
| 23630 /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/ | |
| 23631 static void to_bjdata(const basic_json& j, detail::output_adapter<char> o, | |
| 23632 const bool use_size = false, const bool use_type = false) | |
| 23633 { | |
| 23634 binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true); | |
| 23635 } | |
| 23636 | |
| 23637 /// @brief create a BSON serialization of a given JSON value | |
| 23638 /// @sa https://json.nlohmann.me/api/basic_json/to_bson/ | |
| 23639 static std::vector<std::uint8_t> to_bson(const basic_json& j) | |
| 23640 { | |
| 23641 std::vector<std::uint8_t> result; | |
| 23642 to_bson(j, result); | |
| 23643 return result; | |
| 23644 } | |
| 23645 | |
| 23646 /// @brief create a BSON serialization of a given JSON value | |
| 23647 /// @sa https://json.nlohmann.me/api/basic_json/to_bson/ | |
| 23648 static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o) | |
| 23649 { | |
| 23650 binary_writer<std::uint8_t>(o).write_bson(j); | |
| 23651 } | |
| 23652 | |
| 23653 /// @brief create a BSON serialization of a given JSON value | |
| 23654 /// @sa https://json.nlohmann.me/api/basic_json/to_bson/ | |
| 23655 static void to_bson(const basic_json& j, detail::output_adapter<char> o) | |
| 23656 { | |
| 23657 binary_writer<char>(o).write_bson(j); | |
| 23658 } | |
| 23659 | |
| 23660 /// @brief create a JSON value from an input in CBOR format | |
| 23661 /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/ | |
| 23662 template<typename InputType> | |
| 23663 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23664 static basic_json from_cbor(InputType&& i, | |
| 23665 const bool strict = true, | |
| 23666 const bool allow_exceptions = true, | |
| 23667 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) | |
| 23668 { | |
| 23669 basic_json result; | |
| 23670 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23671 auto ia = detail::input_adapter(std::forward<InputType>(i)); | |
| 23672 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); | |
| 23673 return res ? result : basic_json(value_t::discarded); | |
| 23674 } | |
| 23675 | |
| 23676 /// @brief create a JSON value from an input in CBOR format | |
| 23677 /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/ | |
| 23678 template<typename IteratorType> | |
| 23679 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23680 static basic_json from_cbor(IteratorType first, IteratorType last, | |
| 23681 const bool strict = true, | |
| 23682 const bool allow_exceptions = true, | |
| 23683 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) | |
| 23684 { | |
| 23685 basic_json result; | |
| 23686 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23687 auto ia = detail::input_adapter(std::move(first), std::move(last)); | |
| 23688 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); | |
| 23689 return res ? result : basic_json(value_t::discarded); | |
| 23690 } | |
| 23691 | |
| 23692 template<typename T> | |
| 23693 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23694 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) | |
| 23695 static basic_json from_cbor(const T* ptr, std::size_t len, | |
| 23696 const bool strict = true, | |
| 23697 const bool allow_exceptions = true, | |
| 23698 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) | |
| 23699 { | |
| 23700 return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler); | |
| 23701 } | |
| 23702 | |
| 23703 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23704 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len)) | |
| 23705 static basic_json from_cbor(detail::span_input_adapter&& i, | |
| 23706 const bool strict = true, | |
| 23707 const bool allow_exceptions = true, | |
| 23708 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error) | |
| 23709 { | |
| 23710 basic_json result; | |
| 23711 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23712 auto ia = i.get(); | |
| 23713 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) | |
| 23714 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); | |
| 23715 return res ? result : basic_json(value_t::discarded); | |
| 23716 } | |
| 23717 | |
| 23718 /// @brief create a JSON value from an input in MessagePack format | |
| 23719 /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/ | |
| 23720 template<typename InputType> | |
| 23721 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23722 static basic_json from_msgpack(InputType&& i, | |
| 23723 const bool strict = true, | |
| 23724 const bool allow_exceptions = true) | |
| 23725 { | |
| 23726 basic_json result; | |
| 23727 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23728 auto ia = detail::input_adapter(std::forward<InputType>(i)); | |
| 23729 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); | |
| 23730 return res ? result : basic_json(value_t::discarded); | |
| 23731 } | |
| 23732 | |
| 23733 /// @brief create a JSON value from an input in MessagePack format | |
| 23734 /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/ | |
| 23735 template<typename IteratorType> | |
| 23736 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23737 static basic_json from_msgpack(IteratorType first, IteratorType last, | |
| 23738 const bool strict = true, | |
| 23739 const bool allow_exceptions = true) | |
| 23740 { | |
| 23741 basic_json result; | |
| 23742 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23743 auto ia = detail::input_adapter(std::move(first), std::move(last)); | |
| 23744 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); | |
| 23745 return res ? result : basic_json(value_t::discarded); | |
| 23746 } | |
| 23747 | |
| 23748 template<typename T> | |
| 23749 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23750 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len)) | |
| 23751 static basic_json from_msgpack(const T* ptr, std::size_t len, | |
| 23752 const bool strict = true, | |
| 23753 const bool allow_exceptions = true) | |
| 23754 { | |
| 23755 return from_msgpack(ptr, ptr + len, strict, allow_exceptions); | |
| 23756 } | |
| 23757 | |
| 23758 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23759 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len)) | |
| 23760 static basic_json from_msgpack(detail::span_input_adapter&& i, | |
| 23761 const bool strict = true, | |
| 23762 const bool allow_exceptions = true) | |
| 23763 { | |
| 23764 basic_json result; | |
| 23765 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23766 auto ia = i.get(); | |
| 23767 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) | |
| 23768 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); | |
| 23769 return res ? result : basic_json(value_t::discarded); | |
| 23770 } | |
| 23771 | |
| 23772 /// @brief create a JSON value from an input in UBJSON format | |
| 23773 /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/ | |
| 23774 template<typename InputType> | |
| 23775 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23776 static basic_json from_ubjson(InputType&& i, | |
| 23777 const bool strict = true, | |
| 23778 const bool allow_exceptions = true) | |
| 23779 { | |
| 23780 basic_json result; | |
| 23781 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23782 auto ia = detail::input_adapter(std::forward<InputType>(i)); | |
| 23783 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); | |
| 23784 return res ? result : basic_json(value_t::discarded); | |
| 23785 } | |
| 23786 | |
| 23787 /// @brief create a JSON value from an input in UBJSON format | |
| 23788 /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/ | |
| 23789 template<typename IteratorType> | |
| 23790 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23791 static basic_json from_ubjson(IteratorType first, IteratorType last, | |
| 23792 const bool strict = true, | |
| 23793 const bool allow_exceptions = true) | |
| 23794 { | |
| 23795 basic_json result; | |
| 23796 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23797 auto ia = detail::input_adapter(std::move(first), std::move(last)); | |
| 23798 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); | |
| 23799 return res ? result : basic_json(value_t::discarded); | |
| 23800 } | |
| 23801 | |
| 23802 template<typename T> | |
| 23803 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23804 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len)) | |
| 23805 static basic_json from_ubjson(const T* ptr, std::size_t len, | |
| 23806 const bool strict = true, | |
| 23807 const bool allow_exceptions = true) | |
| 23808 { | |
| 23809 return from_ubjson(ptr, ptr + len, strict, allow_exceptions); | |
| 23810 } | |
| 23811 | |
| 23812 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23813 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len)) | |
| 23814 static basic_json from_ubjson(detail::span_input_adapter&& i, | |
| 23815 const bool strict = true, | |
| 23816 const bool allow_exceptions = true) | |
| 23817 { | |
| 23818 basic_json result; | |
| 23819 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23820 auto ia = i.get(); | |
| 23821 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) | |
| 23822 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); | |
| 23823 return res ? result : basic_json(value_t::discarded); | |
| 23824 } | |
| 23825 | |
| 23826 /// @brief create a JSON value from an input in BJData format | |
| 23827 /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/ | |
| 23828 template<typename InputType> | |
| 23829 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23830 static basic_json from_bjdata(InputType&& i, | |
| 23831 const bool strict = true, | |
| 23832 const bool allow_exceptions = true) | |
| 23833 { | |
| 23834 basic_json result; | |
| 23835 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23836 auto ia = detail::input_adapter(std::forward<InputType>(i)); | |
| 23837 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); | |
| 23838 return res ? result : basic_json(value_t::discarded); | |
| 23839 } | |
| 23840 | |
| 23841 /// @brief create a JSON value from an input in BJData format | |
| 23842 /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/ | |
| 23843 template<typename IteratorType> | |
| 23844 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23845 static basic_json from_bjdata(IteratorType first, IteratorType last, | |
| 23846 const bool strict = true, | |
| 23847 const bool allow_exceptions = true) | |
| 23848 { | |
| 23849 basic_json result; | |
| 23850 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23851 auto ia = detail::input_adapter(std::move(first), std::move(last)); | |
| 23852 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); | |
| 23853 return res ? result : basic_json(value_t::discarded); | |
| 23854 } | |
| 23855 | |
| 23856 /// @brief create a JSON value from an input in BSON format | |
| 23857 /// @sa https://json.nlohmann.me/api/basic_json/from_bson/ | |
| 23858 template<typename InputType> | |
| 23859 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23860 static basic_json from_bson(InputType&& i, | |
| 23861 const bool strict = true, | |
| 23862 const bool allow_exceptions = true) | |
| 23863 { | |
| 23864 basic_json result; | |
| 23865 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23866 auto ia = detail::input_adapter(std::forward<InputType>(i)); | |
| 23867 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); | |
| 23868 return res ? result : basic_json(value_t::discarded); | |
| 23869 } | |
| 23870 | |
| 23871 /// @brief create a JSON value from an input in BSON format | |
| 23872 /// @sa https://json.nlohmann.me/api/basic_json/from_bson/ | |
| 23873 template<typename IteratorType> | |
| 23874 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23875 static basic_json from_bson(IteratorType first, IteratorType last, | |
| 23876 const bool strict = true, | |
| 23877 const bool allow_exceptions = true) | |
| 23878 { | |
| 23879 basic_json result; | |
| 23880 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23881 auto ia = detail::input_adapter(std::move(first), std::move(last)); | |
| 23882 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); | |
| 23883 return res ? result : basic_json(value_t::discarded); | |
| 23884 } | |
| 23885 | |
| 23886 template<typename T> | |
| 23887 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23888 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) | |
| 23889 static basic_json from_bson(const T* ptr, std::size_t len, | |
| 23890 const bool strict = true, | |
| 23891 const bool allow_exceptions = true) | |
| 23892 { | |
| 23893 return from_bson(ptr, ptr + len, strict, allow_exceptions); | |
| 23894 } | |
| 23895 | |
| 23896 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 23897 JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len)) | |
| 23898 static basic_json from_bson(detail::span_input_adapter&& i, | |
| 23899 const bool strict = true, | |
| 23900 const bool allow_exceptions = true) | |
| 23901 { | |
| 23902 basic_json result; | |
| 23903 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions); | |
| 23904 auto ia = i.get(); | |
| 23905 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg) | |
| 23906 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); | |
| 23907 return res ? result : basic_json(value_t::discarded); | |
| 23908 } | |
| 23909 /// @} | |
| 23910 | |
| 23911 ////////////////////////// | |
| 23912 // JSON Pointer support // | |
| 23913 ////////////////////////// | |
| 23914 | |
| 23915 /// @name JSON Pointer functions | |
| 23916 /// @{ | |
| 23917 | |
| 23918 /// @brief access specified element via JSON Pointer | |
| 23919 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 23920 reference operator[](const json_pointer& ptr) | |
| 23921 { | |
| 23922 return ptr.get_unchecked(this); | |
| 23923 } | |
| 23924 | |
| 23925 template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0> | |
| 23926 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 23927 reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) | |
| 23928 { | |
| 23929 return ptr.get_unchecked(this); | |
| 23930 } | |
| 23931 | |
| 23932 /// @brief access specified element via JSON Pointer | |
| 23933 /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/ | |
| 23934 const_reference operator[](const json_pointer& ptr) const | |
| 23935 { | |
| 23936 return ptr.get_unchecked(this); | |
| 23937 } | |
| 23938 | |
| 23939 template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0> | |
| 23940 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 23941 const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const | |
| 23942 { | |
| 23943 return ptr.get_unchecked(this); | |
| 23944 } | |
| 23945 | |
| 23946 /// @brief access specified element via JSON Pointer | |
| 23947 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 23948 reference at(const json_pointer& ptr) | |
| 23949 { | |
| 23950 return ptr.get_checked(this); | |
| 23951 } | |
| 23952 | |
| 23953 template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0> | |
| 23954 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 23955 reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) | |
| 23956 { | |
| 23957 return ptr.get_checked(this); | |
| 23958 } | |
| 23959 | |
| 23960 /// @brief access specified element via JSON Pointer | |
| 23961 /// @sa https://json.nlohmann.me/api/basic_json/at/ | |
| 23962 const_reference at(const json_pointer& ptr) const | |
| 23963 { | |
| 23964 return ptr.get_checked(this); | |
| 23965 } | |
| 23966 | |
| 23967 template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0> | |
| 23968 JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens) | |
| 23969 const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const | |
| 23970 { | |
| 23971 return ptr.get_checked(this); | |
| 23972 } | |
| 23973 | |
| 23974 /// @brief return flattened JSON value | |
| 23975 /// @sa https://json.nlohmann.me/api/basic_json/flatten/ | |
| 23976 basic_json flatten() const | |
| 23977 { | |
| 23978 basic_json result(value_t::object); | |
| 23979 json_pointer::flatten("", *this, result); | |
| 23980 return result; | |
| 23981 } | |
| 23982 | |
| 23983 /// @brief unflatten a previously flattened JSON value | |
| 23984 /// @sa https://json.nlohmann.me/api/basic_json/unflatten/ | |
| 23985 basic_json unflatten() const | |
| 23986 { | |
| 23987 return json_pointer::unflatten(*this); | |
| 23988 } | |
| 23989 | |
| 23990 /// @} | |
| 23991 | |
| 23992 ////////////////////////// | |
| 23993 // JSON Patch functions // | |
| 23994 ////////////////////////// | |
| 23995 | |
| 23996 /// @name JSON Patch functions | |
| 23997 /// @{ | |
| 23998 | |
| 23999 /// @brief applies a JSON patch in-place without copying the object | |
| 24000 /// @sa https://json.nlohmann.me/api/basic_json/patch/ | |
| 24001 void patch_inplace(const basic_json& json_patch) | |
| 24002 { | |
| 24003 basic_json& result = *this; | |
| 24004 // the valid JSON Patch operations | |
| 24005 enum class patch_operations {add, remove, replace, move, copy, test, invalid}; | |
| 24006 | |
| 24007 const auto get_op = [](const std::string & op) | |
| 24008 { | |
| 24009 if (op == "add") | |
| 24010 { | |
| 24011 return patch_operations::add; | |
| 24012 } | |
| 24013 if (op == "remove") | |
| 24014 { | |
| 24015 return patch_operations::remove; | |
| 24016 } | |
| 24017 if (op == "replace") | |
| 24018 { | |
| 24019 return patch_operations::replace; | |
| 24020 } | |
| 24021 if (op == "move") | |
| 24022 { | |
| 24023 return patch_operations::move; | |
| 24024 } | |
| 24025 if (op == "copy") | |
| 24026 { | |
| 24027 return patch_operations::copy; | |
| 24028 } | |
| 24029 if (op == "test") | |
| 24030 { | |
| 24031 return patch_operations::test; | |
| 24032 } | |
| 24033 | |
| 24034 return patch_operations::invalid; | |
| 24035 }; | |
| 24036 | |
| 24037 // wrapper for "add" operation; add value at ptr | |
| 24038 const auto operation_add = [&result](json_pointer & ptr, basic_json val) | |
| 24039 { | |
| 24040 // adding to the root of the target document means replacing it | |
| 24041 if (ptr.empty()) | |
| 24042 { | |
| 24043 result = val; | |
| 24044 return; | |
| 24045 } | |
| 24046 | |
| 24047 // make sure the top element of the pointer exists | |
| 24048 json_pointer const top_pointer = ptr.top(); | |
| 24049 if (top_pointer != ptr) | |
| 24050 { | |
| 24051 result.at(top_pointer); | |
| 24052 } | |
| 24053 | |
| 24054 // get reference to parent of JSON pointer ptr | |
| 24055 const auto last_path = ptr.back(); | |
| 24056 ptr.pop_back(); | |
| 24057 // parent must exist when performing patch add per RFC6902 specs | |
| 24058 basic_json& parent = result.at(ptr); | |
| 24059 | |
| 24060 switch (parent.m_data.m_type) | |
| 24061 { | |
| 24062 case value_t::null: | |
| 24063 case value_t::object: | |
| 24064 { | |
| 24065 // use operator[] to add value | |
| 24066 parent[last_path] = val; | |
| 24067 break; | |
| 24068 } | |
| 24069 | |
| 24070 case value_t::array: | |
| 24071 { | |
| 24072 if (last_path == "-") | |
| 24073 { | |
| 24074 // special case: append to back | |
| 24075 parent.push_back(val); | |
| 24076 } | |
| 24077 else | |
| 24078 { | |
| 24079 const auto idx = json_pointer::template array_index<basic_json_t>(last_path); | |
| 24080 if (JSON_HEDLEY_UNLIKELY(idx > parent.size())) | |
| 24081 { | |
| 24082 // avoid undefined behavior | |
| 24083 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent)); | |
| 24084 } | |
| 24085 | |
| 24086 // default case: insert add offset | |
| 24087 parent.insert(parent.begin() + static_cast<difference_type>(idx), val); | |
| 24088 } | |
| 24089 break; | |
| 24090 } | |
| 24091 | |
| 24092 // if there exists a parent it cannot be primitive | |
| 24093 case value_t::string: // LCOV_EXCL_LINE | |
| 24094 case value_t::boolean: // LCOV_EXCL_LINE | |
| 24095 case value_t::number_integer: // LCOV_EXCL_LINE | |
| 24096 case value_t::number_unsigned: // LCOV_EXCL_LINE | |
| 24097 case value_t::number_float: // LCOV_EXCL_LINE | |
| 24098 case value_t::binary: // LCOV_EXCL_LINE | |
| 24099 case value_t::discarded: // LCOV_EXCL_LINE | |
| 24100 default: // LCOV_EXCL_LINE | |
| 24101 JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE | |
| 24102 } | |
| 24103 }; | |
| 24104 | |
| 24105 // wrapper for "remove" operation; remove value at ptr | |
| 24106 const auto operation_remove = [this, & result](json_pointer & ptr) | |
| 24107 { | |
| 24108 // get reference to parent of JSON pointer ptr | |
| 24109 const auto last_path = ptr.back(); | |
| 24110 ptr.pop_back(); | |
| 24111 basic_json& parent = result.at(ptr); | |
| 24112 | |
| 24113 // remove child | |
| 24114 if (parent.is_object()) | |
| 24115 { | |
| 24116 // perform range check | |
| 24117 auto it = parent.find(last_path); | |
| 24118 if (JSON_HEDLEY_LIKELY(it != parent.end())) | |
| 24119 { | |
| 24120 parent.erase(it); | |
| 24121 } | |
| 24122 else | |
| 24123 { | |
| 24124 JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this)); | |
| 24125 } | |
| 24126 } | |
| 24127 else if (parent.is_array()) | |
| 24128 { | |
| 24129 // note erase performs range check | |
| 24130 parent.erase(json_pointer::template array_index<basic_json_t>(last_path)); | |
| 24131 } | |
| 24132 }; | |
| 24133 | |
| 24134 // type check: top level value must be an array | |
| 24135 if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array())) | |
| 24136 { | |
| 24137 JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch)); | |
| 24138 } | |
| 24139 | |
| 24140 // iterate and apply the operations | |
| 24141 for (const auto& val : json_patch) | |
| 24142 { | |
| 24143 // wrapper to get a value for an operation | |
| 24144 const auto get_value = [&val](const std::string & op, | |
| 24145 const std::string & member, | |
| 24146 bool string_type) -> basic_json & | |
| 24147 { | |
| 24148 // find value | |
| 24149 auto it = val.m_data.m_value.object->find(member); | |
| 24150 | |
| 24151 // context-sensitive error message | |
| 24152 const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\''); | |
| 24153 | |
| 24154 // check if desired value is present | |
| 24155 if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end())) | |
| 24156 { | |
| 24157 // NOLINTNEXTLINE(performance-inefficient-string-concatenation) | |
| 24158 JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val)); | |
| 24159 } | |
| 24160 | |
| 24161 // check if result is of type string | |
| 24162 if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string())) | |
| 24163 { | |
| 24164 // NOLINTNEXTLINE(performance-inefficient-string-concatenation) | |
| 24165 JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val)); | |
| 24166 } | |
| 24167 | |
| 24168 // no error: return value | |
| 24169 return it->second; | |
| 24170 }; | |
| 24171 | |
| 24172 // type check: every element of the array must be an object | |
| 24173 if (JSON_HEDLEY_UNLIKELY(!val.is_object())) | |
| 24174 { | |
| 24175 JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val)); | |
| 24176 } | |
| 24177 | |
| 24178 // collect mandatory members | |
| 24179 const auto op = get_value("op", "op", true).template get<std::string>(); | |
| 24180 const auto path = get_value(op, "path", true).template get<std::string>(); | |
| 24181 json_pointer ptr(path); | |
| 24182 | |
| 24183 switch (get_op(op)) | |
| 24184 { | |
| 24185 case patch_operations::add: | |
| 24186 { | |
| 24187 operation_add(ptr, get_value("add", "value", false)); | |
| 24188 break; | |
| 24189 } | |
| 24190 | |
| 24191 case patch_operations::remove: | |
| 24192 { | |
| 24193 operation_remove(ptr); | |
| 24194 break; | |
| 24195 } | |
| 24196 | |
| 24197 case patch_operations::replace: | |
| 24198 { | |
| 24199 // the "path" location must exist - use at() | |
| 24200 result.at(ptr) = get_value("replace", "value", false); | |
| 24201 break; | |
| 24202 } | |
| 24203 | |
| 24204 case patch_operations::move: | |
| 24205 { | |
| 24206 const auto from_path = get_value("move", "from", true).template get<std::string>(); | |
| 24207 json_pointer from_ptr(from_path); | |
| 24208 | |
| 24209 // the "from" location must exist - use at() | |
| 24210 basic_json const v = result.at(from_ptr); | |
| 24211 | |
| 24212 // The move operation is functionally identical to a | |
| 24213 // "remove" operation on the "from" location, followed | |
| 24214 // immediately by an "add" operation at the target | |
| 24215 // location with the value that was just removed. | |
| 24216 operation_remove(from_ptr); | |
| 24217 operation_add(ptr, v); | |
| 24218 break; | |
| 24219 } | |
| 24220 | |
| 24221 case patch_operations::copy: | |
| 24222 { | |
| 24223 const auto from_path = get_value("copy", "from", true).template get<std::string>(); | |
| 24224 const json_pointer from_ptr(from_path); | |
| 24225 | |
| 24226 // the "from" location must exist - use at() | |
| 24227 basic_json const v = result.at(from_ptr); | |
| 24228 | |
| 24229 // The copy is functionally identical to an "add" | |
| 24230 // operation at the target location using the value | |
| 24231 // specified in the "from" member. | |
| 24232 operation_add(ptr, v); | |
| 24233 break; | |
| 24234 } | |
| 24235 | |
| 24236 case patch_operations::test: | |
| 24237 { | |
| 24238 bool success = false; | |
| 24239 JSON_TRY | |
| 24240 { | |
| 24241 // check if "value" matches the one at "path" | |
| 24242 // the "path" location must exist - use at() | |
| 24243 success = (result.at(ptr) == get_value("test", "value", false)); | |
| 24244 } | |
| 24245 JSON_INTERNAL_CATCH (out_of_range&) | |
| 24246 { | |
| 24247 // ignore out of range errors: success remains false | |
| 24248 } | |
| 24249 | |
| 24250 // throw an exception if test fails | |
| 24251 if (JSON_HEDLEY_UNLIKELY(!success)) | |
| 24252 { | |
| 24253 JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val)); | |
| 24254 } | |
| 24255 | |
| 24256 break; | |
| 24257 } | |
| 24258 | |
| 24259 case patch_operations::invalid: | |
| 24260 default: | |
| 24261 { | |
| 24262 // op must be "add", "remove", "replace", "move", "copy", or | |
| 24263 // "test" | |
| 24264 JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val)); | |
| 24265 } | |
| 24266 } | |
| 24267 } | |
| 24268 } | |
| 24269 | |
| 24270 /// @brief applies a JSON patch to a copy of the current object | |
| 24271 /// @sa https://json.nlohmann.me/api/basic_json/patch/ | |
| 24272 basic_json patch(const basic_json& json_patch) const | |
| 24273 { | |
| 24274 basic_json result = *this; | |
| 24275 result.patch_inplace(json_patch); | |
| 24276 return result; | |
| 24277 } | |
| 24278 | |
| 24279 /// @brief creates a diff as a JSON patch | |
| 24280 /// @sa https://json.nlohmann.me/api/basic_json/diff/ | |
| 24281 JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 24282 static basic_json diff(const basic_json& source, const basic_json& target, | |
| 24283 const std::string& path = "") | |
| 24284 { | |
| 24285 // the patch | |
| 24286 basic_json result(value_t::array); | |
| 24287 | |
| 24288 // if the values are the same, return empty patch | |
| 24289 if (source == target) | |
| 24290 { | |
| 24291 return result; | |
| 24292 } | |
| 24293 | |
| 24294 if (source.type() != target.type()) | |
| 24295 { | |
| 24296 // different types: replace value | |
| 24297 result.push_back( | |
| 24298 { | |
| 24299 {"op", "replace"}, {"path", path}, {"value", target} | |
| 24300 }); | |
| 24301 return result; | |
| 24302 } | |
| 24303 | |
| 24304 switch (source.type()) | |
| 24305 { | |
| 24306 case value_t::array: | |
| 24307 { | |
| 24308 // first pass: traverse common elements | |
| 24309 std::size_t i = 0; | |
| 24310 while (i < source.size() && i < target.size()) | |
| 24311 { | |
| 24312 // recursive call to compare array values at index i | |
| 24313 auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i))); | |
| 24314 result.insert(result.end(), temp_diff.begin(), temp_diff.end()); | |
| 24315 ++i; | |
| 24316 } | |
| 24317 | |
| 24318 // We now reached the end of at least one array | |
| 24319 // in a second pass, traverse the remaining elements | |
| 24320 | |
| 24321 // remove my remaining elements | |
| 24322 const auto end_index = static_cast<difference_type>(result.size()); | |
| 24323 while (i < source.size()) | |
| 24324 { | |
| 24325 // add operations in reverse order to avoid invalid | |
| 24326 // indices | |
| 24327 result.insert(result.begin() + end_index, object( | |
| 24328 { | |
| 24329 {"op", "remove"}, | |
| 24330 {"path", detail::concat(path, '/', std::to_string(i))} | |
| 24331 })); | |
| 24332 ++i; | |
| 24333 } | |
| 24334 | |
| 24335 // add other remaining elements | |
| 24336 while (i < target.size()) | |
| 24337 { | |
| 24338 result.push_back( | |
| 24339 { | |
| 24340 {"op", "add"}, | |
| 24341 {"path", detail::concat(path, "/-")}, | |
| 24342 {"value", target[i]} | |
| 24343 }); | |
| 24344 ++i; | |
| 24345 } | |
| 24346 | |
| 24347 break; | |
| 24348 } | |
| 24349 | |
| 24350 case value_t::object: | |
| 24351 { | |
| 24352 // first pass: traverse this object's elements | |
| 24353 for (auto it = source.cbegin(); it != source.cend(); ++it) | |
| 24354 { | |
| 24355 // escape the key name to be used in a JSON patch | |
| 24356 const auto path_key = detail::concat(path, '/', detail::escape(it.key())); | |
| 24357 | |
| 24358 if (target.find(it.key()) != target.end()) | |
| 24359 { | |
| 24360 // recursive call to compare object values at key it | |
| 24361 auto temp_diff = diff(it.value(), target[it.key()], path_key); | |
| 24362 result.insert(result.end(), temp_diff.begin(), temp_diff.end()); | |
| 24363 } | |
| 24364 else | |
| 24365 { | |
| 24366 // found a key that is not in o -> remove it | |
| 24367 result.push_back(object( | |
| 24368 { | |
| 24369 {"op", "remove"}, {"path", path_key} | |
| 24370 })); | |
| 24371 } | |
| 24372 } | |
| 24373 | |
| 24374 // second pass: traverse other object's elements | |
| 24375 for (auto it = target.cbegin(); it != target.cend(); ++it) | |
| 24376 { | |
| 24377 if (source.find(it.key()) == source.end()) | |
| 24378 { | |
| 24379 // found a key that is not in this -> add it | |
| 24380 const auto path_key = detail::concat(path, '/', detail::escape(it.key())); | |
| 24381 result.push_back( | |
| 24382 { | |
| 24383 {"op", "add"}, {"path", path_key}, | |
| 24384 {"value", it.value()} | |
| 24385 }); | |
| 24386 } | |
| 24387 } | |
| 24388 | |
| 24389 break; | |
| 24390 } | |
| 24391 | |
| 24392 case value_t::null: | |
| 24393 case value_t::string: | |
| 24394 case value_t::boolean: | |
| 24395 case value_t::number_integer: | |
| 24396 case value_t::number_unsigned: | |
| 24397 case value_t::number_float: | |
| 24398 case value_t::binary: | |
| 24399 case value_t::discarded: | |
| 24400 default: | |
| 24401 { | |
| 24402 // both primitive type: replace value | |
| 24403 result.push_back( | |
| 24404 { | |
| 24405 {"op", "replace"}, {"path", path}, {"value", target} | |
| 24406 }); | |
| 24407 break; | |
| 24408 } | |
| 24409 } | |
| 24410 | |
| 24411 return result; | |
| 24412 } | |
| 24413 /// @} | |
| 24414 | |
| 24415 //////////////////////////////// | |
| 24416 // JSON Merge Patch functions // | |
| 24417 //////////////////////////////// | |
| 24418 | |
| 24419 /// @name JSON Merge Patch functions | |
| 24420 /// @{ | |
| 24421 | |
| 24422 /// @brief applies a JSON Merge Patch | |
| 24423 /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/ | |
| 24424 void merge_patch(const basic_json& apply_patch) | |
| 24425 { | |
| 24426 if (apply_patch.is_object()) | |
| 24427 { | |
| 24428 if (!is_object()) | |
| 24429 { | |
| 24430 *this = object(); | |
| 24431 } | |
| 24432 for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it) | |
| 24433 { | |
| 24434 if (it.value().is_null()) | |
| 24435 { | |
| 24436 erase(it.key()); | |
| 24437 } | |
| 24438 else | |
| 24439 { | |
| 24440 operator[](it.key()).merge_patch(it.value()); | |
| 24441 } | |
| 24442 } | |
| 24443 } | |
| 24444 else | |
| 24445 { | |
| 24446 *this = apply_patch; | |
| 24447 } | |
| 24448 } | |
| 24449 | |
| 24450 /// @} | |
| 24451 }; | |
| 24452 | |
| 24453 /// @brief user-defined to_string function for JSON values | |
| 24454 /// @sa https://json.nlohmann.me/api/basic_json/to_string/ | |
| 24455 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 24456 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j) | |
| 24457 { | |
| 24458 return j.dump(); | |
| 24459 } | |
| 24460 | |
| 24461 inline namespace literals | |
| 24462 { | |
| 24463 inline namespace json_literals | |
| 24464 { | |
| 24465 | |
| 24466 /// @brief user-defined string literal for JSON values | |
| 24467 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/ | |
| 24468 JSON_HEDLEY_NON_NULL(1) | |
| 24469 #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) | |
| 24470 inline nlohmann::json operator ""_json(const char* s, std::size_t n) | |
| 24471 #else | |
| 24472 inline nlohmann::json operator "" _json(const char* s, std::size_t n) | |
| 24473 #endif | |
| 24474 { | |
| 24475 return nlohmann::json::parse(s, s + n); | |
| 24476 } | |
| 24477 | |
| 24478 /// @brief user-defined string literal for JSON pointer | |
| 24479 /// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/ | |
| 24480 JSON_HEDLEY_NON_NULL(1) | |
| 24481 #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) | |
| 24482 inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n) | |
| 24483 #else | |
| 24484 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n) | |
| 24485 #endif | |
| 24486 { | |
| 24487 return nlohmann::json::json_pointer(std::string(s, n)); | |
| 24488 } | |
| 24489 | |
| 24490 } // namespace json_literals | |
| 24491 } // namespace literals | |
| 24492 NLOHMANN_JSON_NAMESPACE_END | |
| 24493 | |
| 24494 /////////////////////// | |
| 24495 // nonmember support // | |
| 24496 /////////////////////// | |
| 24497 | |
| 24498 namespace std // NOLINT(cert-dcl58-cpp) | |
| 24499 { | |
| 24500 | |
| 24501 /// @brief hash value for JSON objects | |
| 24502 /// @sa https://json.nlohmann.me/api/basic_json/std_hash/ | |
| 24503 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 24504 struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp) | |
| 24505 { | |
| 24506 std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const | |
| 24507 { | |
| 24508 return nlohmann::detail::hash(j); | |
| 24509 } | |
| 24510 }; | |
| 24511 | |
| 24512 // specialization for std::less<value_t> | |
| 24513 template<> | |
| 24514 struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679 | |
| 24515 { | |
| 24516 /*! | |
| 24517 @brief compare two value_t enum values | |
| 24518 @since version 3.0.0 | |
| 24519 */ | |
| 24520 bool operator()(::nlohmann::detail::value_t lhs, | |
| 24521 ::nlohmann::detail::value_t rhs) const noexcept | |
| 24522 { | |
| 24523 #if JSON_HAS_THREE_WAY_COMPARISON | |
| 24524 return std::is_lt(lhs <=> rhs); // *NOPAD* | |
| 24525 #else | |
| 24526 return ::nlohmann::detail::operator<(lhs, rhs); | |
| 24527 #endif | |
| 24528 } | |
| 24529 }; | |
| 24530 | |
| 24531 // C++20 prohibit function specialization in the std namespace. | |
| 24532 #ifndef JSON_HAS_CPP_20 | |
| 24533 | |
| 24534 /// @brief exchanges the values of two JSON objects | |
| 24535 /// @sa https://json.nlohmann.me/api/basic_json/std_swap/ | |
| 24536 NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 24537 inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept( // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp) | |
| 24538 is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&& // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap) | |
| 24539 is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value) | |
| 24540 { | |
| 24541 j1.swap(j2); | |
| 24542 } | |
| 24543 | |
| 24544 #endif | |
| 24545 | |
| 24546 } // namespace std | |
| 24547 | |
| 24548 #if JSON_USE_GLOBAL_UDLS | |
| 24549 #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) | |
| 24550 using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers) | |
| 24551 using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers) | |
| 24552 #else | |
| 24553 using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers) | |
| 24554 using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers) | |
| 24555 #endif | |
| 24556 #endif | |
| 24557 | |
| 24558 // #include <nlohmann/detail/macro_unscope.hpp> | |
| 24559 // __ _____ _____ _____ | |
| 24560 // __| | __| | | | JSON for Modern C++ | |
| 24561 // | | |__ | | | | | | version 3.11.3 | |
| 24562 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 24563 // | |
| 24564 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 24565 // SPDX-License-Identifier: MIT | |
| 24566 | |
| 24567 | |
| 24568 | |
| 24569 // restore clang diagnostic settings | |
| 24570 #if defined(__clang__) | |
| 24571 #pragma clang diagnostic pop | |
| 24572 #endif | |
| 24573 | |
| 24574 // clean up | |
| 24575 #undef JSON_ASSERT | |
| 24576 #undef JSON_INTERNAL_CATCH | |
| 24577 #undef JSON_THROW | |
| 24578 #undef JSON_PRIVATE_UNLESS_TESTED | |
| 24579 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION | |
| 24580 #undef NLOHMANN_BASIC_JSON_TPL | |
| 24581 #undef JSON_EXPLICIT | |
| 24582 #undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL | |
| 24583 #undef JSON_INLINE_VARIABLE | |
| 24584 #undef JSON_NO_UNIQUE_ADDRESS | |
| 24585 #undef JSON_DISABLE_ENUM_SERIALIZATION | |
| 24586 #undef JSON_USE_GLOBAL_UDLS | |
| 24587 | |
| 24588 #ifndef JSON_TEST_KEEP_MACROS | |
| 24589 #undef JSON_CATCH | |
| 24590 #undef JSON_TRY | |
| 24591 #undef JSON_HAS_CPP_11 | |
| 24592 #undef JSON_HAS_CPP_14 | |
| 24593 #undef JSON_HAS_CPP_17 | |
| 24594 #undef JSON_HAS_CPP_20 | |
| 24595 #undef JSON_HAS_FILESYSTEM | |
| 24596 #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM | |
| 24597 #undef JSON_HAS_THREE_WAY_COMPARISON | |
| 24598 #undef JSON_HAS_RANGES | |
| 24599 #undef JSON_HAS_STATIC_RTTI | |
| 24600 #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON | |
| 24601 #endif | |
| 24602 | |
| 24603 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp> | |
| 24604 // __ _____ _____ _____ | |
| 24605 // __| | __| | | | JSON for Modern C++ | |
| 24606 // | | |__ | | | | | | version 3.11.3 | |
| 24607 // |_____|_____|_____|_|___| https://github.com/nlohmann/json | |
| 24608 // | |
| 24609 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me> | |
| 24610 // SPDX-License-Identifier: MIT | |
| 24611 | |
| 24612 | |
| 24613 | |
| 24614 #undef JSON_HEDLEY_ALWAYS_INLINE | |
| 24615 #undef JSON_HEDLEY_ARM_VERSION | |
| 24616 #undef JSON_HEDLEY_ARM_VERSION_CHECK | |
| 24617 #undef JSON_HEDLEY_ARRAY_PARAM | |
| 24618 #undef JSON_HEDLEY_ASSUME | |
| 24619 #undef JSON_HEDLEY_BEGIN_C_DECLS | |
| 24620 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE | |
| 24621 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN | |
| 24622 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE | |
| 24623 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE | |
| 24624 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION | |
| 24625 #undef JSON_HEDLEY_CLANG_HAS_FEATURE | |
| 24626 #undef JSON_HEDLEY_CLANG_HAS_WARNING | |
| 24627 #undef JSON_HEDLEY_COMPCERT_VERSION | |
| 24628 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK | |
| 24629 #undef JSON_HEDLEY_CONCAT | |
| 24630 #undef JSON_HEDLEY_CONCAT3 | |
| 24631 #undef JSON_HEDLEY_CONCAT3_EX | |
| 24632 #undef JSON_HEDLEY_CONCAT_EX | |
| 24633 #undef JSON_HEDLEY_CONST | |
| 24634 #undef JSON_HEDLEY_CONSTEXPR | |
| 24635 #undef JSON_HEDLEY_CONST_CAST | |
| 24636 #undef JSON_HEDLEY_CPP_CAST | |
| 24637 #undef JSON_HEDLEY_CRAY_VERSION | |
| 24638 #undef JSON_HEDLEY_CRAY_VERSION_CHECK | |
| 24639 #undef JSON_HEDLEY_C_DECL | |
| 24640 #undef JSON_HEDLEY_DEPRECATED | |
| 24641 #undef JSON_HEDLEY_DEPRECATED_FOR | |
| 24642 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL | |
| 24643 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ | |
| 24644 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED | |
| 24645 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES | |
| 24646 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS | |
| 24647 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION | |
| 24648 #undef JSON_HEDLEY_DIAGNOSTIC_POP | |
| 24649 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH | |
| 24650 #undef JSON_HEDLEY_DMC_VERSION | |
| 24651 #undef JSON_HEDLEY_DMC_VERSION_CHECK | |
| 24652 #undef JSON_HEDLEY_EMPTY_BASES | |
| 24653 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION | |
| 24654 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK | |
| 24655 #undef JSON_HEDLEY_END_C_DECLS | |
| 24656 #undef JSON_HEDLEY_FLAGS | |
| 24657 #undef JSON_HEDLEY_FLAGS_CAST | |
| 24658 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE | |
| 24659 #undef JSON_HEDLEY_GCC_HAS_BUILTIN | |
| 24660 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE | |
| 24661 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE | |
| 24662 #undef JSON_HEDLEY_GCC_HAS_EXTENSION | |
| 24663 #undef JSON_HEDLEY_GCC_HAS_FEATURE | |
| 24664 #undef JSON_HEDLEY_GCC_HAS_WARNING | |
| 24665 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK | |
| 24666 #undef JSON_HEDLEY_GCC_VERSION | |
| 24667 #undef JSON_HEDLEY_GCC_VERSION_CHECK | |
| 24668 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE | |
| 24669 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN | |
| 24670 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE | |
| 24671 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE | |
| 24672 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION | |
| 24673 #undef JSON_HEDLEY_GNUC_HAS_FEATURE | |
| 24674 #undef JSON_HEDLEY_GNUC_HAS_WARNING | |
| 24675 #undef JSON_HEDLEY_GNUC_VERSION | |
| 24676 #undef JSON_HEDLEY_GNUC_VERSION_CHECK | |
| 24677 #undef JSON_HEDLEY_HAS_ATTRIBUTE | |
| 24678 #undef JSON_HEDLEY_HAS_BUILTIN | |
| 24679 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE | |
| 24680 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS | |
| 24681 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE | |
| 24682 #undef JSON_HEDLEY_HAS_EXTENSION | |
| 24683 #undef JSON_HEDLEY_HAS_FEATURE | |
| 24684 #undef JSON_HEDLEY_HAS_WARNING | |
| 24685 #undef JSON_HEDLEY_IAR_VERSION | |
| 24686 #undef JSON_HEDLEY_IAR_VERSION_CHECK | |
| 24687 #undef JSON_HEDLEY_IBM_VERSION | |
| 24688 #undef JSON_HEDLEY_IBM_VERSION_CHECK | |
| 24689 #undef JSON_HEDLEY_IMPORT | |
| 24690 #undef JSON_HEDLEY_INLINE | |
| 24691 #undef JSON_HEDLEY_INTEL_CL_VERSION | |
| 24692 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK | |
| 24693 #undef JSON_HEDLEY_INTEL_VERSION | |
| 24694 #undef JSON_HEDLEY_INTEL_VERSION_CHECK | |
| 24695 #undef JSON_HEDLEY_IS_CONSTANT | |
| 24696 #undef JSON_HEDLEY_IS_CONSTEXPR_ | |
| 24697 #undef JSON_HEDLEY_LIKELY | |
| 24698 #undef JSON_HEDLEY_MALLOC | |
| 24699 #undef JSON_HEDLEY_MCST_LCC_VERSION | |
| 24700 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK | |
| 24701 #undef JSON_HEDLEY_MESSAGE | |
| 24702 #undef JSON_HEDLEY_MSVC_VERSION | |
| 24703 #undef JSON_HEDLEY_MSVC_VERSION_CHECK | |
| 24704 #undef JSON_HEDLEY_NEVER_INLINE | |
| 24705 #undef JSON_HEDLEY_NON_NULL | |
| 24706 #undef JSON_HEDLEY_NO_ESCAPE | |
| 24707 #undef JSON_HEDLEY_NO_RETURN | |
| 24708 #undef JSON_HEDLEY_NO_THROW | |
| 24709 #undef JSON_HEDLEY_NULL | |
| 24710 #undef JSON_HEDLEY_PELLES_VERSION | |
| 24711 #undef JSON_HEDLEY_PELLES_VERSION_CHECK | |
| 24712 #undef JSON_HEDLEY_PGI_VERSION | |
| 24713 #undef JSON_HEDLEY_PGI_VERSION_CHECK | |
| 24714 #undef JSON_HEDLEY_PREDICT | |
| 24715 #undef JSON_HEDLEY_PRINTF_FORMAT | |
| 24716 #undef JSON_HEDLEY_PRIVATE | |
| 24717 #undef JSON_HEDLEY_PUBLIC | |
| 24718 #undef JSON_HEDLEY_PURE | |
| 24719 #undef JSON_HEDLEY_REINTERPRET_CAST | |
| 24720 #undef JSON_HEDLEY_REQUIRE | |
| 24721 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR | |
| 24722 #undef JSON_HEDLEY_REQUIRE_MSG | |
| 24723 #undef JSON_HEDLEY_RESTRICT | |
| 24724 #undef JSON_HEDLEY_RETURNS_NON_NULL | |
| 24725 #undef JSON_HEDLEY_SENTINEL | |
| 24726 #undef JSON_HEDLEY_STATIC_ASSERT | |
| 24727 #undef JSON_HEDLEY_STATIC_CAST | |
| 24728 #undef JSON_HEDLEY_STRINGIFY | |
| 24729 #undef JSON_HEDLEY_STRINGIFY_EX | |
| 24730 #undef JSON_HEDLEY_SUNPRO_VERSION | |
| 24731 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK | |
| 24732 #undef JSON_HEDLEY_TINYC_VERSION | |
| 24733 #undef JSON_HEDLEY_TINYC_VERSION_CHECK | |
| 24734 #undef JSON_HEDLEY_TI_ARMCL_VERSION | |
| 24735 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK | |
| 24736 #undef JSON_HEDLEY_TI_CL2000_VERSION | |
| 24737 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK | |
| 24738 #undef JSON_HEDLEY_TI_CL430_VERSION | |
| 24739 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK | |
| 24740 #undef JSON_HEDLEY_TI_CL6X_VERSION | |
| 24741 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK | |
| 24742 #undef JSON_HEDLEY_TI_CL7X_VERSION | |
| 24743 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK | |
| 24744 #undef JSON_HEDLEY_TI_CLPRU_VERSION | |
| 24745 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK | |
| 24746 #undef JSON_HEDLEY_TI_VERSION | |
| 24747 #undef JSON_HEDLEY_TI_VERSION_CHECK | |
| 24748 #undef JSON_HEDLEY_UNAVAILABLE | |
| 24749 #undef JSON_HEDLEY_UNLIKELY | |
| 24750 #undef JSON_HEDLEY_UNPREDICTABLE | |
| 24751 #undef JSON_HEDLEY_UNREACHABLE | |
| 24752 #undef JSON_HEDLEY_UNREACHABLE_RETURN | |
| 24753 #undef JSON_HEDLEY_VERSION | |
| 24754 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR | |
| 24755 #undef JSON_HEDLEY_VERSION_DECODE_MINOR | |
| 24756 #undef JSON_HEDLEY_VERSION_DECODE_REVISION | |
| 24757 #undef JSON_HEDLEY_VERSION_ENCODE | |
| 24758 #undef JSON_HEDLEY_WARNING | |
| 24759 #undef JSON_HEDLEY_WARN_UNUSED_RESULT | |
| 24760 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG | |
| 24761 #undef JSON_HEDLEY_FALL_THROUGH | |
| 24762 | |
| 24763 | |
| 24764 | |
| 24765 #endif // INCLUDE_NLOHMANN_JSON_HPP_ |