about summary refs log tree commit diff stats
path: root/vendor
diff options
context:
space:
mode:
authorStar Rauchenberger <fefferburbia@gmail.com>2022-12-23 11:09:58 +0000
committerStar Rauchenberger <fefferburbia@gmail.com>2022-12-23 11:09:58 +0000
commita76e81ee8bcbad87c9eb58cdb25452cae65bd0c7 (patch)
tree4f677cd679bb7374b022238d55d49dba81b7313f /vendor
parent31770500a918bccf7b624262bc7d444cc2dd8a1d (diff)
downloaddifference-a76e81ee8bcbad87c9eb58cdb25452cae65bd0c7.tar.gz
difference-a76e81ee8bcbad87c9eb58cdb25452cae65bd0c7.tar.bz2
difference-a76e81ee8bcbad87c9eb58cdb25452cae65bd0c7.zip
Bot is now a Mastodon bot
Diffstat (limited to 'vendor')
m---------vendor/curlcpp0


-rw-r--r--vendor/json/json.hpp24596


m---------vendor/libtwittercpp0


m---------vendor/verbly0


4 files changed, 24596 insertions, 0 deletions
diff --git a/vendor/curlcpp b/vendor/curlcpp
new file mode 160000



Subproject f4b87d02725065536bf6620c29aa8c13e15a199
diff --git a/vendor/json/json.hpp b/vendor/json/json.hpp
new file mode 100644
index 0000000..4d1a37a
--- /dev/null
+++ b/vendor/json/json.hpp

@@ -0,0 +1,24596 @@


1//     __ _____ _____ _____


2//  __|  |   __|     |   | |  JSON for Modern C++


3// |  |  |__   |  |  | | | |  version 3.11.2


4// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


5//


6// SPDX-FileCopyrightText: 2013-2022 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 <numeric> // accumulate


31#include <string> // string, stoi, to_string


32#include <utility> // declval, forward, move, pair, swap


33#include <vector> // vector


34


35// #include <nlohmann/adl_serializer.hpp>


36//     __ _____ _____ _____


37//  __|  |   __|     |   | |  JSON for Modern C++


38// |  |  |__   |  |  | | | |  version 3.11.2


39// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


40//


41// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


42// SPDX-License-Identifier: MIT


43


44


45


46#include <utility>


47


48// #include <nlohmann/detail/abi_macros.hpp>


49//     __ _____ _____ _____


50//  __|  |   __|     |   | |  JSON for Modern C++


51// |  |  |__   |  |  | | | |  version 3.11.2


52// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


53//


54// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


55// SPDX-License-Identifier: MIT


56


57


58


59// This file contains all macro definitions affecting or depending on the ABI


60


61#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK


62    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)


63        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 2


64            #warning "Already included a different version of the library!"


65        #endif


66    #endif


67#endif


68


69#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)


70#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)


71#define NLOHMANN_JSON_VERSION_PATCH 2   // NOLINT(modernize-macro-to-enum)


72


73#ifndef JSON_DIAGNOSTICS


74    #define JSON_DIAGNOSTICS 0


75#endif


76


77#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON


78    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0


79#endif


80


81#if JSON_DIAGNOSTICS


82    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag


83#else


84    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS


85#endif


86


87#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON


88    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp


89#else


90    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON


91#endif


92


93#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION


94    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0


95#endif


96


97// Construct the namespace ABI tags component


98#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b


99#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \


100    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)


101


102#define NLOHMANN_JSON_ABI_TAGS                                       \


103    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \


104            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \


105            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)


106


107// Construct the namespace version component


108#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \


109    _v ## major ## _ ## minor ## _ ## patch


110#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \


111    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)


112


113#if NLOHMANN_JSON_NAMESPACE_NO_VERSION


114#define NLOHMANN_JSON_NAMESPACE_VERSION


115#else


116#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \


117    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \


118                                           NLOHMANN_JSON_VERSION_MINOR, \


119                                           NLOHMANN_JSON_VERSION_PATCH)


120#endif


121


122// Combine namespace components


123#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b


124#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \


125    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)


126


127#ifndef NLOHMANN_JSON_NAMESPACE


128#define NLOHMANN_JSON_NAMESPACE               \


129    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \


130            NLOHMANN_JSON_ABI_TAGS,           \


131            NLOHMANN_JSON_NAMESPACE_VERSION)


132#endif


133


134#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN


135#define NLOHMANN_JSON_NAMESPACE_BEGIN                \


136    namespace nlohmann                               \


137    {                                                \


138    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \


139                NLOHMANN_JSON_ABI_TAGS,              \


140                NLOHMANN_JSON_NAMESPACE_VERSION)     \


141    {


142#endif


143


144#ifndef NLOHMANN_JSON_NAMESPACE_END


145#define NLOHMANN_JSON_NAMESPACE_END                                     \


146    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \


147    }  // namespace nlohmann


148#endif


149


150// #include <nlohmann/detail/conversions/from_json.hpp>


151//     __ _____ _____ _____


152//  __|  |   __|     |   | |  JSON for Modern C++


153// |  |  |__   |  |  | | | |  version 3.11.2


154// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


155//


156// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


157// SPDX-License-Identifier: MIT


158


159


160


161#include <algorithm> // transform


162#include <array> // array


163#include <forward_list> // forward_list


164#include <iterator> // inserter, front_inserter, end


165#include <map> // map


166#include <string> // string


167#include <tuple> // tuple, make_tuple


168#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible


169#include <unordered_map> // unordered_map


170#include <utility> // pair, declval


171#include <valarray> // valarray


172


173// #include <nlohmann/detail/exceptions.hpp>


174//     __ _____ _____ _____


175//  __|  |   __|     |   | |  JSON for Modern C++


176// |  |  |__   |  |  | | | |  version 3.11.2


177// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


178//


179// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


180// SPDX-License-Identifier: MIT


181


182


183


184#include <cstddef> // nullptr_t


185#include <exception> // exception


186#include <stdexcept> // runtime_error


187#include <string> // to_string


188#include <vector> // vector


189


190// #include <nlohmann/detail/value_t.hpp>


191//     __ _____ _____ _____


192//  __|  |   __|     |   | |  JSON for Modern C++


193// |  |  |__   |  |  | | | |  version 3.11.2


194// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


195//


196// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


197// SPDX-License-Identifier: MIT


198


199


200


201#include <array> // array


202#include <cstddef> // size_t


203#include <cstdint> // uint8_t


204#include <string> // string


205


206// #include <nlohmann/detail/macro_scope.hpp>


207//     __ _____ _____ _____


208//  __|  |   __|     |   | |  JSON for Modern C++


209// |  |  |__   |  |  | | | |  version 3.11.2


210// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


211//


212// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


213// SPDX-License-Identifier: MIT


214


215


216


217#include <utility> // declval, pair


218// #include <nlohmann/detail/meta/detected.hpp>


219//     __ _____ _____ _____


220//  __|  |   __|     |   | |  JSON for Modern C++


221// |  |  |__   |  |  | | | |  version 3.11.2


222// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


223//


224// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


225// SPDX-License-Identifier: MIT


226


227


228


229#include <type_traits>


230


231// #include <nlohmann/detail/meta/void_t.hpp>


232//     __ _____ _____ _____


233//  __|  |   __|     |   | |  JSON for Modern C++


234// |  |  |__   |  |  | | | |  version 3.11.2


235// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


236//


237// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


238// SPDX-License-Identifier: MIT


239


240


241


242// #include <nlohmann/detail/abi_macros.hpp>


243


244


245NLOHMANN_JSON_NAMESPACE_BEGIN


246namespace detail


247{


248


249template<typename ...Ts> struct make_void


250{


251    using type = void;


252};


253template<typename ...Ts> using void_t = typename make_void<Ts...>::type;


254


255}  // namespace detail


256NLOHMANN_JSON_NAMESPACE_END


257


258


259NLOHMANN_JSON_NAMESPACE_BEGIN


260namespace detail


261{


262


263// https://en.cppreference.com/w/cpp/experimental/is_detected


264struct nonesuch


265{


266    nonesuch() = delete;


267    ~nonesuch() = delete;


268    nonesuch(nonesuch const&) = delete;


269    nonesuch(nonesuch const&&) = delete;


270    void operator=(nonesuch const&) = delete;


271    void operator=(nonesuch&&) = delete;


272};


273


274template<class Default,


275         class AlwaysVoid,


276         template<class...> class Op,


277         class... Args>


278struct detector


279{


280    using value_t = std::false_type;


281    using type = Default;


282};


283


284template<class Default, template<class...> class Op, class... Args>


285struct detector<Default, void_t<Op<Args...>>, Op, Args...>


286{


287    using value_t = std::true_type;


288    using type = Op<Args...>;


289};


290


291template<template<class...> class Op, class... Args>


292using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;


293


294template<template<class...> class Op, class... Args>


295struct is_detected_lazy : is_detected<Op, Args...> { };


296


297template<template<class...> class Op, class... Args>


298using detected_t = typename detector<nonesuch, void, Op, Args...>::type;


299


300template<class Default, template<class...> class Op, class... Args>


301using detected_or = detector<Default, void, Op, Args...>;


302


303template<class Default, template<class...> class Op, class... Args>


304using detected_or_t = typename detected_or<Default, Op, Args...>::type;


305


306template<class Expected, template<class...> class Op, class... Args>


307using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;


308


309template<class To, template<class...> class Op, class... Args>


310using is_detected_convertible =


311    std::is_convertible<detected_t<Op, Args...>, To>;


312


313}  // namespace detail


314NLOHMANN_JSON_NAMESPACE_END


315


316// #include <nlohmann/thirdparty/hedley/hedley.hpp>


317


318


319//     __ _____ _____ _____


320//  __|  |   __|     |   | |  JSON for Modern C++


321// |  |  |__   |  |  | | | |  version 3.11.2


322// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


323//


324// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


325// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>


326// SPDX-License-Identifier: MIT


327


328/* Hedley - https://nemequ.github.io/hedley


329 * Created by Evan Nemerson <evan@nemerson.com>


330 */


331


332#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)


333#if defined(JSON_HEDLEY_VERSION)


334    #undef JSON_HEDLEY_VERSION


335#endif


336#define JSON_HEDLEY_VERSION 15


337


338#if defined(JSON_HEDLEY_STRINGIFY_EX)


339    #undef JSON_HEDLEY_STRINGIFY_EX


340#endif


341#define JSON_HEDLEY_STRINGIFY_EX(x) #x


342


343#if defined(JSON_HEDLEY_STRINGIFY)


344    #undef JSON_HEDLEY_STRINGIFY


345#endif


346#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)


347


348#if defined(JSON_HEDLEY_CONCAT_EX)


349    #undef JSON_HEDLEY_CONCAT_EX


350#endif


351#define JSON_HEDLEY_CONCAT_EX(a,b) a##b


352


353#if defined(JSON_HEDLEY_CONCAT)


354    #undef JSON_HEDLEY_CONCAT


355#endif


356#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)


357


358#if defined(JSON_HEDLEY_CONCAT3_EX)


359    #undef JSON_HEDLEY_CONCAT3_EX


360#endif


361#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c


362


363#if defined(JSON_HEDLEY_CONCAT3)


364    #undef JSON_HEDLEY_CONCAT3


365#endif


366#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)


367


368#if defined(JSON_HEDLEY_VERSION_ENCODE)


369    #undef JSON_HEDLEY_VERSION_ENCODE


370#endif


371#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))


372


373#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)


374    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR


375#endif


376#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)


377


378#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)


379    #undef JSON_HEDLEY_VERSION_DECODE_MINOR


380#endif


381#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)


382


383#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)


384    #undef JSON_HEDLEY_VERSION_DECODE_REVISION


385#endif


386#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)


387


388#if defined(JSON_HEDLEY_GNUC_VERSION)


389    #undef JSON_HEDLEY_GNUC_VERSION


390#endif


391#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)


392    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)


393#elif defined(__GNUC__)


394    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)


395#endif


396


397#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)


398    #undef JSON_HEDLEY_GNUC_VERSION_CHECK


399#endif


400#if defined(JSON_HEDLEY_GNUC_VERSION)


401    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


402#else


403    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)


404#endif


405


406#if defined(JSON_HEDLEY_MSVC_VERSION)


407    #undef JSON_HEDLEY_MSVC_VERSION


408#endif


409#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)


410    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)


411#elif defined(_MSC_FULL_VER) && !defined(__ICL)


412    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)


413#elif defined(_MSC_VER) && !defined(__ICL)


414    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)


415#endif


416


417#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)


418    #undef JSON_HEDLEY_MSVC_VERSION_CHECK


419#endif


420#if !defined(JSON_HEDLEY_MSVC_VERSION)


421    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)


422#elif defined(_MSC_VER) && (_MSC_VER >= 1400)


423    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))


424#elif defined(_MSC_VER) && (_MSC_VER >= 1200)


425    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))


426#else


427    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))


428#endif


429


430#if defined(JSON_HEDLEY_INTEL_VERSION)


431    #undef JSON_HEDLEY_INTEL_VERSION


432#endif


433#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)


434    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)


435#elif defined(__INTEL_COMPILER) && !defined(__ICL)


436    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)


437#endif


438


439#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)


440    #undef JSON_HEDLEY_INTEL_VERSION_CHECK


441#endif


442#if defined(JSON_HEDLEY_INTEL_VERSION)


443    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


444#else


445    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)


446#endif


447


448#if defined(JSON_HEDLEY_INTEL_CL_VERSION)


449    #undef JSON_HEDLEY_INTEL_CL_VERSION


450#endif


451#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)


452    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)


453#endif


454


455#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)


456    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK


457#endif


458#if defined(JSON_HEDLEY_INTEL_CL_VERSION)


459    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


460#else


461    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)


462#endif


463


464#if defined(JSON_HEDLEY_PGI_VERSION)


465    #undef JSON_HEDLEY_PGI_VERSION


466#endif


467#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)


468    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)


469#endif


470


471#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)


472    #undef JSON_HEDLEY_PGI_VERSION_CHECK


473#endif


474#if defined(JSON_HEDLEY_PGI_VERSION)


475    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


476#else


477    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)


478#endif


479


480#if defined(JSON_HEDLEY_SUNPRO_VERSION)


481    #undef JSON_HEDLEY_SUNPRO_VERSION


482#endif


483#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)


484    #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)


485#elif defined(__SUNPRO_C)


486    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)


487#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)


488    #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)


489#elif defined(__SUNPRO_CC)


490    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)


491#endif


492


493#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)


494    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK


495#endif


496#if defined(JSON_HEDLEY_SUNPRO_VERSION)


497    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


498#else


499    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)


500#endif


501


502#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)


503    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION


504#endif


505#if defined(__EMSCRIPTEN__)


506    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)


507#endif


508


509#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)


510    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK


511#endif


512#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)


513    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


514#else


515    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)


516#endif


517


518#if defined(JSON_HEDLEY_ARM_VERSION)


519    #undef JSON_HEDLEY_ARM_VERSION


520#endif


521#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)


522    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)


523#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)


524    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)


525#endif


526


527#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)


528    #undef JSON_HEDLEY_ARM_VERSION_CHECK


529#endif


530#if defined(JSON_HEDLEY_ARM_VERSION)


531    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


532#else


533    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)


534#endif


535


536#if defined(JSON_HEDLEY_IBM_VERSION)


537    #undef JSON_HEDLEY_IBM_VERSION


538#endif


539#if defined(__ibmxl__)


540    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)


541#elif defined(__xlC__) && defined(__xlC_ver__)


542    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)


543#elif defined(__xlC__)


544    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)


545#endif


546


547#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)


548    #undef JSON_HEDLEY_IBM_VERSION_CHECK


549#endif


550#if defined(JSON_HEDLEY_IBM_VERSION)


551    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


552#else


553    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)


554#endif


555


556#if defined(JSON_HEDLEY_TI_VERSION)


557    #undef JSON_HEDLEY_TI_VERSION


558#endif


559#if \


560    defined(__TI_COMPILER_VERSION__) && \


561    ( \


562      defined(__TMS470__) || defined(__TI_ARM__) || \


563      defined(__MSP430__) || \


564      defined(__TMS320C2000__) \


565    )


566#if (__TI_COMPILER_VERSION__ >= 16000000)


567    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


568#endif


569#endif


570


571#if defined(JSON_HEDLEY_TI_VERSION_CHECK)


572    #undef JSON_HEDLEY_TI_VERSION_CHECK


573#endif


574#if defined(JSON_HEDLEY_TI_VERSION)


575    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


576#else


577    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)


578#endif


579


580#if defined(JSON_HEDLEY_TI_CL2000_VERSION)


581    #undef JSON_HEDLEY_TI_CL2000_VERSION


582#endif


583#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)


584    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


585#endif


586


587#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)


588    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK


589#endif


590#if defined(JSON_HEDLEY_TI_CL2000_VERSION)


591    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


592#else


593    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)


594#endif


595


596#if defined(JSON_HEDLEY_TI_CL430_VERSION)


597    #undef JSON_HEDLEY_TI_CL430_VERSION


598#endif


599#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)


600    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


601#endif


602


603#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)


604    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK


605#endif


606#if defined(JSON_HEDLEY_TI_CL430_VERSION)


607    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


608#else


609    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)


610#endif


611


612#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)


613    #undef JSON_HEDLEY_TI_ARMCL_VERSION


614#endif


615#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))


616    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


617#endif


618


619#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)


620    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK


621#endif


622#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)


623    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


624#else


625    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)


626#endif


627


628#if defined(JSON_HEDLEY_TI_CL6X_VERSION)


629    #undef JSON_HEDLEY_TI_CL6X_VERSION


630#endif


631#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)


632    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


633#endif


634


635#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)


636    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK


637#endif


638#if defined(JSON_HEDLEY_TI_CL6X_VERSION)


639    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


640#else


641    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)


642#endif


643


644#if defined(JSON_HEDLEY_TI_CL7X_VERSION)


645    #undef JSON_HEDLEY_TI_CL7X_VERSION


646#endif


647#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)


648    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


649#endif


650


651#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)


652    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK


653#endif


654#if defined(JSON_HEDLEY_TI_CL7X_VERSION)


655    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


656#else


657    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)


658#endif


659


660#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)


661    #undef JSON_HEDLEY_TI_CLPRU_VERSION


662#endif


663#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)


664    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


665#endif


666


667#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)


668    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK


669#endif


670#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)


671    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


672#else


673    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)


674#endif


675


676#if defined(JSON_HEDLEY_CRAY_VERSION)


677    #undef JSON_HEDLEY_CRAY_VERSION


678#endif


679#if defined(_CRAYC)


680    #if defined(_RELEASE_PATCHLEVEL)


681        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)


682    #else


683        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)


684    #endif


685#endif


686


687#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)


688    #undef JSON_HEDLEY_CRAY_VERSION_CHECK


689#endif


690#if defined(JSON_HEDLEY_CRAY_VERSION)


691    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


692#else


693    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)


694#endif


695


696#if defined(JSON_HEDLEY_IAR_VERSION)


697    #undef JSON_HEDLEY_IAR_VERSION


698#endif


699#if defined(__IAR_SYSTEMS_ICC__)


700    #if __VER__ > 1000


701        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))


702    #else


703        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)


704    #endif


705#endif


706


707#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)


708    #undef JSON_HEDLEY_IAR_VERSION_CHECK


709#endif


710#if defined(JSON_HEDLEY_IAR_VERSION)


711    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


712#else


713    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)


714#endif


715


716#if defined(JSON_HEDLEY_TINYC_VERSION)


717    #undef JSON_HEDLEY_TINYC_VERSION


718#endif


719#if defined(__TINYC__)


720    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)


721#endif


722


723#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)


724    #undef JSON_HEDLEY_TINYC_VERSION_CHECK


725#endif


726#if defined(JSON_HEDLEY_TINYC_VERSION)


727    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


728#else


729    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)


730#endif


731


732#if defined(JSON_HEDLEY_DMC_VERSION)


733    #undef JSON_HEDLEY_DMC_VERSION


734#endif


735#if defined(__DMC__)


736    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)


737#endif


738


739#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)


740    #undef JSON_HEDLEY_DMC_VERSION_CHECK


741#endif


742#if defined(JSON_HEDLEY_DMC_VERSION)


743    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


744#else


745    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)


746#endif


747


748#if defined(JSON_HEDLEY_COMPCERT_VERSION)


749    #undef JSON_HEDLEY_COMPCERT_VERSION


750#endif


751#if defined(__COMPCERT_VERSION__)


752    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)


753#endif


754


755#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)


756    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK


757#endif


758#if defined(JSON_HEDLEY_COMPCERT_VERSION)


759    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


760#else


761    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)


762#endif


763


764#if defined(JSON_HEDLEY_PELLES_VERSION)


765    #undef JSON_HEDLEY_PELLES_VERSION


766#endif


767#if defined(__POCC__)


768    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)


769#endif


770


771#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)


772    #undef JSON_HEDLEY_PELLES_VERSION_CHECK


773#endif


774#if defined(JSON_HEDLEY_PELLES_VERSION)


775    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


776#else


777    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)


778#endif


779


780#if defined(JSON_HEDLEY_MCST_LCC_VERSION)


781    #undef JSON_HEDLEY_MCST_LCC_VERSION


782#endif


783#if defined(__LCC__) && defined(__LCC_MINOR__)


784    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)


785#endif


786


787#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)


788    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK


789#endif


790#if defined(JSON_HEDLEY_MCST_LCC_VERSION)


791    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


792#else


793    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)


794#endif


795


796#if defined(JSON_HEDLEY_GCC_VERSION)


797    #undef JSON_HEDLEY_GCC_VERSION


798#endif


799#if \


800    defined(JSON_HEDLEY_GNUC_VERSION) && \


801    !defined(__clang__) && \


802    !defined(JSON_HEDLEY_INTEL_VERSION) && \


803    !defined(JSON_HEDLEY_PGI_VERSION) && \


804    !defined(JSON_HEDLEY_ARM_VERSION) && \


805    !defined(JSON_HEDLEY_CRAY_VERSION) && \


806    !defined(JSON_HEDLEY_TI_VERSION) && \


807    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \


808    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \


809    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \


810    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \


811    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \


812    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \


813    !defined(__COMPCERT__) && \


814    !defined(JSON_HEDLEY_MCST_LCC_VERSION)


815    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION


816#endif


817


818#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)


819    #undef JSON_HEDLEY_GCC_VERSION_CHECK


820#endif


821#if defined(JSON_HEDLEY_GCC_VERSION)


822    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))


823#else


824    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)


825#endif


826


827#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)


828    #undef JSON_HEDLEY_HAS_ATTRIBUTE


829#endif


830#if \


831  defined(__has_attribute) && \


832  ( \


833    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \


834  )


835#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)


836#else


837#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)


838#endif


839


840#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)


841    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE


842#endif


843#if defined(__has_attribute)


844    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)


845#else


846    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


847#endif


848


849#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)


850    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE


851#endif


852#if defined(__has_attribute)


853    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)


854#else


855    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


856#endif


857


858#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)


859    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE


860#endif


861#if \


862    defined(__has_cpp_attribute) && \


863    defined(__cplusplus) && \


864    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))


865    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)


866#else


867    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)


868#endif


869


870#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)


871    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS


872#endif


873#if !defined(__cplusplus) || !defined(__has_cpp_attribute)


874    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)


875#elif \


876    !defined(JSON_HEDLEY_PGI_VERSION) && \


877    !defined(JSON_HEDLEY_IAR_VERSION) && \


878    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \


879    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))


880    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)


881#else


882    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)


883#endif


884


885#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)


886    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE


887#endif


888#if defined(__has_cpp_attribute) && defined(__cplusplus)


889    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)


890#else


891    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


892#endif


893


894#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)


895    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE


896#endif


897#if defined(__has_cpp_attribute) && defined(__cplusplus)


898    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)


899#else


900    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


901#endif


902


903#if defined(JSON_HEDLEY_HAS_BUILTIN)


904    #undef JSON_HEDLEY_HAS_BUILTIN


905#endif


906#if defined(__has_builtin)


907    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)


908#else


909    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)


910#endif


911


912#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)


913    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN


914#endif


915#if defined(__has_builtin)


916    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)


917#else


918    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


919#endif


920


921#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)


922    #undef JSON_HEDLEY_GCC_HAS_BUILTIN


923#endif


924#if defined(__has_builtin)


925    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)


926#else


927    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


928#endif


929


930#if defined(JSON_HEDLEY_HAS_FEATURE)


931    #undef JSON_HEDLEY_HAS_FEATURE


932#endif


933#if defined(__has_feature)


934    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)


935#else


936    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)


937#endif


938


939#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)


940    #undef JSON_HEDLEY_GNUC_HAS_FEATURE


941#endif


942#if defined(__has_feature)


943    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)


944#else


945    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


946#endif


947


948#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)


949    #undef JSON_HEDLEY_GCC_HAS_FEATURE


950#endif


951#if defined(__has_feature)


952    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)


953#else


954    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


955#endif


956


957#if defined(JSON_HEDLEY_HAS_EXTENSION)


958    #undef JSON_HEDLEY_HAS_EXTENSION


959#endif


960#if defined(__has_extension)


961    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)


962#else


963    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)


964#endif


965


966#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)


967    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION


968#endif


969#if defined(__has_extension)


970    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)


971#else


972    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


973#endif


974


975#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)


976    #undef JSON_HEDLEY_GCC_HAS_EXTENSION


977#endif


978#if defined(__has_extension)


979    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)


980#else


981    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


982#endif


983


984#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)


985    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE


986#endif


987#if defined(__has_declspec_attribute)


988    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)


989#else


990    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)


991#endif


992


993#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)


994    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE


995#endif


996#if defined(__has_declspec_attribute)


997    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)


998#else


999    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


1000#endif


1001


1002#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)


1003    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE


1004#endif


1005#if defined(__has_declspec_attribute)


1006    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)


1007#else


1008    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


1009#endif


1010


1011#if defined(JSON_HEDLEY_HAS_WARNING)


1012    #undef JSON_HEDLEY_HAS_WARNING


1013#endif


1014#if defined(__has_warning)


1015    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)


1016#else


1017    #define JSON_HEDLEY_HAS_WARNING(warning) (0)


1018#endif


1019


1020#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)


1021    #undef JSON_HEDLEY_GNUC_HAS_WARNING


1022#endif


1023#if defined(__has_warning)


1024    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)


1025#else


1026    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)


1027#endif


1028


1029#if defined(JSON_HEDLEY_GCC_HAS_WARNING)


1030    #undef JSON_HEDLEY_GCC_HAS_WARNING


1031#endif


1032#if defined(__has_warning)


1033    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)


1034#else


1035    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


1036#endif


1037


1038#if \


1039    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \


1040    defined(__clang__) || \


1041    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \


1042    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1043    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \


1044    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \


1045    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1046    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1047    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \


1048    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \


1049    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \


1050    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \


1051    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1052    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1053    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \


1054    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \


1055    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \


1056    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))


1057    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)


1058#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)


1059    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)


1060#else


1061    #define JSON_HEDLEY_PRAGMA(value)


1062#endif


1063


1064#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)


1065    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH


1066#endif


1067#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)


1068    #undef JSON_HEDLEY_DIAGNOSTIC_POP


1069#endif


1070#if defined(__clang__)


1071    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")


1072    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")


1073#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


1074    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")


1075    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")


1076#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)


1077    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")


1078    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")


1079#elif \


1080    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \


1081    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1082    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))


1083    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))


1084#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)


1085    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")


1086    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")


1087#elif \


1088    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1089    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1090    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \


1091    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \


1092    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1093    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)


1094    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")


1095    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")


1096#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)


1097    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")


1098    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")


1099#else


1100    #define JSON_HEDLEY_DIAGNOSTIC_PUSH


1101    #define JSON_HEDLEY_DIAGNOSTIC_POP


1102#endif


1103


1104/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for


1105   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */


1106#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)


1107    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_


1108#endif


1109#if defined(__cplusplus)


1110#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")


1111#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")


1112#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")


1113#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \


1114    JSON_HEDLEY_DIAGNOSTIC_PUSH \


1115    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \


1116    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \


1117    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \


1118    xpr \


1119    JSON_HEDLEY_DIAGNOSTIC_POP


1120#      else


1121#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \


1122    JSON_HEDLEY_DIAGNOSTIC_PUSH \


1123    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \


1124    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \


1125    xpr \


1126    JSON_HEDLEY_DIAGNOSTIC_POP


1127#      endif


1128#    else


1129#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \


1130    JSON_HEDLEY_DIAGNOSTIC_PUSH \


1131    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \


1132    xpr \


1133    JSON_HEDLEY_DIAGNOSTIC_POP


1134#    endif


1135#  endif


1136#endif


1137#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)


1138    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x


1139#endif


1140


1141#if defined(JSON_HEDLEY_CONST_CAST)


1142    #undef JSON_HEDLEY_CONST_CAST


1143#endif


1144#if defined(__cplusplus)


1145#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))


1146#elif \


1147  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \


1148  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \


1149  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


1150#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \


1151        JSON_HEDLEY_DIAGNOSTIC_PUSH \


1152        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \


1153        ((T) (expr)); \


1154        JSON_HEDLEY_DIAGNOSTIC_POP \


1155    }))


1156#else


1157#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))


1158#endif


1159


1160#if defined(JSON_HEDLEY_REINTERPRET_CAST)


1161    #undef JSON_HEDLEY_REINTERPRET_CAST


1162#endif


1163#if defined(__cplusplus)


1164    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))


1165#else


1166    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))


1167#endif


1168


1169#if defined(JSON_HEDLEY_STATIC_CAST)


1170    #undef JSON_HEDLEY_STATIC_CAST


1171#endif


1172#if defined(__cplusplus)


1173    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))


1174#else


1175    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))


1176#endif


1177


1178#if defined(JSON_HEDLEY_CPP_CAST)


1179    #undef JSON_HEDLEY_CPP_CAST


1180#endif


1181#if defined(__cplusplus)


1182#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")


1183#    define JSON_HEDLEY_CPP_CAST(T, expr) \


1184    JSON_HEDLEY_DIAGNOSTIC_PUSH \


1185    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \


1186    ((T) (expr)) \


1187    JSON_HEDLEY_DIAGNOSTIC_POP


1188#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)


1189#    define JSON_HEDLEY_CPP_CAST(T, expr) \


1190    JSON_HEDLEY_DIAGNOSTIC_PUSH \


1191    _Pragma("diag_suppress=Pe137") \


1192    JSON_HEDLEY_DIAGNOSTIC_POP


1193#  else


1194#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))


1195#  endif


1196#else


1197#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)


1198#endif


1199


1200#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)


1201    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED


1202#endif


1203#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")


1204    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")


1205#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


1206    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")


1207#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1208    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))


1209#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)


1210    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")


1211#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)


1212    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")


1213#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)


1214    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")


1215#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)


1216    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))


1217#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1218    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")


1219#elif \


1220    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1221    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1222    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1223    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1224    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1225    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1226    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1227    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1228    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1229    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1230    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)


1231    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")


1232#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)


1233    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")


1234#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)


1235    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")


1236#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1237    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")


1238#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)


1239    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")


1240#else


1241    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED


1242#endif


1243


1244#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)


1245    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS


1246#endif


1247#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")


1248    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")


1249#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


1250    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")


1251#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1252    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))


1253#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)


1254    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")


1255#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)


1256    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")


1257#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)


1258    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))


1259#elif \


1260    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \


1261    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \


1262    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1263    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)


1264    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")


1265#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)


1266    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")


1267#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1268    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")


1269#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1270    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")


1271#else


1272    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS


1273#endif


1274


1275#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)


1276    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES


1277#endif


1278#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")


1279    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")


1280#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)


1281    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")


1282#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)


1283    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")


1284#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1285    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))


1286#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)


1287    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))


1288#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)


1289    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")


1290#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)


1291    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")


1292#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)


1293    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")


1294#elif \


1295    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \


1296    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \


1297    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)


1298    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")


1299#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1300    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")


1301#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1302    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")


1303#else


1304    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES


1305#endif


1306


1307#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)


1308    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL


1309#endif


1310#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")


1311    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")


1312#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


1313    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")


1314#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)


1315    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")


1316#else


1317    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL


1318#endif


1319


1320#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)


1321    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION


1322#endif


1323#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")


1324    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")


1325#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)


1326    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")


1327#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)


1328    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))


1329#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1330    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")


1331#else


1332    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION


1333#endif


1334


1335#if defined(JSON_HEDLEY_DEPRECATED)


1336    #undef JSON_HEDLEY_DEPRECATED


1337#endif


1338#if defined(JSON_HEDLEY_DEPRECATED_FOR)


1339    #undef JSON_HEDLEY_DEPRECATED_FOR


1340#endif


1341#if \


1342    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \


1343    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1344    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))


1345    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))


1346#elif \


1347    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \


1348    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \


1349    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1350    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \


1351    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \


1352    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \


1353    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \


1354    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \


1355    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \


1356    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1357    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \


1358    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1359    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))


1360    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))


1361#elif defined(__cplusplus) && (__cplusplus >= 201402L)


1362    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])


1363    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])


1364#elif \


1365    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \


1366    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \


1367    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1368    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1369    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1370    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1371    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1372    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1373    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1374    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1375    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1376    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1377    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1378    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1379    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \


1380    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)


1381    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))


1382    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))


1383#elif \


1384    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \


1385    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \


1386    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1387    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)


1388    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)


1389#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1390    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")


1391    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")


1392#else


1393    #define JSON_HEDLEY_DEPRECATED(since)


1394    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)


1395#endif


1396


1397#if defined(JSON_HEDLEY_UNAVAILABLE)


1398    #undef JSON_HEDLEY_UNAVAILABLE


1399#endif


1400#if \


1401    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \


1402    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \


1403    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1404    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1405    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))


1406#else


1407    #define JSON_HEDLEY_UNAVAILABLE(available_since)


1408#endif


1409


1410#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)


1411    #undef JSON_HEDLEY_WARN_UNUSED_RESULT


1412#endif


1413#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)


1414    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG


1415#endif


1416#if \


1417    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \


1418    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \


1419    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1420    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1421    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1422    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1423    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1424    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1425    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1426    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1427    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1428    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1429    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1430    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1431    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \


1432    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \


1433    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1434    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))


1435    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))


1436#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)


1437    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])


1438    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])


1439#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)


1440    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])


1441    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])


1442#elif defined(_Check_return_) /* SAL */


1443    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_


1444    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_


1445#else


1446    #define JSON_HEDLEY_WARN_UNUSED_RESULT


1447    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)


1448#endif


1449


1450#if defined(JSON_HEDLEY_SENTINEL)


1451    #undef JSON_HEDLEY_SENTINEL


1452#endif


1453#if \


1454    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \


1455    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \


1456    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1457    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \


1458    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1459    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))


1460#else


1461    #define JSON_HEDLEY_SENTINEL(position)


1462#endif


1463


1464#if defined(JSON_HEDLEY_NO_RETURN)


1465    #undef JSON_HEDLEY_NO_RETURN


1466#endif


1467#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1468    #define JSON_HEDLEY_NO_RETURN __noreturn


1469#elif \


1470    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1471    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1472    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))


1473#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L


1474    #define JSON_HEDLEY_NO_RETURN _Noreturn


1475#elif defined(__cplusplus) && (__cplusplus >= 201103L)


1476    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])


1477#elif \


1478    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \


1479    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \


1480    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1481    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1482    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1483    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1484    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1485    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1486    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1487    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1488    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1489    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1490    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1491    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1492    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1493    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1494    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)


1495    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))


1496#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)


1497    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")


1498#elif \


1499    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \


1500    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1501    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)


1502#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)


1503    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")


1504#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)


1505    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))


1506#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)


1507    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)


1508#else


1509    #define JSON_HEDLEY_NO_RETURN


1510#endif


1511


1512#if defined(JSON_HEDLEY_NO_ESCAPE)


1513    #undef JSON_HEDLEY_NO_ESCAPE


1514#endif


1515#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)


1516    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))


1517#else


1518    #define JSON_HEDLEY_NO_ESCAPE


1519#endif


1520


1521#if defined(JSON_HEDLEY_UNREACHABLE)


1522    #undef JSON_HEDLEY_UNREACHABLE


1523#endif


1524#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)


1525    #undef JSON_HEDLEY_UNREACHABLE_RETURN


1526#endif


1527#if defined(JSON_HEDLEY_ASSUME)


1528    #undef JSON_HEDLEY_ASSUME


1529#endif


1530#if \


1531    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \


1532    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1533    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1534    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)


1535#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)


1536    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)


1537#elif \


1538    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \


1539    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)


1540    #if defined(__cplusplus)


1541        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)


1542    #else


1543        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)


1544    #endif


1545#endif


1546#if \


1547    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \


1548    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \


1549    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \


1550    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1551    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \


1552    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \


1553    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1554    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()


1555#elif defined(JSON_HEDLEY_ASSUME)


1556    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)


1557#endif


1558#if !defined(JSON_HEDLEY_ASSUME)


1559    #if defined(JSON_HEDLEY_UNREACHABLE)


1560        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))


1561    #else


1562        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)


1563    #endif


1564#endif


1565#if defined(JSON_HEDLEY_UNREACHABLE)


1566    #if  \


1567        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \


1568        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)


1569        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))


1570    #else


1571        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()


1572    #endif


1573#else


1574    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)


1575#endif


1576#if !defined(JSON_HEDLEY_UNREACHABLE)


1577    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)


1578#endif


1579


1580JSON_HEDLEY_DIAGNOSTIC_PUSH


1581#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")


1582    #pragma clang diagnostic ignored "-Wpedantic"


1583#endif


1584#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)


1585    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"


1586#endif


1587#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)


1588    #if defined(__clang__)


1589        #pragma clang diagnostic ignored "-Wvariadic-macros"


1590    #elif defined(JSON_HEDLEY_GCC_VERSION)


1591        #pragma GCC diagnostic ignored "-Wvariadic-macros"


1592    #endif


1593#endif


1594#if defined(JSON_HEDLEY_NON_NULL)


1595    #undef JSON_HEDLEY_NON_NULL


1596#endif


1597#if \


1598    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \


1599    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \


1600    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1601    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)


1602    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))


1603#else


1604    #define JSON_HEDLEY_NON_NULL(...)


1605#endif


1606JSON_HEDLEY_DIAGNOSTIC_POP


1607


1608#if defined(JSON_HEDLEY_PRINTF_FORMAT)


1609    #undef JSON_HEDLEY_PRINTF_FORMAT


1610#endif


1611#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)


1612    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))


1613#elif 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__(gnu_printf, string_idx, first_to_check)))


1615#elif \


1616    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \


1617    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \


1618    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1619    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \


1620    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1621    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1622    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1623    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1624    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1625    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1626    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1627    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1628    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1629    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1630    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1631    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1632    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1633    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))


1634#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)


1635    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))


1636#else


1637    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)


1638#endif


1639


1640#if defined(JSON_HEDLEY_CONSTEXPR)


1641    #undef JSON_HEDLEY_CONSTEXPR


1642#endif


1643#if defined(__cplusplus)


1644    #if __cplusplus >= 201103L


1645        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)


1646    #endif


1647#endif


1648#if !defined(JSON_HEDLEY_CONSTEXPR)


1649    #define JSON_HEDLEY_CONSTEXPR


1650#endif


1651


1652#if defined(JSON_HEDLEY_PREDICT)


1653    #undef JSON_HEDLEY_PREDICT


1654#endif


1655#if defined(JSON_HEDLEY_LIKELY)


1656    #undef JSON_HEDLEY_LIKELY


1657#endif


1658#if defined(JSON_HEDLEY_UNLIKELY)


1659    #undef JSON_HEDLEY_UNLIKELY


1660#endif


1661#if defined(JSON_HEDLEY_UNPREDICTABLE)


1662    #undef JSON_HEDLEY_UNPREDICTABLE


1663#endif


1664#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)


1665    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))


1666#endif


1667#if \


1668  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \


1669  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \


1670  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1671#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))


1672#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))


1673#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))


1674#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )


1675#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )


1676#elif \


1677  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \


1678  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \


1679  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1680  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \


1681  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1682  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1683  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1684  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \


1685  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \


1686  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \


1687  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \


1688  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1689  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1690  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \


1691  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \


1692  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1693#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \


1694    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))


1695#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \


1696    (__extension__ ({ \


1697        double hedley_probability_ = (probability); \


1698        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \


1699    }))


1700#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \


1701    (__extension__ ({ \


1702        double hedley_probability_ = (probability); \


1703        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \


1704    }))


1705#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)


1706#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)


1707#else


1708#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))


1709#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))


1710#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))


1711#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))


1712#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))


1713#endif


1714#if !defined(JSON_HEDLEY_UNPREDICTABLE)


1715    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)


1716#endif


1717


1718#if defined(JSON_HEDLEY_MALLOC)


1719    #undef JSON_HEDLEY_MALLOC


1720#endif


1721#if \


1722    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \


1723    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \


1724    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1725    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1726    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1727    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \


1728    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1729    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1730    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1731    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1732    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1733    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1734    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1735    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1736    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1737    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1738    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1739    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1740    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))


1741#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)


1742    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")


1743#elif \


1744    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \


1745    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1746    #define JSON_HEDLEY_MALLOC __declspec(restrict)


1747#else


1748    #define JSON_HEDLEY_MALLOC


1749#endif


1750


1751#if defined(JSON_HEDLEY_PURE)


1752    #undef JSON_HEDLEY_PURE


1753#endif


1754#if \


1755  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \


1756  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \


1757  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1758  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1759  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1760  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1761  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1762  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1763  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1764  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1765  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1766  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1767  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1768  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1769  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1770  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1771  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1772  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \


1773  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1774#  define JSON_HEDLEY_PURE __attribute__((__pure__))


1775#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)


1776#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")


1777#elif defined(__cplusplus) && \


1778    ( \


1779      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \


1780      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \


1781      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \


1782    )


1783#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")


1784#else


1785#  define JSON_HEDLEY_PURE


1786#endif


1787


1788#if defined(JSON_HEDLEY_CONST)


1789    #undef JSON_HEDLEY_CONST


1790#endif


1791#if \


1792    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \


1793    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \


1794    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1795    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1796    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1797    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1798    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1799    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1800    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1801    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1802    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1803    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1804    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1805    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1806    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1807    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1808    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1809    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \


1810    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1811    #define JSON_HEDLEY_CONST __attribute__((__const__))


1812#elif \


1813    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)


1814    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")


1815#else


1816    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE


1817#endif


1818


1819#if defined(JSON_HEDLEY_RESTRICT)


1820    #undef JSON_HEDLEY_RESTRICT


1821#endif


1822#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)


1823    #define JSON_HEDLEY_RESTRICT restrict


1824#elif \


1825    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \


1826    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \


1827    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1828    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \


1829    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1830    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1831    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \


1832    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1833    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \


1834    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \


1835    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1836    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \


1837    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \


1838    defined(__clang__) || \


1839    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1840    #define JSON_HEDLEY_RESTRICT __restrict


1841#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)


1842    #define JSON_HEDLEY_RESTRICT _Restrict


1843#else


1844    #define JSON_HEDLEY_RESTRICT


1845#endif


1846


1847#if defined(JSON_HEDLEY_INLINE)


1848    #undef JSON_HEDLEY_INLINE


1849#endif


1850#if \


1851    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \


1852    (defined(__cplusplus) && (__cplusplus >= 199711L))


1853    #define JSON_HEDLEY_INLINE inline


1854#elif \


1855    defined(JSON_HEDLEY_GCC_VERSION) || \


1856    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)


1857    #define JSON_HEDLEY_INLINE __inline__


1858#elif \


1859    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \


1860    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \


1861    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1862    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \


1863    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \


1864    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \


1865    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \


1866    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1867    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1868    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1869    #define JSON_HEDLEY_INLINE __inline


1870#else


1871    #define JSON_HEDLEY_INLINE


1872#endif


1873


1874#if defined(JSON_HEDLEY_ALWAYS_INLINE)


1875    #undef JSON_HEDLEY_ALWAYS_INLINE


1876#endif


1877#if \


1878  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \


1879  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \


1880  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1881  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1882  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1883  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1884  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1885  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1886  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1887  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1888  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1889  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1890  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1891  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1892  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1893  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1894  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1895  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \


1896  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)


1897#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE


1898#elif \


1899  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \


1900  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1901#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline


1902#elif defined(__cplusplus) && \


1903    ( \


1904      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1905      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1906      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1907      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \


1908      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1909      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \


1910    )


1911#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")


1912#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1913#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")


1914#else


1915#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE


1916#endif


1917


1918#if defined(JSON_HEDLEY_NEVER_INLINE)


1919    #undef JSON_HEDLEY_NEVER_INLINE


1920#endif


1921#if \


1922    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \


1923    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \


1924    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1925    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1926    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1927    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \


1928    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \


1929    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1930    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \


1931    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1932    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \


1933    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1934    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \


1935    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1936    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \


1937    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \


1938    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \


1939    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \


1940    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)


1941    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))


1942#elif \


1943    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \


1944    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


1945    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)


1946#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)


1947    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")


1948#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)


1949    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")


1950#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


1951    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")


1952#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)


1953    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))


1954#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)


1955    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)


1956#else


1957    #define JSON_HEDLEY_NEVER_INLINE


1958#endif


1959


1960#if defined(JSON_HEDLEY_PRIVATE)


1961    #undef JSON_HEDLEY_PRIVATE


1962#endif


1963#if defined(JSON_HEDLEY_PUBLIC)


1964    #undef JSON_HEDLEY_PUBLIC


1965#endif


1966#if defined(JSON_HEDLEY_IMPORT)


1967    #undef JSON_HEDLEY_IMPORT


1968#endif


1969#if defined(_WIN32) || defined(__CYGWIN__)


1970#  define JSON_HEDLEY_PRIVATE


1971#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)


1972#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)


1973#else


1974#  if \


1975    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \


1976    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \


1977    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \


1978    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


1979    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


1980    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \


1981    ( \


1982      defined(__TI_EABI__) && \


1983      ( \


1984        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \


1985        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \


1986      ) \


1987    ) || \


1988    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


1989#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))


1990#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))


1991#  else


1992#    define JSON_HEDLEY_PRIVATE


1993#    define JSON_HEDLEY_PUBLIC


1994#  endif


1995#  define JSON_HEDLEY_IMPORT    extern


1996#endif


1997


1998#if defined(JSON_HEDLEY_NO_THROW)


1999    #undef JSON_HEDLEY_NO_THROW


2000#endif


2001#if \


2002    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \


2003    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \


2004    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


2005    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


2006    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))


2007#elif \


2008    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \


2009    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \


2010    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)


2011    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)


2012#else


2013    #define JSON_HEDLEY_NO_THROW


2014#endif


2015


2016#if defined(JSON_HEDLEY_FALL_THROUGH)


2017    #undef JSON_HEDLEY_FALL_THROUGH


2018#endif


2019#if \


2020    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \


2021    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \


2022    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


2023    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))


2024#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)


2025    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])


2026#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)


2027    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])


2028#elif defined(__fallthrough) /* SAL */


2029    #define JSON_HEDLEY_FALL_THROUGH __fallthrough


2030#else


2031    #define JSON_HEDLEY_FALL_THROUGH


2032#endif


2033


2034#if defined(JSON_HEDLEY_RETURNS_NON_NULL)


2035    #undef JSON_HEDLEY_RETURNS_NON_NULL


2036#endif


2037#if \


2038    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \


2039    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \


2040    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


2041    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))


2042#elif defined(_Ret_notnull_) /* SAL */


2043    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_


2044#else


2045    #define JSON_HEDLEY_RETURNS_NON_NULL


2046#endif


2047


2048#if defined(JSON_HEDLEY_ARRAY_PARAM)


2049    #undef JSON_HEDLEY_ARRAY_PARAM


2050#endif


2051#if \


2052    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \


2053    !defined(__STDC_NO_VLA__) && \


2054    !defined(__cplusplus) && \


2055    !defined(JSON_HEDLEY_PGI_VERSION) && \


2056    !defined(JSON_HEDLEY_TINYC_VERSION)


2057    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)


2058#else


2059    #define JSON_HEDLEY_ARRAY_PARAM(name)


2060#endif


2061


2062#if defined(JSON_HEDLEY_IS_CONSTANT)


2063    #undef JSON_HEDLEY_IS_CONSTANT


2064#endif


2065#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)


2066    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR


2067#endif


2068/* JSON_HEDLEY_IS_CONSTEXPR_ is for


2069   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */


2070#if defined(JSON_HEDLEY_IS_CONSTEXPR_)


2071    #undef JSON_HEDLEY_IS_CONSTEXPR_


2072#endif


2073#if \


2074    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \


2075    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \


2076    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


2077    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \


2078    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \


2079    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \


2080    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \


2081    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \


2082    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \


2083    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)


2084    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)


2085#endif


2086#if !defined(__cplusplus)


2087#  if \


2088       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \


2089       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \


2090       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


2091       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \


2092       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \


2093       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \


2094       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)


2095#if defined(__INTPTR_TYPE__)


2096    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)


2097#else


2098    #include <stdint.h>


2099    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)


2100#endif


2101#  elif \


2102       ( \


2103          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \


2104          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \


2105          !defined(JSON_HEDLEY_PGI_VERSION) && \


2106          !defined(JSON_HEDLEY_IAR_VERSION)) || \


2107       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \


2108       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \


2109       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \


2110       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \


2111       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)


2112#if defined(__INTPTR_TYPE__)


2113    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)


2114#else


2115    #include <stdint.h>


2116    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)


2117#endif


2118#  elif \


2119       defined(JSON_HEDLEY_GCC_VERSION) || \


2120       defined(JSON_HEDLEY_INTEL_VERSION) || \


2121       defined(JSON_HEDLEY_TINYC_VERSION) || \


2122       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \


2123       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \


2124       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \


2125       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \


2126       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \


2127       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \


2128       defined(__clang__)


2129#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \


2130        sizeof(void) != \


2131        sizeof(*( \


2132                  1 ? \


2133                  ((void*) ((expr) * 0L) ) : \


2134((struct { char v[sizeof(void) * 2]; } *) 1) \


2135                ) \


2136              ) \


2137                                            )


2138#  endif


2139#endif


2140#if defined(JSON_HEDLEY_IS_CONSTEXPR_)


2141    #if !defined(JSON_HEDLEY_IS_CONSTANT)


2142        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)


2143    #endif


2144    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))


2145#else


2146    #if !defined(JSON_HEDLEY_IS_CONSTANT)


2147        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)


2148    #endif


2149    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)


2150#endif


2151


2152#if defined(JSON_HEDLEY_BEGIN_C_DECLS)


2153    #undef JSON_HEDLEY_BEGIN_C_DECLS


2154#endif


2155#if defined(JSON_HEDLEY_END_C_DECLS)


2156    #undef JSON_HEDLEY_END_C_DECLS


2157#endif


2158#if defined(JSON_HEDLEY_C_DECL)


2159    #undef JSON_HEDLEY_C_DECL


2160#endif


2161#if defined(__cplusplus)


2162    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {


2163    #define JSON_HEDLEY_END_C_DECLS }


2164    #define JSON_HEDLEY_C_DECL extern "C"


2165#else


2166    #define JSON_HEDLEY_BEGIN_C_DECLS


2167    #define JSON_HEDLEY_END_C_DECLS


2168    #define JSON_HEDLEY_C_DECL


2169#endif


2170


2171#if defined(JSON_HEDLEY_STATIC_ASSERT)


2172    #undef JSON_HEDLEY_STATIC_ASSERT


2173#endif


2174#if \


2175  !defined(__cplusplus) && ( \


2176      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \


2177      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \


2178      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \


2179      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \


2180      defined(_Static_assert) \


2181    )


2182#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)


2183#elif \


2184  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \


2185  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \


2186  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


2187#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))


2188#else


2189#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)


2190#endif


2191


2192#if defined(JSON_HEDLEY_NULL)


2193    #undef JSON_HEDLEY_NULL


2194#endif


2195#if defined(__cplusplus)


2196    #if __cplusplus >= 201103L


2197        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)


2198    #elif defined(NULL)


2199        #define JSON_HEDLEY_NULL NULL


2200    #else


2201        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)


2202    #endif


2203#elif defined(NULL)


2204    #define JSON_HEDLEY_NULL NULL


2205#else


2206    #define JSON_HEDLEY_NULL ((void*) 0)


2207#endif


2208


2209#if defined(JSON_HEDLEY_MESSAGE)


2210    #undef JSON_HEDLEY_MESSAGE


2211#endif


2212#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")


2213#  define JSON_HEDLEY_MESSAGE(msg) \


2214    JSON_HEDLEY_DIAGNOSTIC_PUSH \


2215    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \


2216    JSON_HEDLEY_PRAGMA(message msg) \


2217    JSON_HEDLEY_DIAGNOSTIC_POP


2218#elif \


2219  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \


2220  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


2221#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)


2222#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)


2223#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)


2224#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)


2225#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))


2226#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)


2227#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))


2228#else


2229#  define JSON_HEDLEY_MESSAGE(msg)


2230#endif


2231


2232#if defined(JSON_HEDLEY_WARNING)


2233    #undef JSON_HEDLEY_WARNING


2234#endif


2235#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")


2236#  define JSON_HEDLEY_WARNING(msg) \


2237    JSON_HEDLEY_DIAGNOSTIC_PUSH \


2238    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \


2239    JSON_HEDLEY_PRAGMA(clang warning msg) \


2240    JSON_HEDLEY_DIAGNOSTIC_POP


2241#elif \


2242  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \


2243  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \


2244  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)


2245#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)


2246#elif \


2247  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \


2248  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


2249#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))


2250#else


2251#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)


2252#endif


2253


2254#if defined(JSON_HEDLEY_REQUIRE)


2255    #undef JSON_HEDLEY_REQUIRE


2256#endif


2257#if defined(JSON_HEDLEY_REQUIRE_MSG)


2258    #undef JSON_HEDLEY_REQUIRE_MSG


2259#endif


2260#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)


2261#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")


2262#    define JSON_HEDLEY_REQUIRE(expr) \


2263    JSON_HEDLEY_DIAGNOSTIC_PUSH \


2264    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \


2265    __attribute__((diagnose_if(!(expr), #expr, "error"))) \


2266    JSON_HEDLEY_DIAGNOSTIC_POP


2267#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \


2268    JSON_HEDLEY_DIAGNOSTIC_PUSH \


2269    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \


2270    __attribute__((diagnose_if(!(expr), msg, "error"))) \


2271    JSON_HEDLEY_DIAGNOSTIC_POP


2272#  else


2273#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))


2274#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))


2275#  endif


2276#else


2277#  define JSON_HEDLEY_REQUIRE(expr)


2278#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)


2279#endif


2280


2281#if defined(JSON_HEDLEY_FLAGS)


2282    #undef JSON_HEDLEY_FLAGS


2283#endif


2284#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))


2285    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))


2286#else


2287    #define JSON_HEDLEY_FLAGS


2288#endif


2289


2290#if defined(JSON_HEDLEY_FLAGS_CAST)


2291    #undef JSON_HEDLEY_FLAGS_CAST


2292#endif


2293#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)


2294#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \


2295        JSON_HEDLEY_DIAGNOSTIC_PUSH \


2296        _Pragma("warning(disable:188)") \


2297        ((T) (expr)); \


2298        JSON_HEDLEY_DIAGNOSTIC_POP \


2299    }))


2300#else


2301#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)


2302#endif


2303


2304#if defined(JSON_HEDLEY_EMPTY_BASES)


2305    #undef JSON_HEDLEY_EMPTY_BASES


2306#endif


2307#if \


2308    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \


2309    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)


2310    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)


2311#else


2312    #define JSON_HEDLEY_EMPTY_BASES


2313#endif


2314


2315/* Remaining macros are deprecated. */


2316


2317#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)


2318    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK


2319#endif


2320#if defined(__clang__)


2321    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)


2322#else


2323    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)


2324#endif


2325


2326#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)


2327    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE


2328#endif


2329#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)


2330


2331#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)


2332    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE


2333#endif


2334#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)


2335


2336#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)


2337    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN


2338#endif


2339#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)


2340


2341#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)


2342    #undef JSON_HEDLEY_CLANG_HAS_FEATURE


2343#endif


2344#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)


2345


2346#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)


2347    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION


2348#endif


2349#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)


2350


2351#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)


2352    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE


2353#endif


2354#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)


2355


2356#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)


2357    #undef JSON_HEDLEY_CLANG_HAS_WARNING


2358#endif


2359#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)


2360


2361#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */


2362


2363


2364// This file contains all internal macro definitions (except those affecting ABI)


2365// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them


2366


2367// #include <nlohmann/detail/abi_macros.hpp>


2368


2369


2370// exclude unsupported compilers


2371#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)


2372    #if defined(__clang__)


2373        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400


2374            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"


2375        #endif


2376    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))


2377        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800


2378            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"


2379        #endif


2380    #endif


2381#endif


2382


2383// C++ language standard detection


2384// if the user manually specified the used c++ version this is skipped


2385#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)


2386    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)


2387        #define JSON_HAS_CPP_20


2388        #define JSON_HAS_CPP_17


2389        #define JSON_HAS_CPP_14


2390    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464


2391        #define JSON_HAS_CPP_17


2392        #define JSON_HAS_CPP_14


2393    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)


2394        #define JSON_HAS_CPP_14


2395    #endif


2396    // the cpp 11 flag is always specified because it is the minimal required version


2397    #define JSON_HAS_CPP_11


2398#endif


2399


2400#ifdef __has_include


2401    #if __has_include(<version>)


2402        #include <version>


2403    #endif


2404#endif


2405


2406#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)


2407    #ifdef JSON_HAS_CPP_17


2408        #if defined(__cpp_lib_filesystem)


2409            #define JSON_HAS_FILESYSTEM 1


2410        #elif defined(__cpp_lib_experimental_filesystem)


2411            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1


2412        #elif !defined(__has_include)


2413            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1


2414        #elif __has_include(<filesystem>)


2415            #define JSON_HAS_FILESYSTEM 1


2416        #elif __has_include(<experimental/filesystem>)


2417            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1


2418        #endif


2419


2420        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/


2421        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8


2422            #undef JSON_HAS_FILESYSTEM


2423            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2424        #endif


2425


2426        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support


2427        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8


2428            #undef JSON_HAS_FILESYSTEM


2429            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2430        #endif


2431


2432        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support


2433        #if defined(__clang_major__) && __clang_major__ < 7


2434            #undef JSON_HAS_FILESYSTEM


2435            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2436        #endif


2437


2438        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support


2439        #if defined(_MSC_VER) && _MSC_VER < 1914


2440            #undef JSON_HAS_FILESYSTEM


2441            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2442        #endif


2443


2444        // no filesystem support before iOS 13


2445        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000


2446            #undef JSON_HAS_FILESYSTEM


2447            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2448        #endif


2449


2450        // no filesystem support before macOS Catalina


2451        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500


2452            #undef JSON_HAS_FILESYSTEM


2453            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2454        #endif


2455    #endif


2456#endif


2457


2458#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM


2459    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0


2460#endif


2461


2462#ifndef JSON_HAS_FILESYSTEM


2463    #define JSON_HAS_FILESYSTEM 0


2464#endif


2465


2466#ifndef JSON_HAS_THREE_WAY_COMPARISON


2467    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \


2468        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L


2469        #define JSON_HAS_THREE_WAY_COMPARISON 1


2470    #else


2471        #define JSON_HAS_THREE_WAY_COMPARISON 0


2472    #endif


2473#endif


2474


2475#ifndef JSON_HAS_RANGES


2476    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error


2477    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427


2478        #define JSON_HAS_RANGES 0


2479    #elif defined(__cpp_lib_ranges)


2480        #define JSON_HAS_RANGES 1


2481    #else


2482        #define JSON_HAS_RANGES 0


2483    #endif


2484#endif


2485


2486#ifdef JSON_HAS_CPP_17


2487    #define JSON_INLINE_VARIABLE inline


2488#else


2489    #define JSON_INLINE_VARIABLE


2490#endif


2491


2492#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)


2493    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]


2494#else


2495    #define JSON_NO_UNIQUE_ADDRESS


2496#endif


2497


2498// disable documentation warnings on clang


2499#if defined(__clang__)


2500    #pragma clang diagnostic push


2501    #pragma clang diagnostic ignored "-Wdocumentation"


2502    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"


2503#endif


2504


2505// allow disabling exceptions


2506#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)


2507    #define JSON_THROW(exception) throw exception


2508    #define JSON_TRY try


2509    #define JSON_CATCH(exception) catch(exception)


2510    #define JSON_INTERNAL_CATCH(exception) catch(exception)


2511#else


2512    #include <cstdlib>


2513    #define JSON_THROW(exception) std::abort()


2514    #define JSON_TRY if(true)


2515    #define JSON_CATCH(exception) if(false)


2516    #define JSON_INTERNAL_CATCH(exception) if(false)


2517#endif


2518


2519// override exception macros


2520#if defined(JSON_THROW_USER)


2521    #undef JSON_THROW


2522    #define JSON_THROW JSON_THROW_USER


2523#endif


2524#if defined(JSON_TRY_USER)


2525    #undef JSON_TRY


2526    #define JSON_TRY JSON_TRY_USER


2527#endif


2528#if defined(JSON_CATCH_USER)


2529    #undef JSON_CATCH


2530    #define JSON_CATCH JSON_CATCH_USER


2531    #undef JSON_INTERNAL_CATCH


2532    #define JSON_INTERNAL_CATCH JSON_CATCH_USER


2533#endif


2534#if defined(JSON_INTERNAL_CATCH_USER)


2535    #undef JSON_INTERNAL_CATCH


2536    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER


2537#endif


2538


2539// allow overriding assert


2540#if !defined(JSON_ASSERT)


2541    #include <cassert> // assert


2542    #define JSON_ASSERT(x) assert(x)


2543#endif


2544


2545// allow to access some private functions (needed by the test suite)


2546#if defined(JSON_TESTS_PRIVATE)


2547    #define JSON_PRIVATE_UNLESS_TESTED public


2548#else


2549    #define JSON_PRIVATE_UNLESS_TESTED private


2550#endif


2551


2552/*!


2553@brief macro to briefly define a mapping between an enum and JSON


2554@def NLOHMANN_JSON_SERIALIZE_ENUM


2555@since version 3.4.0


2556*/


2557#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \


2558    template<typename BasicJsonType>                                                            \


2559    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \


2560    {                                                                                           \


2561        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \


2562        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \


2563        auto it = std::find_if(std::begin(m), std::end(m),                                      \


2564                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \


2565        {                                                                                       \


2566            return ej_pair.first == e;                                                          \


2567        });                                                                                     \


2568        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \


2569    }                                                                                           \


2570    template<typename BasicJsonType>                                                            \


2571    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \


2572    {                                                                                           \


2573        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \


2574        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \


2575        auto it = std::find_if(std::begin(m), std::end(m),                                      \


2576                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \


2577        {                                                                                       \


2578            return ej_pair.second == j;                                                         \


2579        });                                                                                     \


2580        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \


2581    }


2582


2583// Ugly macros to avoid uglier copy-paste when specializing basic_json. They


2584// may be removed in the future once the class is split.


2585


2586#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \


2587    template<template<typename, typename, typename...> class ObjectType,   \


2588             template<typename, typename...> class ArrayType,              \


2589             class StringType, class BooleanType, class NumberIntegerType, \


2590             class NumberUnsignedType, class NumberFloatType,              \


2591             template<typename> class AllocatorType,                       \


2592             template<typename, typename = void> class JSONSerializer,     \


2593             class BinaryType>


2594


2595#define NLOHMANN_BASIC_JSON_TPL                                            \


2596    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \


2597    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \


2598    AllocatorType, JSONSerializer, BinaryType>


2599


2600// Macros to simplify conversion from/to types


2601


2602#define NLOHMANN_JSON_EXPAND( x ) x


2603#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


2604#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \


2605        NLOHMANN_JSON_PASTE64, \


2606        NLOHMANN_JSON_PASTE63, \


2607        NLOHMANN_JSON_PASTE62, \


2608        NLOHMANN_JSON_PASTE61, \


2609        NLOHMANN_JSON_PASTE60, \


2610        NLOHMANN_JSON_PASTE59, \


2611        NLOHMANN_JSON_PASTE58, \


2612        NLOHMANN_JSON_PASTE57, \


2613        NLOHMANN_JSON_PASTE56, \


2614        NLOHMANN_JSON_PASTE55, \


2615        NLOHMANN_JSON_PASTE54, \


2616        NLOHMANN_JSON_PASTE53, \


2617        NLOHMANN_JSON_PASTE52, \


2618        NLOHMANN_JSON_PASTE51, \


2619        NLOHMANN_JSON_PASTE50, \


2620        NLOHMANN_JSON_PASTE49, \


2621        NLOHMANN_JSON_PASTE48, \


2622        NLOHMANN_JSON_PASTE47, \


2623        NLOHMANN_JSON_PASTE46, \


2624        NLOHMANN_JSON_PASTE45, \


2625        NLOHMANN_JSON_PASTE44, \


2626        NLOHMANN_JSON_PASTE43, \


2627        NLOHMANN_JSON_PASTE42, \


2628        NLOHMANN_JSON_PASTE41, \


2629        NLOHMANN_JSON_PASTE40, \


2630        NLOHMANN_JSON_PASTE39, \


2631        NLOHMANN_JSON_PASTE38, \


2632        NLOHMANN_JSON_PASTE37, \


2633        NLOHMANN_JSON_PASTE36, \


2634        NLOHMANN_JSON_PASTE35, \


2635        NLOHMANN_JSON_PASTE34, \


2636        NLOHMANN_JSON_PASTE33, \


2637        NLOHMANN_JSON_PASTE32, \


2638        NLOHMANN_JSON_PASTE31, \


2639        NLOHMANN_JSON_PASTE30, \


2640        NLOHMANN_JSON_PASTE29, \


2641        NLOHMANN_JSON_PASTE28, \


2642        NLOHMANN_JSON_PASTE27, \


2643        NLOHMANN_JSON_PASTE26, \


2644        NLOHMANN_JSON_PASTE25, \


2645        NLOHMANN_JSON_PASTE24, \


2646        NLOHMANN_JSON_PASTE23, \


2647        NLOHMANN_JSON_PASTE22, \


2648        NLOHMANN_JSON_PASTE21, \


2649        NLOHMANN_JSON_PASTE20, \


2650        NLOHMANN_JSON_PASTE19, \


2651        NLOHMANN_JSON_PASTE18, \


2652        NLOHMANN_JSON_PASTE17, \


2653        NLOHMANN_JSON_PASTE16, \


2654        NLOHMANN_JSON_PASTE15, \


2655        NLOHMANN_JSON_PASTE14, \


2656        NLOHMANN_JSON_PASTE13, \


2657        NLOHMANN_JSON_PASTE12, \


2658        NLOHMANN_JSON_PASTE11, \


2659        NLOHMANN_JSON_PASTE10, \


2660        NLOHMANN_JSON_PASTE9, \


2661        NLOHMANN_JSON_PASTE8, \


2662        NLOHMANN_JSON_PASTE7, \


2663        NLOHMANN_JSON_PASTE6, \


2664        NLOHMANN_JSON_PASTE5, \


2665        NLOHMANN_JSON_PASTE4, \


2666        NLOHMANN_JSON_PASTE3, \


2667        NLOHMANN_JSON_PASTE2, \


2668        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))


2669#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)


2670#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)


2671#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)


2672#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)


2673#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)


2674#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)


2675#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)


2676#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)


2677#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)


2678#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)


2679#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)


2680#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)


2681#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)


2682#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)


2683#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)


2684#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)


2685#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)


2686#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)


2687#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)


2688#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)


2689#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)


2690#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)


2691#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)


2692#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)


2693#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)


2694#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)


2695#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)


2696#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)


2697#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)


2698#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)


2699#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)


2700#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)


2701#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)


2702#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)


2703#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)


2704#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)


2705#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)


2706#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)


2707#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)


2708#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)


2709#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)


2710#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)


2711#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)


2712#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)


2713#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)


2714#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)


2715#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)


2716#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)


2717#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)


2718#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)


2719#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)


2720#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)


2721#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)


2722#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)


2723#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)


2724#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)


2725#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)


2726#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)


2727#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)


2728#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)


2729#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)


2730#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)


2731#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)


2732


2733#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;


2734#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);


2735#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);


2736


2737/*!


2738@brief macro


2739@def NLOHMANN_DEFINE_TYPE_INTRUSIVE


2740@since version 3.9.0


2741*/


2742#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \


2743    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__)) } \


2744    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__)) }


2745


2746#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \


2747    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__)) } \


2748    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }


2749


2750/*!


2751@brief macro


2752@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE


2753@since version 3.9.0


2754*/


2755#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \


2756    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__)) } \


2757    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__)) }


2758


2759#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \


2760    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__)) } \


2761    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }


2762


2763


2764// inspired from https://stackoverflow.com/a/26745591


2765// allows to call any std function as if (e.g. with begin):


2766// using std::begin; begin(x);


2767//


2768// it allows using the detected idiom to retrieve the return type


2769// of such an expression


2770#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \


2771    namespace detail {                                                            \


2772    using std::std_name;                                                          \


2773    \


2774    template<typename... T>                                                       \


2775    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \


2776    }                                                                             \


2777    \


2778    namespace detail2 {                                                           \


2779    struct std_name##_tag                                                         \


2780    {                                                                             \


2781    };                                                                            \


2782    \


2783    template<typename... T>                                                       \


2784    std_name##_tag std_name(T&&...);                                              \


2785    \


2786    template<typename... T>                                                       \


2787    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \


2788    \


2789    template<typename... T>                                                       \


2790    struct would_call_std_##std_name                                              \


2791    {                                                                             \


2792        static constexpr auto const value = ::nlohmann::detail::                  \


2793                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \


2794    };                                                                            \


2795    } /* namespace detail2 */ \


2796    \


2797    template<typename... T>                                                       \


2798    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \


2799    {                                                                             \


2800    }


2801


2802#ifndef JSON_USE_IMPLICIT_CONVERSIONS


2803    #define JSON_USE_IMPLICIT_CONVERSIONS 1


2804#endif


2805


2806#if JSON_USE_IMPLICIT_CONVERSIONS


2807    #define JSON_EXPLICIT


2808#else


2809    #define JSON_EXPLICIT explicit


2810#endif


2811


2812#ifndef JSON_DISABLE_ENUM_SERIALIZATION


2813    #define JSON_DISABLE_ENUM_SERIALIZATION 0


2814#endif


2815


2816#ifndef JSON_USE_GLOBAL_UDLS


2817    #define JSON_USE_GLOBAL_UDLS 1


2818#endif


2819


2820#if JSON_HAS_THREE_WAY_COMPARISON


2821    #include <compare> // partial_ordering


2822#endif


2823


2824NLOHMANN_JSON_NAMESPACE_BEGIN


2825namespace detail


2826{


2827


2828///////////////////////////


2829// JSON type enumeration //


2830///////////////////////////


2831


2832/*!


2833@brief the JSON type enumeration


2834


2835This enumeration collects the different JSON types. It is internally used to


2836distinguish the stored values, and the functions @ref basic_json::is_null(),


2837@ref basic_json::is_object(), @ref basic_json::is_array(),


2838@ref basic_json::is_string(), @ref basic_json::is_boolean(),


2839@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),


2840@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),


2841@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and


2842@ref basic_json::is_structured() rely on it.


2843


2844@note There are three enumeration entries (number_integer, number_unsigned, and


2845number_float), because the library distinguishes these three types for numbers:


2846@ref basic_json::number_unsigned_t is used for unsigned integers,


2847@ref basic_json::number_integer_t is used for signed integers, and


2848@ref basic_json::number_float_t is used for floating-point numbers or to


2849approximate integers which do not fit in the limits of their respective type.


2850


2851@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON


2852value with the default value for a given type


2853


2854@since version 1.0.0


2855*/


2856enum class value_t : std::uint8_t


2857{


2858    null,             ///< null value


2859    object,           ///< object (unordered set of name/value pairs)


2860    array,            ///< array (ordered collection of values)


2861    string,           ///< string value


2862    boolean,          ///< boolean value


2863    number_integer,   ///< number value (signed integer)


2864    number_unsigned,  ///< number value (unsigned integer)


2865    number_float,     ///< number value (floating-point)


2866    binary,           ///< binary array (ordered collection of bytes)


2867    discarded         ///< discarded by the parser callback function


2868};


2869


2870/*!


2871@brief comparison operator for JSON types


2872


2873Returns an ordering that is similar to Python:


2874- order: null < boolean < number < object < array < string < binary


2875- furthermore, each type is not smaller than itself


2876- discarded values are not comparable


2877- binary is represented as a b"" string in python and directly comparable to a


2878  string; however, making a binary array directly comparable with a string would


2879  be surprising behavior in a JSON file.


2880


2881@since version 1.0.0


2882*/


2883#if JSON_HAS_THREE_WAY_COMPARISON


2884    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*


2885#else


2886    inline bool operator<(const value_t lhs, const value_t rhs) noexcept


2887#endif


2888{


2889    static constexpr std::array<std::uint8_t, 9> order = {{


2890            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,


2891            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,


2892            6 /* binary */


2893        }


2894    };


2895


2896    const auto l_index = static_cast<std::size_t>(lhs);


2897    const auto r_index = static_cast<std::size_t>(rhs);


2898#if JSON_HAS_THREE_WAY_COMPARISON


2899    if (l_index < order.size() && r_index < order.size())


2900    {


2901        return order[l_index] <=> order[r_index]; // *NOPAD*


2902    }


2903    return std::partial_ordering::unordered;


2904#else


2905    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];


2906#endif


2907}


2908


2909// GCC selects the built-in operator< over an operator rewritten from


2910// a user-defined spaceship operator


2911// Clang, MSVC, and ICC select the rewritten candidate


2912// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)


2913#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)


2914inline bool operator<(const value_t lhs, const value_t rhs) noexcept


2915{


2916    return std::is_lt(lhs <=> rhs); // *NOPAD*


2917}


2918#endif


2919


2920}  // namespace detail


2921NLOHMANN_JSON_NAMESPACE_END


2922


2923// #include <nlohmann/detail/string_escape.hpp>


2924//     __ _____ _____ _____


2925//  __|  |   __|     |   | |  JSON for Modern C++


2926// |  |  |__   |  |  | | | |  version 3.11.2


2927// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


2928//


2929// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


2930// SPDX-License-Identifier: MIT


2931


2932


2933


2934// #include <nlohmann/detail/abi_macros.hpp>


2935


2936


2937NLOHMANN_JSON_NAMESPACE_BEGIN


2938namespace detail


2939{


2940


2941/*!


2942@brief replace all occurrences of a substring by another string


2943


2944@param[in,out] s  the string to manipulate; changed so that all


2945               occurrences of @a f are replaced with @a t


2946@param[in]     f  the substring to replace with @a t


2947@param[in]     t  the string to replace @a f


2948


2949@pre The search string @a f must not be empty. **This precondition is


2950enforced with an assertion.**


2951


2952@since version 2.0.0


2953*/


2954template<typename StringType>


2955inline void replace_substring(StringType& s, const StringType& f,


2956                              const StringType& t)


2957{


2958    JSON_ASSERT(!f.empty());


2959    for (auto pos = s.find(f);                // find first occurrence of f


2960            pos != StringType::npos;          // make sure f was found


2961            s.replace(pos, f.size(), t),      // replace with t, and


2962            pos = s.find(f, pos + t.size()))  // find next occurrence of f


2963    {}


2964}


2965


2966/*!


2967 * @brief string escaping as described in RFC 6901 (Sect. 4)


2968 * @param[in] s string to escape


2969 * @return    escaped string


2970 *


2971 * Note the order of escaping "~" to "~0" and "/" to "~1" is important.


2972 */


2973template<typename StringType>


2974inline StringType escape(StringType s)


2975{


2976    replace_substring(s, StringType{"~"}, StringType{"~0"});


2977    replace_substring(s, StringType{"/"}, StringType{"~1"});


2978    return s;


2979}


2980


2981/*!


2982 * @brief string unescaping as described in RFC 6901 (Sect. 4)


2983 * @param[in] s string to unescape


2984 * @return    unescaped string


2985 *


2986 * Note the order of escaping "~1" to "/" and "~0" to "~" is important.


2987 */


2988template<typename StringType>


2989static void unescape(StringType& s)


2990{


2991    replace_substring(s, StringType{"~1"}, StringType{"/"});


2992    replace_substring(s, StringType{"~0"}, StringType{"~"});


2993}


2994


2995}  // namespace detail


2996NLOHMANN_JSON_NAMESPACE_END


2997


2998// #include <nlohmann/detail/input/position_t.hpp>


2999//     __ _____ _____ _____


3000//  __|  |   __|     |   | |  JSON for Modern C++


3001// |  |  |__   |  |  | | | |  version 3.11.2


3002// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3003//


3004// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3005// SPDX-License-Identifier: MIT


3006


3007


3008


3009#include <cstddef> // size_t


3010


3011// #include <nlohmann/detail/abi_macros.hpp>


3012


3013


3014NLOHMANN_JSON_NAMESPACE_BEGIN


3015namespace detail


3016{


3017


3018/// struct to capture the start position of the current token


3019struct position_t


3020{


3021    /// the total number of characters read


3022    std::size_t chars_read_total = 0;


3023    /// the number of characters read in the current line


3024    std::size_t chars_read_current_line = 0;


3025    /// the number of lines read


3026    std::size_t lines_read = 0;


3027


3028    /// conversion to size_t to preserve SAX interface


3029    constexpr operator size_t() const


3030    {


3031        return chars_read_total;


3032    }


3033};


3034


3035}  // namespace detail


3036NLOHMANN_JSON_NAMESPACE_END


3037


3038// #include <nlohmann/detail/macro_scope.hpp>


3039


3040// #include <nlohmann/detail/meta/cpp_future.hpp>


3041//     __ _____ _____ _____


3042//  __|  |   __|     |   | |  JSON for Modern C++


3043// |  |  |__   |  |  | | | |  version 3.11.2


3044// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3045//


3046// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3047// SPDX-FileCopyrightText: 2018 The Abseil Authors


3048// SPDX-License-Identifier: MIT


3049


3050


3051


3052#include <array> // array


3053#include <cstddef> // size_t


3054#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type


3055#include <utility> // index_sequence, make_index_sequence, index_sequence_for


3056


3057// #include <nlohmann/detail/macro_scope.hpp>


3058


3059


3060NLOHMANN_JSON_NAMESPACE_BEGIN


3061namespace detail


3062{


3063


3064template<typename T>


3065using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;


3066


3067#ifdef JSON_HAS_CPP_14


3068


3069// the following utilities are natively available in C++14


3070using std::enable_if_t;


3071using std::index_sequence;


3072using std::make_index_sequence;


3073using std::index_sequence_for;


3074


3075#else


3076


3077// alias templates to reduce boilerplate


3078template<bool B, typename T = void>


3079using enable_if_t = typename std::enable_if<B, T>::type;


3080


3081// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h


3082// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.


3083


3084//// START OF CODE FROM GOOGLE ABSEIL


3085


3086// integer_sequence


3087//


3088// Class template representing a compile-time integer sequence. An instantiation


3089// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its


3090// type through its template arguments (which is a common need when


3091// working with C++11 variadic templates). `absl::integer_sequence` is designed


3092// to be a drop-in replacement for C++14's `std::integer_sequence`.


3093//


3094// Example:


3095//


3096//   template< class T, T... Ints >


3097//   void user_function(integer_sequence<T, Ints...>);


3098//


3099//   int main()


3100//   {


3101//     // user_function's `T` will be deduced to `int` and `Ints...`


3102//     // will be deduced to `0, 1, 2, 3, 4`.


3103//     user_function(make_integer_sequence<int, 5>());


3104//   }


3105template <typename T, T... Ints>


3106struct integer_sequence


3107{


3108    using value_type = T;


3109    static constexpr std::size_t size() noexcept


3110    {


3111        return sizeof...(Ints);


3112    }


3113};


3114


3115// index_sequence


3116//


3117// A helper template for an `integer_sequence` of `size_t`,


3118// `absl::index_sequence` is designed to be a drop-in replacement for C++14's


3119// `std::index_sequence`.


3120template <size_t... Ints>


3121using index_sequence = integer_sequence<size_t, Ints...>;


3122


3123namespace utility_internal


3124{


3125


3126template <typename Seq, size_t SeqSize, size_t Rem>


3127struct Extend;


3128


3129// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.


3130template <typename T, T... Ints, size_t SeqSize>


3131struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>


3132{


3133    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;


3134};


3135


3136template <typename T, T... Ints, size_t SeqSize>


3137struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>


3138{


3139    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;


3140};


3141


3142// Recursion helper for 'make_integer_sequence<T, N>'.


3143// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.


3144template <typename T, size_t N>


3145struct Gen


3146{


3147    using type =


3148        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;


3149};


3150


3151template <typename T>


3152struct Gen<T, 0>


3153{


3154    using type = integer_sequence<T>;


3155};


3156


3157}  // namespace utility_internal


3158


3159// Compile-time sequences of integers


3160


3161// make_integer_sequence


3162//


3163// This template alias is equivalent to


3164// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in


3165// replacement for C++14's `std::make_integer_sequence`.


3166template <typename T, T N>


3167using make_integer_sequence = typename utility_internal::Gen<T, N>::type;


3168


3169// make_index_sequence


3170//


3171// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,


3172// and is designed to be a drop-in replacement for C++14's


3173// `std::make_index_sequence`.


3174template <size_t N>


3175using make_index_sequence = make_integer_sequence<size_t, N>;


3176


3177// index_sequence_for


3178//


3179// Converts a typename pack into an index sequence of the same length, and


3180// is designed to be a drop-in replacement for C++14's


3181// `std::index_sequence_for()`


3182template <typename... Ts>


3183using index_sequence_for = make_index_sequence<sizeof...(Ts)>;


3184


3185//// END OF CODE FROM GOOGLE ABSEIL


3186


3187#endif


3188


3189// dispatch utility (taken from ranges-v3)


3190template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};


3191template<> struct priority_tag<0> {};


3192


3193// taken from ranges-v3


3194template<typename T>


3195struct static_const


3196{


3197    static JSON_INLINE_VARIABLE constexpr T value{};


3198};


3199


3200#ifndef JSON_HAS_CPP_17


3201    template<typename T>


3202    constexpr T static_const<T>::value;


3203#endif


3204


3205template<typename T, typename... Args>


3206inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)


3207{


3208    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};


3209}


3210


3211}  // namespace detail


3212NLOHMANN_JSON_NAMESPACE_END


3213


3214// #include <nlohmann/detail/meta/type_traits.hpp>


3215//     __ _____ _____ _____


3216//  __|  |   __|     |   | |  JSON for Modern C++


3217// |  |  |__   |  |  | | | |  version 3.11.2


3218// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3219//


3220// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3221// SPDX-License-Identifier: MIT


3222


3223


3224


3225#include <limits> // numeric_limits


3226#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type


3227#include <utility> // declval


3228#include <tuple> // tuple


3229


3230// #include <nlohmann/detail/iterators/iterator_traits.hpp>


3231//     __ _____ _____ _____


3232//  __|  |   __|     |   | |  JSON for Modern C++


3233// |  |  |__   |  |  | | | |  version 3.11.2


3234// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3235//


3236// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3237// SPDX-License-Identifier: MIT


3238


3239


3240


3241#include <iterator> // random_access_iterator_tag


3242


3243// #include <nlohmann/detail/abi_macros.hpp>


3244


3245// #include <nlohmann/detail/meta/void_t.hpp>


3246


3247// #include <nlohmann/detail/meta/cpp_future.hpp>


3248


3249


3250NLOHMANN_JSON_NAMESPACE_BEGIN


3251namespace detail


3252{


3253


3254template<typename It, typename = void>


3255struct iterator_types {};


3256


3257template<typename It>


3258struct iterator_types <


3259    It,


3260    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,


3261    typename It::reference, typename It::iterator_category >>


3262{


3263    using difference_type = typename It::difference_type;


3264    using value_type = typename It::value_type;


3265    using pointer = typename It::pointer;


3266    using reference = typename It::reference;


3267    using iterator_category = typename It::iterator_category;


3268};


3269


3270// This is required as some compilers implement std::iterator_traits in a way that


3271// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.


3272template<typename T, typename = void>


3273struct iterator_traits


3274{


3275};


3276


3277template<typename T>


3278struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>


3279            : iterator_types<T>


3280{


3281};


3282


3283template<typename T>


3284struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>


3285{


3286    using iterator_category = std::random_access_iterator_tag;


3287    using value_type = T;


3288    using difference_type = ptrdiff_t;


3289    using pointer = T*;


3290    using reference = T&;


3291};


3292


3293}  // namespace detail


3294NLOHMANN_JSON_NAMESPACE_END


3295


3296// #include <nlohmann/detail/macro_scope.hpp>


3297


3298// #include <nlohmann/detail/meta/call_std/begin.hpp>


3299//     __ _____ _____ _____


3300//  __|  |   __|     |   | |  JSON for Modern C++


3301// |  |  |__   |  |  | | | |  version 3.11.2


3302// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3303//


3304// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3305// SPDX-License-Identifier: MIT


3306


3307


3308


3309// #include <nlohmann/detail/macro_scope.hpp>


3310


3311


3312NLOHMANN_JSON_NAMESPACE_BEGIN


3313


3314NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);


3315


3316NLOHMANN_JSON_NAMESPACE_END


3317


3318// #include <nlohmann/detail/meta/call_std/end.hpp>


3319//     __ _____ _____ _____


3320//  __|  |   __|     |   | |  JSON for Modern C++


3321// |  |  |__   |  |  | | | |  version 3.11.2


3322// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3323//


3324// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3325// SPDX-License-Identifier: MIT


3326


3327


3328


3329// #include <nlohmann/detail/macro_scope.hpp>


3330


3331


3332NLOHMANN_JSON_NAMESPACE_BEGIN


3333


3334NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);


3335


3336NLOHMANN_JSON_NAMESPACE_END


3337


3338// #include <nlohmann/detail/meta/cpp_future.hpp>


3339


3340// #include <nlohmann/detail/meta/detected.hpp>


3341


3342// #include <nlohmann/json_fwd.hpp>


3343//     __ _____ _____ _____


3344//  __|  |   __|     |   | |  JSON for Modern C++


3345// |  |  |__   |  |  | | | |  version 3.11.2


3346// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


3347//


3348// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


3349// SPDX-License-Identifier: MIT


3350


3351#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_


3352    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_


3353


3354    #include <cstdint> // int64_t, uint64_t


3355    #include <map> // map


3356    #include <memory> // allocator


3357    #include <string> // string


3358    #include <vector> // vector


3359


3360    // #include <nlohmann/detail/abi_macros.hpp>


3361


3362


3363    /*!


3364    @brief namespace for Niels Lohmann


3365    @see https://github.com/nlohmann


3366    @since version 1.0.0


3367    */


3368    NLOHMANN_JSON_NAMESPACE_BEGIN


3369


3370    /*!


3371    @brief default JSONSerializer template argument


3372


3373    This serializer ignores the template arguments and uses ADL


3374    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))


3375    for serialization.


3376    */


3377    template<typename T = void, typename SFINAE = void>


3378    struct adl_serializer;


3379


3380    /// a class to store JSON values


3381    /// @sa https://json.nlohmann.me/api/basic_json/


3382    template<template<typename U, typename V, typename... Args> class ObjectType =


3383    std::map,


3384    template<typename U, typename... Args> class ArrayType = std::vector,


3385    class StringType = std::string, class BooleanType = bool,


3386    class NumberIntegerType = std::int64_t,


3387    class NumberUnsignedType = std::uint64_t,


3388    class NumberFloatType = double,


3389    template<typename U> class AllocatorType = std::allocator,


3390    template<typename T, typename SFINAE = void> class JSONSerializer =


3391    adl_serializer,


3392    class BinaryType = std::vector<std::uint8_t>>


3393    class basic_json;


3394


3395    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document


3396    /// @sa https://json.nlohmann.me/api/json_pointer/


3397    template<typename RefStringType>


3398    class json_pointer;


3399


3400    /*!


3401    @brief default specialization


3402    @sa https://json.nlohmann.me/api/json/


3403    */


3404    using json = basic_json<>;


3405


3406    /// @brief a minimal map-like container that preserves insertion order


3407    /// @sa https://json.nlohmann.me/api/ordered_map/


3408    template<class Key, class T, class IgnoredLess, class Allocator>


3409    struct ordered_map;


3410


3411    /// @brief specialization that maintains the insertion order of object keys


3412    /// @sa https://json.nlohmann.me/api/ordered_json/


3413    using ordered_json = basic_json<nlohmann::ordered_map>;


3414


3415    NLOHMANN_JSON_NAMESPACE_END


3416


3417#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_


3418


3419


3420NLOHMANN_JSON_NAMESPACE_BEGIN


3421/*!


3422@brief detail namespace with internal helper functions


3423


3424This namespace collects functions that should not be exposed,


3425implementations of some @ref basic_json methods, and meta-programming helpers.


3426


3427@since version 2.1.0


3428*/


3429namespace detail


3430{


3431


3432/////////////


3433// helpers //


3434/////////////


3435


3436// Note to maintainers:


3437//


3438// Every trait in this file expects a non CV-qualified type.


3439// The only exceptions are in the 'aliases for detected' section


3440// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))


3441//


3442// In this case, T has to be properly CV-qualified to constraint the function arguments


3443// (e.g. to_json(BasicJsonType&, const T&))


3444


3445template<typename> struct is_basic_json : std::false_type {};


3446


3447NLOHMANN_BASIC_JSON_TPL_DECLARATION


3448struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};


3449


3450// used by exceptions create() member functions


3451// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t


3452// false_type otherwise


3453template<typename BasicJsonContext>


3454struct is_basic_json_context :


3455    std::integral_constant < bool,


3456    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value


3457    || std::is_same<BasicJsonContext, std::nullptr_t>::value >


3458{};


3459


3460//////////////////////


3461// json_ref helpers //


3462//////////////////////


3463


3464template<typename>


3465class json_ref;


3466


3467template<typename>


3468struct is_json_ref : std::false_type {};


3469


3470template<typename T>


3471struct is_json_ref<json_ref<T>> : std::true_type {};


3472


3473//////////////////////////


3474// aliases for detected //


3475//////////////////////////


3476


3477template<typename T>


3478using mapped_type_t = typename T::mapped_type;


3479


3480template<typename T>


3481using key_type_t = typename T::key_type;


3482


3483template<typename T>


3484using value_type_t = typename T::value_type;


3485


3486template<typename T>


3487using difference_type_t = typename T::difference_type;


3488


3489template<typename T>


3490using pointer_t = typename T::pointer;


3491


3492template<typename T>


3493using reference_t = typename T::reference;


3494


3495template<typename T>


3496using iterator_category_t = typename T::iterator_category;


3497


3498template<typename T, typename... Args>


3499using to_json_function = decltype(T::to_json(std::declval<Args>()...));


3500


3501template<typename T, typename... Args>


3502using from_json_function = decltype(T::from_json(std::declval<Args>()...));


3503


3504template<typename T, typename U>


3505using get_template_function = decltype(std::declval<T>().template get<U>());


3506


3507// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists


3508template<typename BasicJsonType, typename T, typename = void>


3509struct has_from_json : std::false_type {};


3510


3511// trait checking if j.get<T> is valid


3512// use this trait instead of std::is_constructible or std::is_convertible,


3513// both rely on, or make use of implicit conversions, and thus fail when T


3514// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)


3515template <typename BasicJsonType, typename T>


3516struct is_getable


3517{


3518    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;


3519};


3520


3521template<typename BasicJsonType, typename T>


3522struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>


3523{


3524    using serializer = typename BasicJsonType::template json_serializer<T, void>;


3525


3526    static constexpr bool value =


3527        is_detected_exact<void, from_json_function, serializer,


3528        const BasicJsonType&, T&>::value;


3529};


3530


3531// This trait checks if JSONSerializer<T>::from_json(json const&) exists


3532// this overload is used for non-default-constructible user-defined-types


3533template<typename BasicJsonType, typename T, typename = void>


3534struct has_non_default_from_json : std::false_type {};


3535


3536template<typename BasicJsonType, typename T>


3537struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>


3538{


3539    using serializer = typename BasicJsonType::template json_serializer<T, void>;


3540


3541    static constexpr bool value =


3542        is_detected_exact<T, from_json_function, serializer,


3543        const BasicJsonType&>::value;


3544};


3545


3546// This trait checks if BasicJsonType::json_serializer<T>::to_json exists


3547// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.


3548template<typename BasicJsonType, typename T, typename = void>


3549struct has_to_json : std::false_type {};


3550


3551template<typename BasicJsonType, typename T>


3552struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>


3553{


3554    using serializer = typename BasicJsonType::template json_serializer<T, void>;


3555


3556    static constexpr bool value =


3557        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,


3558        T>::value;


3559};


3560


3561template<typename T>


3562using detect_key_compare = typename T::key_compare;


3563


3564template<typename T>


3565struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};


3566


3567// obtains the actual object key comparator


3568template<typename BasicJsonType>


3569struct actual_object_comparator


3570{


3571    using object_t = typename BasicJsonType::object_t;


3572    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;


3573    using type = typename std::conditional < has_key_compare<object_t>::value,


3574          typename object_t::key_compare, object_comparator_t>::type;


3575};


3576


3577template<typename BasicJsonType>


3578using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;


3579


3580///////////////////


3581// is_ functions //


3582///////////////////


3583


3584// https://en.cppreference.com/w/cpp/types/conjunction


3585template<class...> struct conjunction : std::true_type { };


3586template<class B> struct conjunction<B> : B { };


3587template<class B, class... Bn>


3588struct conjunction<B, Bn...>


3589: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};


3590


3591// https://en.cppreference.com/w/cpp/types/negation


3592template<class B> struct negation : std::integral_constant < bool, !B::value > { };


3593


3594// Reimplementation of is_constructible and is_default_constructible, due to them being broken for


3595// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).


3596// This causes compile errors in e.g. clang 3.5 or gcc 4.9.


3597template <typename T>


3598struct is_default_constructible : std::is_default_constructible<T> {};


3599


3600template <typename T1, typename T2>


3601struct is_default_constructible<std::pair<T1, T2>>


3602            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};


3603


3604template <typename T1, typename T2>


3605struct is_default_constructible<const std::pair<T1, T2>>


3606            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};


3607


3608template <typename... Ts>


3609struct is_default_constructible<std::tuple<Ts...>>


3610            : conjunction<is_default_constructible<Ts>...> {};


3611


3612template <typename... Ts>


3613struct is_default_constructible<const std::tuple<Ts...>>


3614            : conjunction<is_default_constructible<Ts>...> {};


3615


3616


3617template <typename T, typename... Args>


3618struct is_constructible : std::is_constructible<T, Args...> {};


3619


3620template <typename T1, typename T2>


3621struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};


3622


3623template <typename T1, typename T2>


3624struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};


3625


3626template <typename... Ts>


3627struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};


3628


3629template <typename... Ts>


3630struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};


3631


3632


3633template<typename T, typename = void>


3634struct is_iterator_traits : std::false_type {};


3635


3636template<typename T>


3637struct is_iterator_traits<iterator_traits<T>>


3638{


3639  private:


3640    using traits = iterator_traits<T>;


3641


3642  public:


3643    static constexpr auto value =


3644        is_detected<value_type_t, traits>::value &&


3645        is_detected<difference_type_t, traits>::value &&


3646        is_detected<pointer_t, traits>::value &&


3647        is_detected<iterator_category_t, traits>::value &&


3648        is_detected<reference_t, traits>::value;


3649};


3650


3651template<typename T>


3652struct is_range


3653{


3654  private:


3655    using t_ref = typename std::add_lvalue_reference<T>::type;


3656


3657    using iterator = detected_t<result_of_begin, t_ref>;


3658    using sentinel = detected_t<result_of_end, t_ref>;


3659


3660    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator


3661    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for


3662    // but reimplementing these would be too much work, as a lot of other concepts are used underneath


3663    static constexpr auto is_iterator_begin =


3664        is_iterator_traits<iterator_traits<iterator>>::value;


3665


3666  public:


3667    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;


3668};


3669


3670template<typename R>


3671using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;


3672


3673template<typename T>


3674using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;


3675


3676// The following implementation of is_complete_type is taken from


3677// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/


3678// and is written by Xiang Fan who agreed to using it in this library.


3679


3680template<typename T, typename = void>


3681struct is_complete_type : std::false_type {};


3682


3683template<typename T>


3684struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};


3685


3686template<typename BasicJsonType, typename CompatibleObjectType,


3687         typename = void>


3688struct is_compatible_object_type_impl : std::false_type {};


3689


3690template<typename BasicJsonType, typename CompatibleObjectType>


3691struct is_compatible_object_type_impl <


3692    BasicJsonType, CompatibleObjectType,


3693    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&


3694    is_detected<key_type_t, CompatibleObjectType>::value >>


3695{


3696    using object_t = typename BasicJsonType::object_t;


3697


3698    // macOS's is_constructible does not play well with nonesuch...


3699    static constexpr bool value =


3700        is_constructible<typename object_t::key_type,


3701        typename CompatibleObjectType::key_type>::value &&


3702        is_constructible<typename object_t::mapped_type,


3703        typename CompatibleObjectType::mapped_type>::value;


3704};


3705


3706template<typename BasicJsonType, typename CompatibleObjectType>


3707struct is_compatible_object_type


3708    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};


3709


3710template<typename BasicJsonType, typename ConstructibleObjectType,


3711         typename = void>


3712struct is_constructible_object_type_impl : std::false_type {};


3713


3714template<typename BasicJsonType, typename ConstructibleObjectType>


3715struct is_constructible_object_type_impl <


3716    BasicJsonType, ConstructibleObjectType,


3717    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&


3718    is_detected<key_type_t, ConstructibleObjectType>::value >>


3719{


3720    using object_t = typename BasicJsonType::object_t;


3721


3722    static constexpr bool value =


3723        (is_default_constructible<ConstructibleObjectType>::value &&


3724         (std::is_move_assignable<ConstructibleObjectType>::value ||


3725          std::is_copy_assignable<ConstructibleObjectType>::value) &&


3726         (is_constructible<typename ConstructibleObjectType::key_type,


3727          typename object_t::key_type>::value &&


3728          std::is_same <


3729          typename object_t::mapped_type,


3730          typename ConstructibleObjectType::mapped_type >::value)) ||


3731        (has_from_json<BasicJsonType,


3732         typename ConstructibleObjectType::mapped_type>::value ||


3733         has_non_default_from_json <


3734         BasicJsonType,


3735         typename ConstructibleObjectType::mapped_type >::value);


3736};


3737


3738template<typename BasicJsonType, typename ConstructibleObjectType>


3739struct is_constructible_object_type


3740    : is_constructible_object_type_impl<BasicJsonType,


3741      ConstructibleObjectType> {};


3742


3743template<typename BasicJsonType, typename CompatibleStringType>


3744struct is_compatible_string_type


3745{


3746    static constexpr auto value =


3747        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;


3748};


3749


3750template<typename BasicJsonType, typename ConstructibleStringType>


3751struct is_constructible_string_type


3752{


3753    // launder type through decltype() to fix compilation failure on ICPC


3754#ifdef __INTEL_COMPILER


3755    using laundered_type = decltype(std::declval<ConstructibleStringType>());


3756#else


3757    using laundered_type = ConstructibleStringType;


3758#endif


3759


3760    static constexpr auto value =


3761        conjunction <


3762        is_constructible<laundered_type, typename BasicJsonType::string_t>,


3763        is_detected_exact<typename BasicJsonType::string_t::value_type,


3764        value_type_t, laundered_type >>::value;


3765};


3766


3767template<typename BasicJsonType, typename CompatibleArrayType, typename = void>


3768struct is_compatible_array_type_impl : std::false_type {};


3769


3770template<typename BasicJsonType, typename CompatibleArrayType>


3771struct is_compatible_array_type_impl <


3772    BasicJsonType, CompatibleArrayType,


3773    enable_if_t <


3774    is_detected<iterator_t, CompatibleArrayType>::value&&


3775    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&


3776// special case for types like std::filesystem::path whose iterator's value_type are themselves


3777// c.f. https://github.com/nlohmann/json/pull/3073


3778    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>


3779{


3780    static constexpr bool value =


3781        is_constructible<BasicJsonType,


3782        range_value_t<CompatibleArrayType>>::value;


3783};


3784


3785template<typename BasicJsonType, typename CompatibleArrayType>


3786struct is_compatible_array_type


3787    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};


3788


3789template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>


3790struct is_constructible_array_type_impl : std::false_type {};


3791


3792template<typename BasicJsonType, typename ConstructibleArrayType>


3793struct is_constructible_array_type_impl <


3794    BasicJsonType, ConstructibleArrayType,


3795    enable_if_t<std::is_same<ConstructibleArrayType,


3796    typename BasicJsonType::value_type>::value >>


3797            : std::true_type {};


3798


3799template<typename BasicJsonType, typename ConstructibleArrayType>


3800struct is_constructible_array_type_impl <


3801    BasicJsonType, ConstructibleArrayType,


3802    enable_if_t < !std::is_same<ConstructibleArrayType,


3803    typename BasicJsonType::value_type>::value&&


3804    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&


3805    is_default_constructible<ConstructibleArrayType>::value&&


3806(std::is_move_assignable<ConstructibleArrayType>::value ||


3807 std::is_copy_assignable<ConstructibleArrayType>::value)&&


3808is_detected<iterator_t, ConstructibleArrayType>::value&&


3809is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&


3810is_detected<range_value_t, ConstructibleArrayType>::value&&


3811// special case for types like std::filesystem::path whose iterator's value_type are themselves


3812// c.f. https://github.com/nlohmann/json/pull/3073


3813!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&


3814        is_complete_type <


3815        detected_t<range_value_t, ConstructibleArrayType >>::value >>


3816{


3817    using value_type = range_value_t<ConstructibleArrayType>;


3818


3819    static constexpr bool value =


3820        std::is_same<value_type,


3821        typename BasicJsonType::array_t::value_type>::value ||


3822        has_from_json<BasicJsonType,


3823        value_type>::value ||


3824        has_non_default_from_json <


3825        BasicJsonType,


3826        value_type >::value;


3827};


3828


3829template<typename BasicJsonType, typename ConstructibleArrayType>


3830struct is_constructible_array_type


3831    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};


3832


3833template<typename RealIntegerType, typename CompatibleNumberIntegerType,


3834         typename = void>


3835struct is_compatible_integer_type_impl : std::false_type {};


3836


3837template<typename RealIntegerType, typename CompatibleNumberIntegerType>


3838struct is_compatible_integer_type_impl <


3839    RealIntegerType, CompatibleNumberIntegerType,


3840    enable_if_t < std::is_integral<RealIntegerType>::value&&


3841    std::is_integral<CompatibleNumberIntegerType>::value&&


3842    !std::is_same<bool, CompatibleNumberIntegerType>::value >>


3843{


3844    // is there an assert somewhere on overflows?


3845    using RealLimits = std::numeric_limits<RealIntegerType>;


3846    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;


3847


3848    static constexpr auto value =


3849        is_constructible<RealIntegerType,


3850        CompatibleNumberIntegerType>::value &&


3851        CompatibleLimits::is_integer &&


3852        RealLimits::is_signed == CompatibleLimits::is_signed;


3853};


3854


3855template<typename RealIntegerType, typename CompatibleNumberIntegerType>


3856struct is_compatible_integer_type


3857    : is_compatible_integer_type_impl<RealIntegerType,


3858      CompatibleNumberIntegerType> {};


3859


3860template<typename BasicJsonType, typename CompatibleType, typename = void>


3861struct is_compatible_type_impl: std::false_type {};


3862


3863template<typename BasicJsonType, typename CompatibleType>


3864struct is_compatible_type_impl <


3865    BasicJsonType, CompatibleType,


3866    enable_if_t<is_complete_type<CompatibleType>::value >>


3867{


3868    static constexpr bool value =


3869        has_to_json<BasicJsonType, CompatibleType>::value;


3870};


3871


3872template<typename BasicJsonType, typename CompatibleType>


3873struct is_compatible_type


3874    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};


3875


3876template<typename T1, typename T2>


3877struct is_constructible_tuple : std::false_type {};


3878


3879template<typename T1, typename... Args>


3880struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};


3881


3882template<typename BasicJsonType, typename T>


3883struct is_json_iterator_of : std::false_type {};


3884


3885template<typename BasicJsonType>


3886struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};


3887


3888template<typename BasicJsonType>


3889struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type


3890{};


3891


3892// checks if a given type T is a template specialization of Primary


3893template<template <typename...> class Primary, typename T>


3894struct is_specialization_of : std::false_type {};


3895


3896template<template <typename...> class Primary, typename... Args>


3897struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};


3898


3899template<typename T>


3900using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;


3901


3902// checks if A and B are comparable using Compare functor


3903template<typename Compare, typename A, typename B, typename = void>


3904struct is_comparable : std::false_type {};


3905


3906template<typename Compare, typename A, typename B>


3907struct is_comparable<Compare, A, B, void_t<


3908decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),


3909decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))


3910>> : std::true_type {};


3911


3912template<typename T>


3913using detect_is_transparent = typename T::is_transparent;


3914


3915// type trait to check if KeyType can be used as object key (without a BasicJsonType)


3916// see is_usable_as_basic_json_key_type below


3917template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,


3918         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>


3919using is_usable_as_key_type = typename std::conditional <


3920                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value


3921                              && !(ExcludeObjectKeyType && std::is_same<KeyType,


3922                                   ObjectKeyType>::value)


3923                              && (!RequireTransparentComparator


3924                                  || is_detected <detect_is_transparent, Comparator>::value)


3925                              && !is_json_pointer<KeyType>::value,


3926                              std::true_type,


3927                              std::false_type >::type;


3928


3929// type trait to check if KeyType can be used as object key


3930// true if:


3931//   - KeyType is comparable with BasicJsonType::object_t::key_type


3932//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type


3933//   - the comparator is transparent or RequireTransparentComparator is false


3934//   - KeyType is not a JSON iterator or json_pointer


3935template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,


3936         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>


3937using is_usable_as_basic_json_key_type = typename std::conditional <


3938        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,


3939        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,


3940        RequireTransparentComparator, ExcludeObjectKeyType>::value


3941        && !is_json_iterator_of<BasicJsonType, KeyType>::value,


3942        std::true_type,


3943        std::false_type >::type;


3944


3945template<typename ObjectType, typename KeyType>


3946using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));


3947


3948// type trait to check if object_t has an erase() member functions accepting KeyType


3949template<typename BasicJsonType, typename KeyType>


3950using has_erase_with_key_type = typename std::conditional <


3951                                is_detected <


3952                                detect_erase_with_key_type,


3953                                typename BasicJsonType::object_t, KeyType >::value,


3954                                std::true_type,


3955                                std::false_type >::type;


3956


3957// a naive helper to check if a type is an ordered_map (exploits the fact that


3958// ordered_map inherits capacity() from std::vector)


3959template <typename T>


3960struct is_ordered_map


3961{


3962    using one = char;


3963


3964    struct two


3965    {


3966        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


3967    };


3968


3969    template <typename C> static one test( decltype(&C::capacity) ) ;


3970    template <typename C> static two test(...);


3971


3972    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


3973};


3974


3975// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)


3976template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >


3977T conditional_static_cast(U value)


3978{


3979    return static_cast<T>(value);


3980}


3981


3982template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>


3983T conditional_static_cast(U value)


3984{


3985    return value;


3986}


3987


3988template<typename... Types>


3989using all_integral = conjunction<std::is_integral<Types>...>;


3990


3991template<typename... Types>


3992using all_signed = conjunction<std::is_signed<Types>...>;


3993


3994template<typename... Types>


3995using all_unsigned = conjunction<std::is_unsigned<Types>...>;


3996


3997// there's a disjunction trait in another PR; replace when merged


3998template<typename... Types>


3999using same_sign = std::integral_constant < bool,


4000      all_signed<Types...>::value || all_unsigned<Types...>::value >;


4001


4002template<typename OfType, typename T>


4003using never_out_of_range = std::integral_constant < bool,


4004      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))


4005      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;


4006


4007template<typename OfType, typename T,


4008         bool OfTypeSigned = std::is_signed<OfType>::value,


4009         bool TSigned = std::is_signed<T>::value>


4010struct value_in_range_of_impl2;


4011


4012template<typename OfType, typename T>


4013struct value_in_range_of_impl2<OfType, T, false, false>


4014{


4015    static constexpr bool test(T val)


4016    {


4017        using CommonType = typename std::common_type<OfType, T>::type;


4018        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());


4019    }


4020};


4021


4022template<typename OfType, typename T>


4023struct value_in_range_of_impl2<OfType, T, true, false>


4024{


4025    static constexpr bool test(T val)


4026    {


4027        using CommonType = typename std::common_type<OfType, T>::type;


4028        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());


4029    }


4030};


4031


4032template<typename OfType, typename T>


4033struct value_in_range_of_impl2<OfType, T, false, true>


4034{


4035    static constexpr bool test(T val)


4036    {


4037        using CommonType = typename std::common_type<OfType, T>::type;


4038        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());


4039    }


4040};


4041


4042


4043template<typename OfType, typename T>


4044struct value_in_range_of_impl2<OfType, T, true, true>


4045{


4046    static constexpr bool test(T val)


4047    {


4048        using CommonType = typename std::common_type<OfType, T>::type;


4049        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())


4050               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());


4051    }


4052};


4053


4054template<typename OfType, typename T,


4055         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,


4056         typename = detail::enable_if_t<all_integral<OfType, T>::value>>


4057struct value_in_range_of_impl1;


4058


4059template<typename OfType, typename T>


4060struct value_in_range_of_impl1<OfType, T, false>


4061{


4062    static constexpr bool test(T val)


4063    {


4064        return value_in_range_of_impl2<OfType, T>::test(val);


4065    }


4066};


4067


4068template<typename OfType, typename T>


4069struct value_in_range_of_impl1<OfType, T, true>


4070{


4071    static constexpr bool test(T /*val*/)


4072    {


4073        return true;


4074    }


4075};


4076


4077template<typename OfType, typename T>


4078inline constexpr bool value_in_range_of(T val)


4079{


4080    return value_in_range_of_impl1<OfType, T>::test(val);


4081}


4082


4083template<bool Value>


4084using bool_constant = std::integral_constant<bool, Value>;


4085


4086///////////////////////////////////////////////////////////////////////////////


4087// is_c_string


4088///////////////////////////////////////////////////////////////////////////////


4089


4090namespace impl


4091{


4092


4093template<typename T>


4094inline constexpr bool is_c_string()


4095{


4096    using TUnExt = typename std::remove_extent<T>::type;


4097    using TUnCVExt = typename std::remove_cv<TUnExt>::type;


4098    using TUnPtr = typename std::remove_pointer<T>::type;


4099    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;


4100    return


4101        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)


4102        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);


4103}


4104


4105}  // namespace impl


4106


4107// checks whether T is a [cv] char */[cv] char[] C string


4108template<typename T>


4109struct is_c_string : bool_constant<impl::is_c_string<T>()> {};


4110


4111template<typename T>


4112using is_c_string_uncvref = is_c_string<uncvref_t<T>>;


4113


4114///////////////////////////////////////////////////////////////////////////////


4115// is_transparent


4116///////////////////////////////////////////////////////////////////////////////


4117


4118namespace impl


4119{


4120


4121template<typename T>


4122inline constexpr bool is_transparent()


4123{


4124    return is_detected<detect_is_transparent, T>::value;


4125}


4126


4127}  // namespace impl


4128


4129// checks whether T has a member named is_transparent


4130template<typename T>


4131struct is_transparent : bool_constant<impl::is_transparent<T>()> {};


4132


4133///////////////////////////////////////////////////////////////////////////////


4134


4135}  // namespace detail


4136NLOHMANN_JSON_NAMESPACE_END


4137


4138// #include <nlohmann/detail/string_concat.hpp>


4139//     __ _____ _____ _____


4140//  __|  |   __|     |   | |  JSON for Modern C++


4141// |  |  |__   |  |  | | | |  version 3.11.2


4142// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


4143//


4144// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


4145// SPDX-License-Identifier: MIT


4146


4147


4148


4149#include <cstring> // strlen


4150#include <string> // string


4151#include <utility> // forward


4152


4153// #include <nlohmann/detail/meta/cpp_future.hpp>


4154


4155// #include <nlohmann/detail/meta/detected.hpp>


4156


4157


4158NLOHMANN_JSON_NAMESPACE_BEGIN


4159namespace detail


4160{


4161


4162inline std::size_t concat_length()


4163{


4164    return 0;


4165}


4166


4167template<typename... Args>


4168inline std::size_t concat_length(const char* cstr, Args&& ... rest);


4169


4170template<typename StringType, typename... Args>


4171inline std::size_t concat_length(const StringType& str, Args&& ... rest);


4172


4173template<typename... Args>


4174inline std::size_t concat_length(const char /*c*/, Args&& ... rest)


4175{


4176    return 1 + concat_length(std::forward<Args>(rest)...);


4177}


4178


4179template<typename... Args>


4180inline std::size_t concat_length(const char* cstr, Args&& ... rest)


4181{


4182    // cppcheck-suppress ignoredReturnValue


4183    return ::strlen(cstr) + concat_length(std::forward<Args>(rest)...);


4184}


4185


4186template<typename StringType, typename... Args>


4187inline std::size_t concat_length(const StringType& str, Args&& ... rest)


4188{


4189    return str.size() + concat_length(std::forward<Args>(rest)...);


4190}


4191


4192template<typename OutStringType>


4193inline void concat_into(OutStringType& /*out*/)


4194{}


4195


4196template<typename StringType, typename Arg>


4197using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));


4198


4199template<typename StringType, typename Arg>


4200using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;


4201


4202template<typename StringType, typename Arg>


4203using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());


4204


4205template<typename StringType, typename Arg>


4206using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;


4207


4208template<typename StringType, typename Arg>


4209using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));


4210


4211template<typename StringType, typename Arg>


4212using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;


4213


4214template<typename StringType, typename Arg>


4215using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));


4216


4217template<typename StringType, typename Arg>


4218using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;


4219


4220template < typename OutStringType, typename Arg, typename... Args,


4221           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value


4222                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >


4223inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);


4224


4225template < typename OutStringType, typename Arg, typename... Args,


4226           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value


4227                         && !detect_string_can_append_op<OutStringType, Arg>::value


4228                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >


4229inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);


4230


4231template < typename OutStringType, typename Arg, typename... Args,


4232           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value


4233                         && !detect_string_can_append_op<OutStringType, Arg>::value


4234                         && !detect_string_can_append_iter<OutStringType, Arg>::value


4235                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >


4236inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);


4237


4238template<typename OutStringType, typename Arg, typename... Args,


4239         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>


4240inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)


4241{


4242    out.append(std::forward<Arg>(arg));


4243    concat_into(out, std::forward<Args>(rest)...);


4244}


4245


4246template < typename OutStringType, typename Arg, typename... Args,


4247           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value


4248                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >


4249inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)


4250{


4251    out += std::forward<Arg>(arg);


4252    concat_into(out, std::forward<Args>(rest)...);


4253}


4254


4255template < typename OutStringType, typename Arg, typename... Args,


4256           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value


4257                         && !detect_string_can_append_op<OutStringType, Arg>::value


4258                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >


4259inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)


4260{


4261    out.append(arg.begin(), arg.end());


4262    concat_into(out, std::forward<Args>(rest)...);


4263}


4264


4265template < typename OutStringType, typename Arg, typename... Args,


4266           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value


4267                         && !detect_string_can_append_op<OutStringType, Arg>::value


4268                         && !detect_string_can_append_iter<OutStringType, Arg>::value


4269                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >


4270inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)


4271{


4272    out.append(arg.data(), arg.size());


4273    concat_into(out, std::forward<Args>(rest)...);


4274}


4275


4276template<typename OutStringType = std::string, typename... Args>


4277inline OutStringType concat(Args && ... args)


4278{


4279    OutStringType str;


4280    str.reserve(concat_length(std::forward<Args>(args)...));


4281    concat_into(str, std::forward<Args>(args)...);


4282    return str;


4283}


4284


4285}  // namespace detail


4286NLOHMANN_JSON_NAMESPACE_END


4287


4288


4289


4290NLOHMANN_JSON_NAMESPACE_BEGIN


4291namespace detail


4292{


4293


4294////////////////


4295// exceptions //


4296////////////////


4297


4298/// @brief general exception of the @ref basic_json class


4299/// @sa https://json.nlohmann.me/api/basic_json/exception/


4300class exception : public std::exception


4301{


4302  public:


4303    /// returns the explanatory string


4304    const char* what() const noexcept override


4305    {


4306        return m.what();


4307    }


4308


4309    /// the id of the exception


4310    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)


4311


4312  protected:


4313    JSON_HEDLEY_NON_NULL(3)


4314    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)


4315


4316    static std::string name(const std::string& ename, int id_)


4317    {


4318        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");


4319    }


4320


4321    static std::string diagnostics(std::nullptr_t /*leaf_element*/)


4322    {


4323        return "";


4324    }


4325


4326    template<typename BasicJsonType>


4327    static std::string diagnostics(const BasicJsonType* leaf_element)


4328    {


4329#if JSON_DIAGNOSTICS


4330        std::vector<std::string> tokens;


4331        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)


4332        {


4333            switch (current->m_parent->type())


4334            {


4335                case value_t::array:


4336                {


4337                    for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)


4338                    {


4339                        if (&current->m_parent->m_value.array->operator[](i) == current)


4340                        {


4341                            tokens.emplace_back(std::to_string(i));


4342                            break;


4343                        }


4344                    }


4345                    break;


4346                }


4347


4348                case value_t::object:


4349                {


4350                    for (const auto& element : *current->m_parent->m_value.object)


4351                    {


4352                        if (&element.second == current)


4353                        {


4354                            tokens.emplace_back(element.first.c_str());


4355                            break;


4356                        }


4357                    }


4358                    break;


4359                }


4360


4361                case value_t::null: // LCOV_EXCL_LINE


4362                case value_t::string: // LCOV_EXCL_LINE


4363                case value_t::boolean: // LCOV_EXCL_LINE


4364                case value_t::number_integer: // LCOV_EXCL_LINE


4365                case value_t::number_unsigned: // LCOV_EXCL_LINE


4366                case value_t::number_float: // LCOV_EXCL_LINE


4367                case value_t::binary: // LCOV_EXCL_LINE


4368                case value_t::discarded: // LCOV_EXCL_LINE


4369                default:   // LCOV_EXCL_LINE


4370                    break; // LCOV_EXCL_LINE


4371            }


4372        }


4373


4374        if (tokens.empty())


4375        {


4376            return "";


4377        }


4378


4379        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},


4380                                   [](const std::string & a, const std::string & b)


4381        {


4382            return concat(a, '/', detail::escape(b));


4383        });


4384        return concat('(', str, ") ");


4385#else


4386        static_cast<void>(leaf_element);


4387        return "";


4388#endif


4389    }


4390


4391  private:


4392    /// an exception object as storage for error messages


4393    std::runtime_error m;


4394};


4395


4396/// @brief exception indicating a parse error


4397/// @sa https://json.nlohmann.me/api/basic_json/parse_error/


4398class parse_error : public exception


4399{


4400  public:


4401    /*!


4402    @brief create a parse error exception


4403    @param[in] id_       the id of the exception


4404    @param[in] pos       the position where the error occurred (or with


4405                         chars_read_total=0 if the position cannot be


4406                         determined)


4407    @param[in] what_arg  the explanatory string


4408    @return parse_error object


4409    */


4410    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>


4411    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)


4412    {


4413        std::string w = concat(exception::name("parse_error", id_), "parse error",


4414                               position_string(pos), ": ", exception::diagnostics(context), what_arg);


4415        return {id_, pos.chars_read_total, w.c_str()};


4416    }


4417


4418    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>


4419    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)


4420    {


4421        std::string w = concat(exception::name("parse_error", id_), "parse error",


4422                               (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),


4423                               ": ", exception::diagnostics(context), what_arg);


4424        return {id_, byte_, w.c_str()};


4425    }


4426


4427    /*!


4428    @brief byte index of the parse error


4429


4430    The byte index of the last read character in the input file.


4431


4432    @note For an input with n bytes, 1 is the index of the first character and


4433          n+1 is the index of the terminating null byte or the end of file.


4434          This also holds true when reading a byte vector (CBOR or MessagePack).


4435    */


4436    const std::size_t byte;


4437


4438  private:


4439    parse_error(int id_, std::size_t byte_, const char* what_arg)


4440        : exception(id_, what_arg), byte(byte_) {}


4441


4442    static std::string position_string(const position_t& pos)


4443    {


4444        return concat(" at line ", std::to_string(pos.lines_read + 1),


4445                      ", column ", std::to_string(pos.chars_read_current_line));


4446    }


4447};


4448


4449/// @brief exception indicating errors with iterators


4450/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/


4451class invalid_iterator : public exception


4452{


4453  public:


4454    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>


4455    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)


4456    {


4457        std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);


4458        return {id_, w.c_str()};


4459    }


4460


4461  private:


4462    JSON_HEDLEY_NON_NULL(3)


4463    invalid_iterator(int id_, const char* what_arg)


4464        : exception(id_, what_arg) {}


4465};


4466


4467/// @brief exception indicating executing a member function with a wrong type


4468/// @sa https://json.nlohmann.me/api/basic_json/type_error/


4469class type_error : public exception


4470{


4471  public:


4472    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>


4473    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)


4474    {


4475        std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);


4476        return {id_, w.c_str()};


4477    }


4478


4479  private:


4480    JSON_HEDLEY_NON_NULL(3)


4481    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}


4482};


4483


4484/// @brief exception indicating access out of the defined range


4485/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/


4486class out_of_range : public exception


4487{


4488  public:


4489    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>


4490    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)


4491    {


4492        std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);


4493        return {id_, w.c_str()};


4494    }


4495


4496  private:


4497    JSON_HEDLEY_NON_NULL(3)


4498    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}


4499};


4500


4501/// @brief exception indicating other library errors


4502/// @sa https://json.nlohmann.me/api/basic_json/other_error/


4503class other_error : public exception


4504{


4505  public:


4506    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>


4507    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)


4508    {


4509        std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);


4510        return {id_, w.c_str()};


4511    }


4512


4513  private:


4514    JSON_HEDLEY_NON_NULL(3)


4515    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}


4516};


4517


4518}  // namespace detail


4519NLOHMANN_JSON_NAMESPACE_END


4520


4521// #include <nlohmann/detail/macro_scope.hpp>


4522


4523// #include <nlohmann/detail/meta/cpp_future.hpp>


4524


4525// #include <nlohmann/detail/meta/identity_tag.hpp>


4526//     __ _____ _____ _____


4527//  __|  |   __|     |   | |  JSON for Modern C++


4528// |  |  |__   |  |  | | | |  version 3.11.2


4529// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


4530//


4531// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


4532// SPDX-License-Identifier: MIT


4533


4534


4535


4536// #include <nlohmann/detail/abi_macros.hpp>


4537


4538


4539NLOHMANN_JSON_NAMESPACE_BEGIN


4540namespace detail


4541{


4542


4543// dispatching helper struct


4544template <class T> struct identity_tag {};


4545


4546}  // namespace detail


4547NLOHMANN_JSON_NAMESPACE_END


4548


4549// #include <nlohmann/detail/meta/std_fs.hpp>


4550//     __ _____ _____ _____


4551//  __|  |   __|     |   | |  JSON for Modern C++


4552// |  |  |__   |  |  | | | |  version 3.11.2


4553// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


4554//


4555// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


4556// SPDX-License-Identifier: MIT


4557


4558


4559


4560// #include <nlohmann/detail/macro_scope.hpp>


4561


4562


4563#if JSON_HAS_EXPERIMENTAL_FILESYSTEM


4564#include <experimental/filesystem>


4565NLOHMANN_JSON_NAMESPACE_BEGIN


4566namespace detail


4567{


4568namespace std_fs = std::experimental::filesystem;


4569}  // namespace detail


4570NLOHMANN_JSON_NAMESPACE_END


4571#elif JSON_HAS_FILESYSTEM


4572#include <filesystem>


4573NLOHMANN_JSON_NAMESPACE_BEGIN


4574namespace detail


4575{


4576namespace std_fs = std::filesystem;


4577}  // namespace detail


4578NLOHMANN_JSON_NAMESPACE_END


4579#endif


4580


4581// #include <nlohmann/detail/meta/type_traits.hpp>


4582


4583// #include <nlohmann/detail/string_concat.hpp>


4584


4585// #include <nlohmann/detail/value_t.hpp>


4586


4587


4588NLOHMANN_JSON_NAMESPACE_BEGIN


4589namespace detail


4590{


4591


4592template<typename BasicJsonType>


4593inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)


4594{


4595    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))


4596    {


4597        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));


4598    }


4599    n = nullptr;


4600}


4601


4602// overloads for basic_json template parameters


4603template < typename BasicJsonType, typename ArithmeticType,


4604           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&


4605                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,


4606                         int > = 0 >


4607void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)


4608{


4609    switch (static_cast<value_t>(j))


4610    {


4611        case value_t::number_unsigned:


4612        {


4613            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());


4614            break;


4615        }


4616        case value_t::number_integer:


4617        {


4618            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());


4619            break;


4620        }


4621        case value_t::number_float:


4622        {


4623            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());


4624            break;


4625        }


4626


4627        case value_t::null:


4628        case value_t::object:


4629        case value_t::array:


4630        case value_t::string:


4631        case value_t::boolean:


4632        case value_t::binary:


4633        case value_t::discarded:


4634        default:


4635            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));


4636    }


4637}


4638


4639template<typename BasicJsonType>


4640inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)


4641{


4642    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))


4643    {


4644        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));


4645    }


4646    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();


4647}


4648


4649template<typename BasicJsonType>


4650inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)


4651{


4652    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))


4653    {


4654        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));


4655    }


4656    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();


4657}


4658


4659template <


4660    typename BasicJsonType, typename StringType,


4661    enable_if_t <


4662        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value


4663        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value


4664        && !std::is_same<typename BasicJsonType::string_t, StringType>::value


4665        && !is_json_ref<StringType>::value, int > = 0 >


4666inline void from_json(const BasicJsonType& j, StringType& s)


4667{


4668    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))


4669    {


4670        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));


4671    }


4672


4673    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();


4674}


4675


4676template<typename BasicJsonType>


4677inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)


4678{


4679    get_arithmetic_value(j, val);


4680}


4681


4682template<typename BasicJsonType>


4683inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)


4684{


4685    get_arithmetic_value(j, val);


4686}


4687


4688template<typename BasicJsonType>


4689inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)


4690{


4691    get_arithmetic_value(j, val);


4692}


4693


4694#if !JSON_DISABLE_ENUM_SERIALIZATION


4695template<typename BasicJsonType, typename EnumType,


4696         enable_if_t<std::is_enum<EnumType>::value, int> = 0>


4697inline void from_json(const BasicJsonType& j, EnumType& e)


4698{


4699    typename std::underlying_type<EnumType>::type val;


4700    get_arithmetic_value(j, val);


4701    e = static_cast<EnumType>(val);


4702}


4703#endif  // JSON_DISABLE_ENUM_SERIALIZATION


4704


4705// forward_list doesn't have an insert method


4706template<typename BasicJsonType, typename T, typename Allocator,


4707         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>


4708inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)


4709{


4710    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


4711    {


4712        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


4713    }


4714    l.clear();


4715    std::transform(j.rbegin(), j.rend(),


4716                   std::front_inserter(l), [](const BasicJsonType & i)


4717    {


4718        return i.template get<T>();


4719    });


4720}


4721


4722// valarray doesn't have an insert method


4723template<typename BasicJsonType, typename T,


4724         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>


4725inline void from_json(const BasicJsonType& j, std::valarray<T>& l)


4726{


4727    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


4728    {


4729        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


4730    }


4731    l.resize(j.size());


4732    std::transform(j.begin(), j.end(), std::begin(l),


4733                   [](const BasicJsonType & elem)


4734    {


4735        return elem.template get<T>();


4736    });


4737}


4738


4739template<typename BasicJsonType, typename T, std::size_t N>


4740auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


4741-> decltype(j.template get<T>(), void())


4742{


4743    for (std::size_t i = 0; i < N; ++i)


4744    {


4745        arr[i] = j.at(i).template get<T>();


4746    }


4747}


4748


4749template<typename BasicJsonType>


4750inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)


4751{


4752    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();


4753}


4754


4755template<typename BasicJsonType, typename T, std::size_t N>


4756auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,


4757                          priority_tag<2> /*unused*/)


4758-> decltype(j.template get<T>(), void())


4759{


4760    for (std::size_t i = 0; i < N; ++i)


4761    {


4762        arr[i] = j.at(i).template get<T>();


4763    }


4764}


4765


4766template<typename BasicJsonType, typename ConstructibleArrayType,


4767         enable_if_t<


4768             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,


4769             int> = 0>


4770auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)


4771-> decltype(


4772    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),


4773    j.template get<typename ConstructibleArrayType::value_type>(),


4774    void())


4775{


4776    using std::end;


4777


4778    ConstructibleArrayType ret;


4779    ret.reserve(j.size());


4780    std::transform(j.begin(), j.end(),


4781                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)


4782    {


4783        // get<BasicJsonType>() returns *this, this won't call a from_json


4784        // method when value_type is BasicJsonType


4785        return i.template get<typename ConstructibleArrayType::value_type>();


4786    });


4787    arr = std::move(ret);


4788}


4789


4790template<typename BasicJsonType, typename ConstructibleArrayType,


4791         enable_if_t<


4792             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,


4793             int> = 0>


4794inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,


4795                                 priority_tag<0> /*unused*/)


4796{


4797    using std::end;


4798


4799    ConstructibleArrayType ret;


4800    std::transform(


4801        j.begin(), j.end(), std::inserter(ret, end(ret)),


4802        [](const BasicJsonType & i)


4803    {


4804        // get<BasicJsonType>() returns *this, this won't call a from_json


4805        // method when value_type is BasicJsonType


4806        return i.template get<typename ConstructibleArrayType::value_type>();


4807    });


4808    arr = std::move(ret);


4809}


4810


4811template < typename BasicJsonType, typename ConstructibleArrayType,


4812           enable_if_t <


4813               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&


4814               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&


4815               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&


4816               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&


4817               !is_basic_json<ConstructibleArrayType>::value,


4818               int > = 0 >


4819auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)


4820-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),


4821j.template get<typename ConstructibleArrayType::value_type>(),


4822void())


4823{


4824    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


4825    {


4826        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


4827    }


4828


4829    from_json_array_impl(j, arr, priority_tag<3> {});


4830}


4831


4832template < typename BasicJsonType, typename T, std::size_t... Idx >


4833std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,


4834        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)


4835{


4836    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };


4837}


4838


4839template < typename BasicJsonType, typename T, std::size_t N >


4840auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)


4841-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))


4842{


4843    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


4844    {


4845        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


4846    }


4847


4848    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});


4849}


4850


4851template<typename BasicJsonType>


4852inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)


4853{


4854    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))


4855    {


4856        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));


4857    }


4858


4859    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();


4860}


4861


4862template<typename BasicJsonType, typename ConstructibleObjectType,


4863         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>


4864inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)


4865{


4866    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))


4867    {


4868        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));


4869    }


4870


4871    ConstructibleObjectType ret;


4872    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();


4873    using value_type = typename ConstructibleObjectType::value_type;


4874    std::transform(


4875        inner_object->begin(), inner_object->end(),


4876        std::inserter(ret, ret.begin()),


4877        [](typename BasicJsonType::object_t::value_type const & p)


4878    {


4879        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());


4880    });


4881    obj = std::move(ret);


4882}


4883


4884// overload for arithmetic types, not chosen for basic_json template arguments


4885// (BooleanType, etc..); note: Is it really necessary to provide explicit


4886// overloads for boolean_t etc. in case of a custom BooleanType which is not


4887// an arithmetic type?


4888template < typename BasicJsonType, typename ArithmeticType,


4889           enable_if_t <


4890               std::is_arithmetic<ArithmeticType>::value&&


4891               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&


4892               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&


4893               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&


4894               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,


4895               int > = 0 >


4896inline void from_json(const BasicJsonType& j, ArithmeticType& val)


4897{


4898    switch (static_cast<value_t>(j))


4899    {


4900        case value_t::number_unsigned:


4901        {


4902            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());


4903            break;


4904        }


4905        case value_t::number_integer:


4906        {


4907            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());


4908            break;


4909        }


4910        case value_t::number_float:


4911        {


4912            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());


4913            break;


4914        }


4915        case value_t::boolean:


4916        {


4917            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());


4918            break;


4919        }


4920


4921        case value_t::null:


4922        case value_t::object:


4923        case value_t::array:


4924        case value_t::string:


4925        case value_t::binary:


4926        case value_t::discarded:


4927        default:


4928            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));


4929    }


4930}


4931


4932template<typename BasicJsonType, typename... Args, std::size_t... Idx>


4933std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)


4934{


4935    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);


4936}


4937


4938template < typename BasicJsonType, class A1, class A2 >


4939std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)


4940{


4941    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),


4942            std::forward<BasicJsonType>(j).at(1).template get<A2>()};


4943}


4944


4945template<typename BasicJsonType, typename A1, typename A2>


4946inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)


4947{


4948    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});


4949}


4950


4951template<typename BasicJsonType, typename... Args>


4952std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)


4953{


4954    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});


4955}


4956


4957template<typename BasicJsonType, typename... Args>


4958inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)


4959{


4960    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});


4961}


4962


4963template<typename BasicJsonType, typename TupleRelated>


4964auto from_json(BasicJsonType&& j, TupleRelated&& t)


4965-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))


4966{


4967    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


4968    {


4969        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


4970    }


4971


4972    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});


4973}


4974


4975template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,


4976           typename = enable_if_t < !std::is_constructible <


4977                                        typename BasicJsonType::string_t, Key >::value >>


4978inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)


4979{


4980    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


4981    {


4982        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


4983    }


4984    m.clear();


4985    for (const auto& p : j)


4986    {


4987        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))


4988        {


4989            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));


4990        }


4991        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());


4992    }


4993}


4994


4995template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,


4996           typename = enable_if_t < !std::is_constructible <


4997                                        typename BasicJsonType::string_t, Key >::value >>


4998inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)


4999{


5000    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))


5001    {


5002        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));


5003    }


5004    m.clear();


5005    for (const auto& p : j)


5006    {


5007        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))


5008        {


5009            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));


5010        }


5011        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());


5012    }


5013}


5014


5015#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM


5016template<typename BasicJsonType>


5017inline void from_json(const BasicJsonType& j, std_fs::path& p)


5018{


5019    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))


5020    {


5021        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));


5022    }


5023    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();


5024}


5025#endif


5026


5027struct from_json_fn


5028{


5029    template<typename BasicJsonType, typename T>


5030    auto operator()(const BasicJsonType& j, T&& val) const


5031    noexcept(noexcept(from_json(j, std::forward<T>(val))))


5032    -> decltype(from_json(j, std::forward<T>(val)))


5033    {


5034        return from_json(j, std::forward<T>(val));


5035    }


5036};


5037


5038}  // namespace detail


5039


5040#ifndef JSON_HAS_CPP_17


5041/// namespace to hold default `from_json` function


5042/// to see why this is required:


5043/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html


5044namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)


5045{


5046#endif


5047JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)


5048    detail::static_const<detail::from_json_fn>::value;


5049#ifndef JSON_HAS_CPP_17


5050}  // namespace


5051#endif


5052


5053NLOHMANN_JSON_NAMESPACE_END


5054


5055// #include <nlohmann/detail/conversions/to_json.hpp>


5056//     __ _____ _____ _____


5057//  __|  |   __|     |   | |  JSON for Modern C++


5058// |  |  |__   |  |  | | | |  version 3.11.2


5059// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


5060//


5061// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


5062// SPDX-License-Identifier: MIT


5063


5064


5065


5066#include <algorithm> // copy


5067#include <iterator> // begin, end


5068#include <string> // string


5069#include <tuple> // tuple, get


5070#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type


5071#include <utility> // move, forward, declval, pair


5072#include <valarray> // valarray


5073#include <vector> // vector


5074


5075// #include <nlohmann/detail/iterators/iteration_proxy.hpp>


5076//     __ _____ _____ _____


5077//  __|  |   __|     |   | |  JSON for Modern C++


5078// |  |  |__   |  |  | | | |  version 3.11.2


5079// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


5080//


5081// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


5082// SPDX-License-Identifier: MIT


5083


5084


5085


5086#include <cstddef> // size_t


5087#include <iterator> // input_iterator_tag


5088#include <string> // string, to_string


5089#include <tuple> // tuple_size, get, tuple_element


5090#include <utility> // move


5091


5092#if JSON_HAS_RANGES


5093    #include <ranges> // enable_borrowed_range


5094#endif


5095


5096// #include <nlohmann/detail/abi_macros.hpp>


5097


5098// #include <nlohmann/detail/meta/type_traits.hpp>


5099


5100// #include <nlohmann/detail/value_t.hpp>


5101


5102


5103NLOHMANN_JSON_NAMESPACE_BEGIN


5104namespace detail


5105{


5106


5107template<typename string_type>


5108void int_to_string( string_type& target, std::size_t value )


5109{


5110    // For ADL


5111    using std::to_string;


5112    target = to_string(value);


5113}


5114template<typename IteratorType> class iteration_proxy_value


5115{


5116  public:


5117    using difference_type = std::ptrdiff_t;


5118    using value_type = iteration_proxy_value;


5119    using pointer = value_type *;


5120    using reference = value_type &;


5121    using iterator_category = std::input_iterator_tag;


5122    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;


5123


5124  private:


5125    /// the iterator


5126    IteratorType anchor{};


5127    /// an index for arrays (used to create key names)


5128    std::size_t array_index = 0;


5129    /// last stringified array index


5130    mutable std::size_t array_index_last = 0;


5131    /// a string representation of the array index


5132    mutable string_type array_index_str = "0";


5133    /// an empty string (to return a reference for primitive values)


5134    string_type empty_str{};


5135


5136  public:


5137    explicit iteration_proxy_value() = default;


5138    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)


5139    noexcept(std::is_nothrow_move_constructible<IteratorType>::value


5140             && std::is_nothrow_default_constructible<string_type>::value)


5141        : anchor(std::move(it))


5142        , array_index(array_index_)


5143    {}


5144


5145    iteration_proxy_value(iteration_proxy_value const&) = default;


5146    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;


5147    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions


5148    iteration_proxy_value(iteration_proxy_value&&)


5149    noexcept(std::is_nothrow_move_constructible<IteratorType>::value


5150             && std::is_nothrow_move_constructible<string_type>::value) = default;


5151    iteration_proxy_value& operator=(iteration_proxy_value&&)


5152    noexcept(std::is_nothrow_move_assignable<IteratorType>::value


5153             && std::is_nothrow_move_assignable<string_type>::value) = default;


5154    ~iteration_proxy_value() = default;


5155


5156    /// dereference operator (needed for range-based for)


5157    const iteration_proxy_value& operator*() const


5158    {


5159        return *this;


5160    }


5161


5162    /// increment operator (needed for range-based for)


5163    iteration_proxy_value& operator++()


5164    {


5165        ++anchor;


5166        ++array_index;


5167


5168        return *this;


5169    }


5170


5171    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)


5172    {


5173        auto tmp = iteration_proxy_value(anchor, array_index);


5174        ++anchor;


5175        ++array_index;


5176        return tmp;


5177    }


5178


5179    /// equality operator (needed for InputIterator)


5180    bool operator==(const iteration_proxy_value& o) const


5181    {


5182        return anchor == o.anchor;


5183    }


5184


5185    /// inequality operator (needed for range-based for)


5186    bool operator!=(const iteration_proxy_value& o) const


5187    {


5188        return anchor != o.anchor;


5189    }


5190


5191    /// return key of the iterator


5192    const string_type& key() const


5193    {


5194        JSON_ASSERT(anchor.m_object != nullptr);


5195


5196        switch (anchor.m_object->type())


5197        {


5198            // use integer array index as key


5199            case value_t::array:


5200            {


5201                if (array_index != array_index_last)


5202                {


5203                    int_to_string( array_index_str, array_index );


5204                    array_index_last = array_index;


5205                }


5206                return array_index_str;


5207            }


5208


5209            // use key from the object


5210            case value_t::object:


5211                return anchor.key();


5212


5213            // use an empty key for all primitive types


5214            case value_t::null:


5215            case value_t::string:


5216            case value_t::boolean:


5217            case value_t::number_integer:


5218            case value_t::number_unsigned:


5219            case value_t::number_float:


5220            case value_t::binary:


5221            case value_t::discarded:


5222            default:


5223                return empty_str;


5224        }


5225    }


5226


5227    /// return value of the iterator


5228    typename IteratorType::reference value() const


5229    {


5230        return anchor.value();


5231    }


5232};


5233


5234/// proxy class for the items() function


5235template<typename IteratorType> class iteration_proxy


5236{


5237  private:


5238    /// the container to iterate


5239    typename IteratorType::pointer container = nullptr;


5240


5241  public:


5242    explicit iteration_proxy() = default;


5243


5244    /// construct iteration proxy from a container


5245    explicit iteration_proxy(typename IteratorType::reference cont) noexcept


5246        : container(&cont) {}


5247


5248    iteration_proxy(iteration_proxy const&) = default;


5249    iteration_proxy& operator=(iteration_proxy const&) = default;


5250    iteration_proxy(iteration_proxy&&) noexcept = default;


5251    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;


5252    ~iteration_proxy() = default;


5253


5254    /// return iterator begin (needed for range-based for)


5255    iteration_proxy_value<IteratorType> begin() const noexcept


5256    {


5257        return iteration_proxy_value<IteratorType>(container->begin());


5258    }


5259


5260    /// return iterator end (needed for range-based for)


5261    iteration_proxy_value<IteratorType> end() const noexcept


5262    {


5263        return iteration_proxy_value<IteratorType>(container->end());


5264    }


5265};


5266


5267// Structured Bindings Support


5268// For further reference see https://blog.tartanllama.xyz/structured-bindings/


5269// And see https://github.com/nlohmann/json/pull/1391


5270template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>


5271auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())


5272{


5273    return i.key();


5274}


5275// Structured Bindings Support


5276// For further reference see https://blog.tartanllama.xyz/structured-bindings/


5277// And see https://github.com/nlohmann/json/pull/1391


5278template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>


5279auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())


5280{


5281    return i.value();


5282}


5283


5284}  // namespace detail


5285NLOHMANN_JSON_NAMESPACE_END


5286


5287// The Addition to the STD Namespace is required to add


5288// Structured Bindings Support to the iteration_proxy_value class


5289// For further reference see https://blog.tartanllama.xyz/structured-bindings/


5290// And see https://github.com/nlohmann/json/pull/1391


5291namespace std


5292{


5293


5294#if defined(__clang__)


5295    // Fix: https://github.com/nlohmann/json/issues/1401


5296    #pragma clang diagnostic push


5297    #pragma clang diagnostic ignored "-Wmismatched-tags"


5298#endif


5299template<typename IteratorType>


5300class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>


5301            : public std::integral_constant<std::size_t, 2> {};


5302


5303template<std::size_t N, typename IteratorType>


5304class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>


5305{


5306  public:


5307    using type = decltype(


5308                     get<N>(std::declval <


5309                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));


5310};


5311#if defined(__clang__)


5312    #pragma clang diagnostic pop


5313#endif


5314


5315}  // namespace std


5316


5317#if JSON_HAS_RANGES


5318    template <typename IteratorType>


5319    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;


5320#endif


5321


5322// #include <nlohmann/detail/macro_scope.hpp>


5323


5324// #include <nlohmann/detail/meta/cpp_future.hpp>


5325


5326// #include <nlohmann/detail/meta/std_fs.hpp>


5327


5328// #include <nlohmann/detail/meta/type_traits.hpp>


5329


5330// #include <nlohmann/detail/value_t.hpp>


5331


5332


5333NLOHMANN_JSON_NAMESPACE_BEGIN


5334namespace detail


5335{


5336


5337//////////////////


5338// constructors //


5339//////////////////


5340


5341/*


5342 * Note all external_constructor<>::construct functions need to call


5343 * j.m_value.destroy(j.m_type) to avoid a memory leak in case j contains an


5344 * allocated value (e.g., a string). See bug issue


5345 * https://github.com/nlohmann/json/issues/2865 for more information.


5346 */


5347


5348template<value_t> struct external_constructor;


5349


5350template<>


5351struct external_constructor<value_t::boolean>


5352{


5353    template<typename BasicJsonType>


5354    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept


5355    {


5356        j.m_value.destroy(j.m_type);


5357        j.m_type = value_t::boolean;


5358        j.m_value = b;


5359        j.assert_invariant();


5360    }


5361};


5362


5363template<>


5364struct external_constructor<value_t::string>


5365{


5366    template<typename BasicJsonType>


5367    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)


5368    {


5369        j.m_value.destroy(j.m_type);


5370        j.m_type = value_t::string;


5371        j.m_value = s;


5372        j.assert_invariant();


5373    }


5374


5375    template<typename BasicJsonType>


5376    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)


5377    {


5378        j.m_value.destroy(j.m_type);


5379        j.m_type = value_t::string;


5380        j.m_value = std::move(s);


5381        j.assert_invariant();


5382    }


5383


5384    template < typename BasicJsonType, typename CompatibleStringType,


5385               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,


5386                             int > = 0 >


5387    static void construct(BasicJsonType& j, const CompatibleStringType& str)


5388    {


5389        j.m_value.destroy(j.m_type);


5390        j.m_type = value_t::string;


5391        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);


5392        j.assert_invariant();


5393    }


5394};


5395


5396template<>


5397struct external_constructor<value_t::binary>


5398{


5399    template<typename BasicJsonType>


5400    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)


5401    {


5402        j.m_value.destroy(j.m_type);


5403        j.m_type = value_t::binary;


5404        j.m_value = typename BasicJsonType::binary_t(b);


5405        j.assert_invariant();


5406    }


5407


5408    template<typename BasicJsonType>


5409    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)


5410    {


5411        j.m_value.destroy(j.m_type);


5412        j.m_type = value_t::binary;


5413        j.m_value = typename BasicJsonType::binary_t(std::move(b));


5414        j.assert_invariant();


5415    }


5416};


5417


5418template<>


5419struct external_constructor<value_t::number_float>


5420{


5421    template<typename BasicJsonType>


5422    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept


5423    {


5424        j.m_value.destroy(j.m_type);


5425        j.m_type = value_t::number_float;


5426        j.m_value = val;


5427        j.assert_invariant();


5428    }


5429};


5430


5431template<>


5432struct external_constructor<value_t::number_unsigned>


5433{


5434    template<typename BasicJsonType>


5435    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept


5436    {


5437        j.m_value.destroy(j.m_type);


5438        j.m_type = value_t::number_unsigned;


5439        j.m_value = val;


5440        j.assert_invariant();


5441    }


5442};


5443


5444template<>


5445struct external_constructor<value_t::number_integer>


5446{


5447    template<typename BasicJsonType>


5448    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept


5449    {


5450        j.m_value.destroy(j.m_type);


5451        j.m_type = value_t::number_integer;


5452        j.m_value = val;


5453        j.assert_invariant();


5454    }


5455};


5456


5457template<>


5458struct external_constructor<value_t::array>


5459{


5460    template<typename BasicJsonType>


5461    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)


5462    {


5463        j.m_value.destroy(j.m_type);


5464        j.m_type = value_t::array;


5465        j.m_value = arr;


5466        j.set_parents();


5467        j.assert_invariant();


5468    }


5469


5470    template<typename BasicJsonType>


5471    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)


5472    {


5473        j.m_value.destroy(j.m_type);


5474        j.m_type = value_t::array;


5475        j.m_value = std::move(arr);


5476        j.set_parents();


5477        j.assert_invariant();


5478    }


5479


5480    template < typename BasicJsonType, typename CompatibleArrayType,


5481               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,


5482                             int > = 0 >


5483    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)


5484    {


5485        using std::begin;


5486        using std::end;


5487


5488        j.m_value.destroy(j.m_type);


5489        j.m_type = value_t::array;


5490        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));


5491        j.set_parents();


5492        j.assert_invariant();


5493    }


5494


5495    template<typename BasicJsonType>


5496    static void construct(BasicJsonType& j, const std::vector<bool>& arr)


5497    {


5498        j.m_value.destroy(j.m_type);


5499        j.m_type = value_t::array;


5500        j.m_value = value_t::array;


5501        j.m_value.array->reserve(arr.size());


5502        for (const bool x : arr)


5503        {


5504            j.m_value.array->push_back(x);


5505            j.set_parent(j.m_value.array->back());


5506        }


5507        j.assert_invariant();


5508    }


5509


5510    template<typename BasicJsonType, typename T,


5511             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>


5512    static void construct(BasicJsonType& j, const std::valarray<T>& arr)


5513    {


5514        j.m_value.destroy(j.m_type);


5515        j.m_type = value_t::array;


5516        j.m_value = value_t::array;


5517        j.m_value.array->resize(arr.size());


5518        if (arr.size() > 0)


5519        {


5520            std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());


5521        }


5522        j.set_parents();


5523        j.assert_invariant();


5524    }


5525};


5526


5527template<>


5528struct external_constructor<value_t::object>


5529{


5530    template<typename BasicJsonType>


5531    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)


5532    {


5533        j.m_value.destroy(j.m_type);


5534        j.m_type = value_t::object;


5535        j.m_value = obj;


5536        j.set_parents();


5537        j.assert_invariant();


5538    }


5539


5540    template<typename BasicJsonType>


5541    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)


5542    {


5543        j.m_value.destroy(j.m_type);


5544        j.m_type = value_t::object;


5545        j.m_value = std::move(obj);


5546        j.set_parents();


5547        j.assert_invariant();


5548    }


5549


5550    template < typename BasicJsonType, typename CompatibleObjectType,


5551               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >


5552    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)


5553    {


5554        using std::begin;


5555        using std::end;


5556


5557        j.m_value.destroy(j.m_type);


5558        j.m_type = value_t::object;


5559        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));


5560        j.set_parents();


5561        j.assert_invariant();


5562    }


5563};


5564


5565/////////////


5566// to_json //


5567/////////////


5568


5569template<typename BasicJsonType, typename T,


5570         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>


5571inline void to_json(BasicJsonType& j, T b) noexcept


5572{


5573    external_constructor<value_t::boolean>::construct(j, b);


5574}


5575


5576template < typename BasicJsonType, typename BoolRef,


5577           enable_if_t <


5578               ((std::is_same<std::vector<bool>::reference, BoolRef>::value


5579                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)


5580                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value


5581                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,


5582                                      typename BasicJsonType::boolean_t >::value))


5583               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >


5584inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept


5585{


5586    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));


5587}


5588


5589template<typename BasicJsonType, typename CompatibleString,


5590         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>


5591inline void to_json(BasicJsonType& j, const CompatibleString& s)


5592{


5593    external_constructor<value_t::string>::construct(j, s);


5594}


5595


5596template<typename BasicJsonType>


5597inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)


5598{


5599    external_constructor<value_t::string>::construct(j, std::move(s));


5600}


5601


5602template<typename BasicJsonType, typename FloatType,


5603         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>


5604inline void to_json(BasicJsonType& j, FloatType val) noexcept


5605{


5606    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));


5607}


5608


5609template<typename BasicJsonType, typename CompatibleNumberUnsignedType,


5610         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>


5611inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept


5612{


5613    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));


5614}


5615


5616template<typename BasicJsonType, typename CompatibleNumberIntegerType,


5617         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>


5618inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept


5619{


5620    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));


5621}


5622


5623#if !JSON_DISABLE_ENUM_SERIALIZATION


5624template<typename BasicJsonType, typename EnumType,


5625         enable_if_t<std::is_enum<EnumType>::value, int> = 0>


5626inline void to_json(BasicJsonType& j, EnumType e) noexcept


5627{


5628    using underlying_type = typename std::underlying_type<EnumType>::type;


5629    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));


5630}


5631#endif  // JSON_DISABLE_ENUM_SERIALIZATION


5632


5633template<typename BasicJsonType>


5634inline void to_json(BasicJsonType& j, const std::vector<bool>& e)


5635{


5636    external_constructor<value_t::array>::construct(j, e);


5637}


5638


5639template < typename BasicJsonType, typename CompatibleArrayType,


5640           enable_if_t < is_compatible_array_type<BasicJsonType,


5641                         CompatibleArrayType>::value&&


5642                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&


5643                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&


5644                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&


5645                         !is_basic_json<CompatibleArrayType>::value,


5646                         int > = 0 >


5647inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)


5648{


5649    external_constructor<value_t::array>::construct(j, arr);


5650}


5651


5652template<typename BasicJsonType>


5653inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)


5654{


5655    external_constructor<value_t::binary>::construct(j, bin);


5656}


5657


5658template<typename BasicJsonType, typename T,


5659         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>


5660inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)


5661{


5662    external_constructor<value_t::array>::construct(j, std::move(arr));


5663}


5664


5665template<typename BasicJsonType>


5666inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)


5667{


5668    external_constructor<value_t::array>::construct(j, std::move(arr));


5669}


5670


5671template < typename BasicJsonType, typename CompatibleObjectType,


5672           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >


5673inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)


5674{


5675    external_constructor<value_t::object>::construct(j, obj);


5676}


5677


5678template<typename BasicJsonType>


5679inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)


5680{


5681    external_constructor<value_t::object>::construct(j, std::move(obj));


5682}


5683


5684template <


5685    typename BasicJsonType, typename T, std::size_t N,


5686    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,


5687                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


5688                  int > = 0 >


5689inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


5690{


5691    external_constructor<value_t::array>::construct(j, arr);


5692}


5693


5694template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >


5695inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)


5696{


5697    j = { p.first, p.second };


5698}


5699


5700// for https://github.com/nlohmann/json/pull/1134


5701template<typename BasicJsonType, typename T,


5702         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>


5703inline void to_json(BasicJsonType& j, const T& b)


5704{


5705    j = { {b.key(), b.value()} };


5706}


5707


5708template<typename BasicJsonType, typename Tuple, std::size_t... Idx>


5709inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)


5710{


5711    j = { std::get<Idx>(t)... };


5712}


5713


5714template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>


5715inline void to_json(BasicJsonType& j, const T& t)


5716{


5717    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});


5718}


5719


5720#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM


5721template<typename BasicJsonType>


5722inline void to_json(BasicJsonType& j, const std_fs::path& p)


5723{


5724    j = p.string();


5725}


5726#endif


5727


5728struct to_json_fn


5729{


5730    template<typename BasicJsonType, typename T>


5731    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))


5732    -> decltype(to_json(j, std::forward<T>(val)), void())


5733    {


5734        return to_json(j, std::forward<T>(val));


5735    }


5736};


5737}  // namespace detail


5738


5739#ifndef JSON_HAS_CPP_17


5740/// namespace to hold default `to_json` function


5741/// to see why this is required:


5742/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html


5743namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)


5744{


5745#endif


5746JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)


5747    detail::static_const<detail::to_json_fn>::value;


5748#ifndef JSON_HAS_CPP_17


5749}  // namespace


5750#endif


5751


5752NLOHMANN_JSON_NAMESPACE_END


5753


5754// #include <nlohmann/detail/meta/identity_tag.hpp>


5755


5756


5757NLOHMANN_JSON_NAMESPACE_BEGIN


5758


5759/// @sa https://json.nlohmann.me/api/adl_serializer/


5760template<typename ValueType, typename>


5761struct adl_serializer


5762{


5763    /// @brief convert a JSON value to any value type


5764    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/


5765    template<typename BasicJsonType, typename TargetType = ValueType>


5766    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(


5767        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))


5768    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())


5769    {


5770        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);


5771    }


5772


5773    /// @brief convert a JSON value to any value type


5774    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/


5775    template<typename BasicJsonType, typename TargetType = ValueType>


5776    static auto from_json(BasicJsonType && j) noexcept(


5777    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))


5778    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))


5779    {


5780        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});


5781    }


5782


5783    /// @brief convert any value type to a JSON value


5784    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/


5785    template<typename BasicJsonType, typename TargetType = ValueType>


5786    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(


5787        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))


5788    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())


5789    {


5790        ::nlohmann::to_json(j, std::forward<TargetType>(val));


5791    }


5792};


5793


5794NLOHMANN_JSON_NAMESPACE_END


5795


5796// #include <nlohmann/byte_container_with_subtype.hpp>


5797//     __ _____ _____ _____


5798//  __|  |   __|     |   | |  JSON for Modern C++


5799// |  |  |__   |  |  | | | |  version 3.11.2


5800// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


5801//


5802// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


5803// SPDX-License-Identifier: MIT


5804


5805


5806


5807#include <cstdint> // uint8_t, uint64_t


5808#include <tuple> // tie


5809#include <utility> // move


5810


5811// #include <nlohmann/detail/abi_macros.hpp>


5812


5813


5814NLOHMANN_JSON_NAMESPACE_BEGIN


5815


5816/// @brief an internal type for a backed binary type


5817/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/


5818template<typename BinaryType>


5819class byte_container_with_subtype : public BinaryType


5820{


5821  public:


5822    using container_type = BinaryType;


5823    using subtype_type = std::uint64_t;


5824


5825    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/


5826    byte_container_with_subtype() noexcept(noexcept(container_type()))


5827        : container_type()


5828    {}


5829


5830    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/


5831    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))


5832        : container_type(b)


5833    {}


5834


5835    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/


5836    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))


5837        : container_type(std::move(b))


5838    {}


5839


5840    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/


5841    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))


5842        : container_type(b)


5843        , m_subtype(subtype_)


5844        , m_has_subtype(true)


5845    {}


5846


5847    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/


5848    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))


5849        : container_type(std::move(b))


5850        , m_subtype(subtype_)


5851        , m_has_subtype(true)


5852    {}


5853


5854    bool operator==(const byte_container_with_subtype& rhs) const


5855    {


5856        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==


5857               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);


5858    }


5859


5860    bool operator!=(const byte_container_with_subtype& rhs) const


5861    {


5862        return !(rhs == *this);


5863    }


5864


5865    /// @brief sets the binary subtype


5866    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/


5867    void set_subtype(subtype_type subtype_) noexcept


5868    {


5869        m_subtype = subtype_;


5870        m_has_subtype = true;


5871    }


5872


5873    /// @brief return the binary subtype


5874    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/


5875    constexpr subtype_type subtype() const noexcept


5876    {


5877        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);


5878    }


5879


5880    /// @brief return whether the value has a subtype


5881    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/


5882    constexpr bool has_subtype() const noexcept


5883    {


5884        return m_has_subtype;


5885    }


5886


5887    /// @brief clears the binary subtype


5888    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/


5889    void clear_subtype() noexcept


5890    {


5891        m_subtype = 0;


5892        m_has_subtype = false;


5893    }


5894


5895  private:


5896    subtype_type m_subtype = 0;


5897    bool m_has_subtype = false;


5898};


5899


5900NLOHMANN_JSON_NAMESPACE_END


5901


5902// #include <nlohmann/detail/conversions/from_json.hpp>


5903


5904// #include <nlohmann/detail/conversions/to_json.hpp>


5905


5906// #include <nlohmann/detail/exceptions.hpp>


5907


5908// #include <nlohmann/detail/hash.hpp>


5909//     __ _____ _____ _____


5910//  __|  |   __|     |   | |  JSON for Modern C++


5911// |  |  |__   |  |  | | | |  version 3.11.2


5912// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


5913//


5914// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


5915// SPDX-License-Identifier: MIT


5916


5917


5918


5919#include <cstdint> // uint8_t


5920#include <cstddef> // size_t


5921#include <functional> // hash


5922


5923// #include <nlohmann/detail/abi_macros.hpp>


5924


5925// #include <nlohmann/detail/value_t.hpp>


5926


5927


5928NLOHMANN_JSON_NAMESPACE_BEGIN


5929namespace detail


5930{


5931


5932// boost::hash_combine


5933inline std::size_t combine(std::size_t seed, std::size_t h) noexcept


5934{


5935    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);


5936    return seed;


5937}


5938


5939/*!


5940@brief hash a JSON value


5941


5942The hash function tries to rely on std::hash where possible. Furthermore, the


5943type of the JSON value is taken into account to have different hash values for


5944null, 0, 0U, and false, etc.


5945


5946@tparam BasicJsonType basic_json specialization


5947@param j JSON value to hash


5948@return hash value of j


5949*/


5950template<typename BasicJsonType>


5951std::size_t hash(const BasicJsonType& j)


5952{


5953    using string_t = typename BasicJsonType::string_t;


5954    using number_integer_t = typename BasicJsonType::number_integer_t;


5955    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


5956    using number_float_t = typename BasicJsonType::number_float_t;


5957


5958    const auto type = static_cast<std::size_t>(j.type());


5959    switch (j.type())


5960    {


5961        case BasicJsonType::value_t::null:


5962        case BasicJsonType::value_t::discarded:


5963        {


5964            return combine(type, 0);


5965        }


5966


5967        case BasicJsonType::value_t::object:


5968        {


5969            auto seed = combine(type, j.size());


5970            for (const auto& element : j.items())


5971            {


5972                const auto h = std::hash<string_t> {}(element.key());


5973                seed = combine(seed, h);


5974                seed = combine(seed, hash(element.value()));


5975            }


5976            return seed;


5977        }


5978


5979        case BasicJsonType::value_t::array:


5980        {


5981            auto seed = combine(type, j.size());


5982            for (const auto& element : j)


5983            {


5984                seed = combine(seed, hash(element));


5985            }


5986            return seed;


5987        }


5988


5989        case BasicJsonType::value_t::string:


5990        {


5991            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());


5992            return combine(type, h);


5993        }


5994


5995        case BasicJsonType::value_t::boolean:


5996        {


5997            const auto h = std::hash<bool> {}(j.template get<bool>());


5998            return combine(type, h);


5999        }


6000


6001        case BasicJsonType::value_t::number_integer:


6002        {


6003            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());


6004            return combine(type, h);


6005        }


6006


6007        case BasicJsonType::value_t::number_unsigned:


6008        {


6009            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());


6010            return combine(type, h);


6011        }


6012


6013        case BasicJsonType::value_t::number_float:


6014        {


6015            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());


6016            return combine(type, h);


6017        }


6018


6019        case BasicJsonType::value_t::binary:


6020        {


6021            auto seed = combine(type, j.get_binary().size());


6022            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());


6023            seed = combine(seed, h);


6024            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));


6025            for (const auto byte : j.get_binary())


6026            {


6027                seed = combine(seed, std::hash<std::uint8_t> {}(byte));


6028            }


6029            return seed;


6030        }


6031


6032        default:                   // LCOV_EXCL_LINE


6033            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


6034            return 0;              // LCOV_EXCL_LINE


6035    }


6036}


6037


6038}  // namespace detail


6039NLOHMANN_JSON_NAMESPACE_END


6040


6041// #include <nlohmann/detail/input/binary_reader.hpp>


6042//     __ _____ _____ _____


6043//  __|  |   __|     |   | |  JSON for Modern C++


6044// |  |  |__   |  |  | | | |  version 3.11.2


6045// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


6046//


6047// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


6048// SPDX-License-Identifier: MIT


6049


6050


6051


6052#include <algorithm> // generate_n


6053#include <array> // array


6054#include <cmath> // ldexp


6055#include <cstddef> // size_t


6056#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t


6057#include <cstdio> // snprintf


6058#include <cstring> // memcpy


6059#include <iterator> // back_inserter


6060#include <limits> // numeric_limits


6061#include <string> // char_traits, string


6062#include <utility> // make_pair, move


6063#include <vector> // vector


6064


6065// #include <nlohmann/detail/exceptions.hpp>


6066


6067// #include <nlohmann/detail/input/input_adapters.hpp>


6068//     __ _____ _____ _____


6069//  __|  |   __|     |   | |  JSON for Modern C++


6070// |  |  |__   |  |  | | | |  version 3.11.2


6071// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


6072//


6073// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


6074// SPDX-License-Identifier: MIT


6075


6076


6077


6078#include <array> // array


6079#include <cstddef> // size_t


6080#include <cstring> // strlen


6081#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next


6082#include <memory> // shared_ptr, make_shared, addressof


6083#include <numeric> // accumulate


6084#include <string> // string, char_traits


6085#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer


6086#include <utility> // pair, declval


6087


6088#ifndef JSON_NO_IO


6089    #include <cstdio>   // FILE *


6090    #include <istream>  // istream


6091#endif                  // JSON_NO_IO


6092


6093// #include <nlohmann/detail/iterators/iterator_traits.hpp>


6094


6095// #include <nlohmann/detail/macro_scope.hpp>


6096


6097


6098NLOHMANN_JSON_NAMESPACE_BEGIN


6099namespace detail


6100{


6101


6102/// the supported input formats


6103enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };


6104


6105////////////////////


6106// input adapters //


6107////////////////////


6108


6109#ifndef JSON_NO_IO


6110/*!


6111Input adapter for stdio file access. This adapter read only 1 byte and do not use any


6112 buffer. This adapter is a very low level adapter.


6113*/


6114class file_input_adapter


6115{


6116  public:


6117    using char_type = char;


6118


6119    JSON_HEDLEY_NON_NULL(2)


6120    explicit file_input_adapter(std::FILE* f) noexcept


6121        : m_file(f)


6122    {


6123        JSON_ASSERT(m_file != nullptr);


6124    }


6125


6126    // make class move-only


6127    file_input_adapter(const file_input_adapter&) = delete;


6128    file_input_adapter(file_input_adapter&&) noexcept = default;


6129    file_input_adapter& operator=(const file_input_adapter&) = delete;


6130    file_input_adapter& operator=(file_input_adapter&&) = delete;


6131    ~file_input_adapter() = default;


6132


6133    std::char_traits<char>::int_type get_character() noexcept


6134    {


6135        return std::fgetc(m_file);


6136    }


6137


6138  private:


6139    /// the file pointer to read from


6140    std::FILE* m_file;


6141};


6142


6143


6144/*!


6145Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at


6146beginning of input. Does not support changing the underlying std::streambuf


6147in mid-input. Maintains underlying std::istream and std::streambuf to support


6148subsequent use of standard std::istream operations to process any input


6149characters following those used in parsing the JSON input.  Clears the


6150std::istream flags; any input errors (e.g., EOF) will be detected by the first


6151subsequent call for input from the std::istream.


6152*/


6153class input_stream_adapter


6154{


6155  public:


6156    using char_type = char;


6157


6158    ~input_stream_adapter()


6159    {


6160        // clear stream flags; we use underlying streambuf I/O, do not


6161        // maintain ifstream flags, except eof


6162        if (is != nullptr)


6163        {


6164            is->clear(is->rdstate() & std::ios::eofbit);


6165        }


6166    }


6167


6168    explicit input_stream_adapter(std::istream& i)


6169        : is(&i), sb(i.rdbuf())


6170    {}


6171


6172    // delete because of pointer members


6173    input_stream_adapter(const input_stream_adapter&) = delete;


6174    input_stream_adapter& operator=(input_stream_adapter&) = delete;


6175    input_stream_adapter& operator=(input_stream_adapter&&) = delete;


6176


6177    input_stream_adapter(input_stream_adapter&& rhs) noexcept


6178        : is(rhs.is), sb(rhs.sb)


6179    {


6180        rhs.is = nullptr;


6181        rhs.sb = nullptr;


6182    }


6183


6184    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to


6185    // ensure that std::char_traits<char>::eof() and the character 0xFF do not


6186    // end up as the same value, e.g. 0xFFFFFFFF.


6187    std::char_traits<char>::int_type get_character()


6188    {


6189        auto res = sb->sbumpc();


6190        // set eof manually, as we don't use the istream interface.


6191        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))


6192        {


6193            is->clear(is->rdstate() | std::ios::eofbit);


6194        }


6195        return res;


6196    }


6197


6198  private:


6199    /// the associated input stream


6200    std::istream* is = nullptr;


6201    std::streambuf* sb = nullptr;


6202};


6203#endif  // JSON_NO_IO


6204


6205// General-purpose iterator-based adapter. It might not be as fast as


6206// theoretically possible for some containers, but it is extremely versatile.


6207template<typename IteratorType>


6208class iterator_input_adapter


6209{


6210  public:


6211    using char_type = typename std::iterator_traits<IteratorType>::value_type;


6212


6213    iterator_input_adapter(IteratorType first, IteratorType last)


6214        : current(std::move(first)), end(std::move(last))


6215    {}


6216


6217    typename std::char_traits<char_type>::int_type get_character()


6218    {


6219        if (JSON_HEDLEY_LIKELY(current != end))


6220        {


6221            auto result = std::char_traits<char_type>::to_int_type(*current);


6222            std::advance(current, 1);


6223            return result;


6224        }


6225


6226        return std::char_traits<char_type>::eof();


6227    }


6228


6229  private:


6230    IteratorType current;


6231    IteratorType end;


6232


6233    template<typename BaseInputAdapter, size_t T>


6234    friend struct wide_string_input_helper;


6235


6236    bool empty() const


6237    {


6238        return current == end;


6239    }


6240};


6241


6242


6243template<typename BaseInputAdapter, size_t T>


6244struct wide_string_input_helper;


6245


6246template<typename BaseInputAdapter>


6247struct wide_string_input_helper<BaseInputAdapter, 4>


6248{


6249    // UTF-32


6250    static void fill_buffer(BaseInputAdapter& input,


6251                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,


6252                            size_t& utf8_bytes_index,


6253                            size_t& utf8_bytes_filled)


6254    {


6255        utf8_bytes_index = 0;


6256


6257        if (JSON_HEDLEY_UNLIKELY(input.empty()))


6258        {


6259            utf8_bytes[0] = std::char_traits<char>::eof();


6260            utf8_bytes_filled = 1;


6261        }


6262        else


6263        {


6264            // get the current character


6265            const auto wc = input.get_character();


6266


6267            // UTF-32 to UTF-8 encoding


6268            if (wc < 0x80)


6269            {


6270                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);


6271                utf8_bytes_filled = 1;


6272            }


6273            else if (wc <= 0x7FF)


6274            {


6275                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));


6276                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));


6277                utf8_bytes_filled = 2;


6278            }


6279            else if (wc <= 0xFFFF)


6280            {


6281                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));


6282                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));


6283                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));


6284                utf8_bytes_filled = 3;


6285            }


6286            else if (wc <= 0x10FFFF)


6287            {


6288                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));


6289                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));


6290                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));


6291                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));


6292                utf8_bytes_filled = 4;


6293            }


6294            else


6295            {


6296                // unknown character


6297                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);


6298                utf8_bytes_filled = 1;


6299            }


6300        }


6301    }


6302};


6303


6304template<typename BaseInputAdapter>


6305struct wide_string_input_helper<BaseInputAdapter, 2>


6306{


6307    // UTF-16


6308    static void fill_buffer(BaseInputAdapter& input,


6309                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,


6310                            size_t& utf8_bytes_index,


6311                            size_t& utf8_bytes_filled)


6312    {


6313        utf8_bytes_index = 0;


6314


6315        if (JSON_HEDLEY_UNLIKELY(input.empty()))


6316        {


6317            utf8_bytes[0] = std::char_traits<char>::eof();


6318            utf8_bytes_filled = 1;


6319        }


6320        else


6321        {


6322            // get the current character


6323            const auto wc = input.get_character();


6324


6325            // UTF-16 to UTF-8 encoding


6326            if (wc < 0x80)


6327            {


6328                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);


6329                utf8_bytes_filled = 1;


6330            }


6331            else if (wc <= 0x7FF)


6332            {


6333                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));


6334                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));


6335                utf8_bytes_filled = 2;


6336            }


6337            else if (0xD800 > wc || wc >= 0xE000)


6338            {


6339                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));


6340                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));


6341                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));


6342                utf8_bytes_filled = 3;


6343            }


6344            else


6345            {


6346                if (JSON_HEDLEY_UNLIKELY(!input.empty()))


6347                {


6348                    const auto wc2 = static_cast<unsigned int>(input.get_character());


6349                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));


6350                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));


6351                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));


6352                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));


6353                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));


6354                    utf8_bytes_filled = 4;


6355                }


6356                else


6357                {


6358                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);


6359                    utf8_bytes_filled = 1;


6360                }


6361            }


6362        }


6363    }


6364};


6365


6366// Wraps another input apdater to convert wide character types into individual bytes.


6367template<typename BaseInputAdapter, typename WideCharType>


6368class wide_string_input_adapter


6369{


6370  public:


6371    using char_type = char;


6372


6373    wide_string_input_adapter(BaseInputAdapter base)


6374        : base_adapter(base) {}


6375


6376    typename std::char_traits<char>::int_type get_character() noexcept


6377    {


6378        // check if buffer needs to be filled


6379        if (utf8_bytes_index == utf8_bytes_filled)


6380        {


6381            fill_buffer<sizeof(WideCharType)>();


6382


6383            JSON_ASSERT(utf8_bytes_filled > 0);


6384            JSON_ASSERT(utf8_bytes_index == 0);


6385        }


6386


6387        // use buffer


6388        JSON_ASSERT(utf8_bytes_filled > 0);


6389        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);


6390        return utf8_bytes[utf8_bytes_index++];


6391    }


6392


6393  private:


6394    BaseInputAdapter base_adapter;


6395


6396    template<size_t T>


6397    void fill_buffer()


6398    {


6399        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);


6400    }


6401


6402    /// a buffer for UTF-8 bytes


6403    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};


6404


6405    /// index to the utf8_codes array for the next valid byte


6406    std::size_t utf8_bytes_index = 0;


6407    /// number of valid bytes in the utf8_codes array


6408    std::size_t utf8_bytes_filled = 0;


6409};


6410


6411


6412template<typename IteratorType, typename Enable = void>


6413struct iterator_input_adapter_factory


6414{


6415    using iterator_type = IteratorType;


6416    using char_type = typename std::iterator_traits<iterator_type>::value_type;


6417    using adapter_type = iterator_input_adapter<iterator_type>;


6418


6419    static adapter_type create(IteratorType first, IteratorType last)


6420    {


6421        return adapter_type(std::move(first), std::move(last));


6422    }


6423};


6424


6425template<typename T>


6426struct is_iterator_of_multibyte


6427{


6428    using value_type = typename std::iterator_traits<T>::value_type;


6429    enum


6430    {


6431        value = sizeof(value_type) > 1


6432    };


6433};


6434


6435template<typename IteratorType>


6436struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>


6437{


6438    using iterator_type = IteratorType;


6439    using char_type = typename std::iterator_traits<iterator_type>::value_type;


6440    using base_adapter_type = iterator_input_adapter<iterator_type>;


6441    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;


6442


6443    static adapter_type create(IteratorType first, IteratorType last)


6444    {


6445        return adapter_type(base_adapter_type(std::move(first), std::move(last)));


6446    }


6447};


6448


6449// General purpose iterator-based input


6450template<typename IteratorType>


6451typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)


6452{


6453    using factory_type = iterator_input_adapter_factory<IteratorType>;


6454    return factory_type::create(first, last);


6455}


6456


6457// Convenience shorthand from container to iterator


6458// Enables ADL on begin(container) and end(container)


6459// Encloses the using declarations in namespace for not to leak them to outside scope


6460


6461namespace container_input_adapter_factory_impl


6462{


6463


6464using std::begin;


6465using std::end;


6466


6467template<typename ContainerType, typename Enable = void>


6468struct container_input_adapter_factory {};


6469


6470template<typename ContainerType>


6471struct container_input_adapter_factory< ContainerType,


6472       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>


6473       {


6474           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));


6475


6476           static adapter_type create(const ContainerType& container)


6477{


6478    return input_adapter(begin(container), end(container));


6479}


6480       };


6481


6482}  // namespace container_input_adapter_factory_impl


6483


6484template<typename ContainerType>


6485typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)


6486{


6487    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);


6488}


6489


6490#ifndef JSON_NO_IO


6491// Special cases with fast paths


6492inline file_input_adapter input_adapter(std::FILE* file)


6493{


6494    return file_input_adapter(file);


6495}


6496


6497inline input_stream_adapter input_adapter(std::istream& stream)


6498{


6499    return input_stream_adapter(stream);


6500}


6501


6502inline input_stream_adapter input_adapter(std::istream&& stream)


6503{


6504    return input_stream_adapter(stream);


6505}


6506#endif  // JSON_NO_IO


6507


6508using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));


6509


6510// Null-delimited strings, and the like.


6511template < typename CharT,


6512           typename std::enable_if <


6513               std::is_pointer<CharT>::value&&


6514               !std::is_array<CharT>::value&&


6515               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&


6516               sizeof(typename std::remove_pointer<CharT>::type) == 1,


6517               int >::type = 0 >


6518contiguous_bytes_input_adapter input_adapter(CharT b)


6519{


6520    auto length = std::strlen(reinterpret_cast<const char*>(b));


6521    const auto* ptr = reinterpret_cast<const char*>(b);


6522    return input_adapter(ptr, ptr + length);


6523}


6524


6525template<typename T, std::size_t N>


6526auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


6527{


6528    return input_adapter(array, array + N);


6529}


6530


6531// This class only handles inputs of input_buffer_adapter type.


6532// It's required so that expressions like {ptr, len} can be implicitly cast


6533// to the correct adapter.


6534class span_input_adapter


6535{


6536  public:


6537    template < typename CharT,


6538               typename std::enable_if <


6539                   std::is_pointer<CharT>::value&&


6540                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&


6541                   sizeof(typename std::remove_pointer<CharT>::type) == 1,


6542                   int >::type = 0 >


6543    span_input_adapter(CharT b, std::size_t l)


6544        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}


6545


6546    template<class IteratorType,


6547             typename std::enable_if<


6548                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,


6549                 int>::type = 0>


6550    span_input_adapter(IteratorType first, IteratorType last)


6551        : ia(input_adapter(first, last)) {}


6552


6553    contiguous_bytes_input_adapter&& get()


6554    {


6555        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)


6556    }


6557


6558  private:


6559    contiguous_bytes_input_adapter ia;


6560};


6561


6562}  // namespace detail


6563NLOHMANN_JSON_NAMESPACE_END


6564


6565// #include <nlohmann/detail/input/json_sax.hpp>


6566//     __ _____ _____ _____


6567//  __|  |   __|     |   | |  JSON for Modern C++


6568// |  |  |__   |  |  | | | |  version 3.11.2


6569// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


6570//


6571// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


6572// SPDX-License-Identifier: MIT


6573


6574


6575


6576#include <cstddef>


6577#include <string> // string


6578#include <utility> // move


6579#include <vector> // vector


6580


6581// #include <nlohmann/detail/exceptions.hpp>


6582


6583// #include <nlohmann/detail/macro_scope.hpp>


6584


6585// #include <nlohmann/detail/string_concat.hpp>


6586


6587


6588NLOHMANN_JSON_NAMESPACE_BEGIN


6589


6590/*!


6591@brief SAX interface


6592


6593This class describes the SAX interface used by @ref nlohmann::json::sax_parse.


6594Each function is called in different situations while the input is parsed. The


6595boolean return value informs the parser whether to continue processing the


6596input.


6597*/


6598template<typename BasicJsonType>


6599struct json_sax


6600{


6601    using number_integer_t = typename BasicJsonType::number_integer_t;


6602    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


6603    using number_float_t = typename BasicJsonType::number_float_t;


6604    using string_t = typename BasicJsonType::string_t;


6605    using binary_t = typename BasicJsonType::binary_t;


6606


6607    /*!


6608    @brief a null value was read


6609    @return whether parsing should proceed


6610    */


6611    virtual bool null() = 0;


6612


6613    /*!


6614    @brief a boolean value was read


6615    @param[in] val  boolean value


6616    @return whether parsing should proceed


6617    */


6618    virtual bool boolean(bool val) = 0;


6619


6620    /*!


6621    @brief an integer number was read


6622    @param[in] val  integer value


6623    @return whether parsing should proceed


6624    */


6625    virtual bool number_integer(number_integer_t val) = 0;


6626


6627    /*!


6628    @brief an unsigned integer number was read


6629    @param[in] val  unsigned integer value


6630    @return whether parsing should proceed


6631    */


6632    virtual bool number_unsigned(number_unsigned_t val) = 0;


6633


6634    /*!


6635    @brief a floating-point number was read


6636    @param[in] val  floating-point value


6637    @param[in] s    raw token value


6638    @return whether parsing should proceed


6639    */


6640    virtual bool number_float(number_float_t val, const string_t& s) = 0;


6641


6642    /*!


6643    @brief a string value was read


6644    @param[in] val  string value


6645    @return whether parsing should proceed


6646    @note It is safe to move the passed string value.


6647    */


6648    virtual bool string(string_t& val) = 0;


6649


6650    /*!


6651    @brief a binary value was read


6652    @param[in] val  binary value


6653    @return whether parsing should proceed


6654    @note It is safe to move the passed binary value.


6655    */


6656    virtual bool binary(binary_t& val) = 0;


6657


6658    /*!


6659    @brief the beginning of an object was read


6660    @param[in] elements  number of object elements or -1 if unknown


6661    @return whether parsing should proceed


6662    @note binary formats may report the number of elements


6663    */


6664    virtual bool start_object(std::size_t elements) = 0;


6665


6666    /*!


6667    @brief an object key was read


6668    @param[in] val  object key


6669    @return whether parsing should proceed


6670    @note It is safe to move the passed string.


6671    */


6672    virtual bool key(string_t& val) = 0;


6673


6674    /*!


6675    @brief the end of an object was read


6676    @return whether parsing should proceed


6677    */


6678    virtual bool end_object() = 0;


6679


6680    /*!


6681    @brief the beginning of an array was read


6682    @param[in] elements  number of array elements or -1 if unknown


6683    @return whether parsing should proceed


6684    @note binary formats may report the number of elements


6685    */


6686    virtual bool start_array(std::size_t elements) = 0;


6687


6688    /*!


6689    @brief the end of an array was read


6690    @return whether parsing should proceed


6691    */


6692    virtual bool end_array() = 0;


6693


6694    /*!


6695    @brief a parse error occurred


6696    @param[in] position    the position in the input where the error occurs


6697    @param[in] last_token  the last read token


6698    @param[in] ex          an exception object describing the error


6699    @return whether parsing should proceed (must return false)


6700    */


6701    virtual bool parse_error(std::size_t position,


6702                             const std::string& last_token,


6703                             const detail::exception& ex) = 0;


6704


6705    json_sax() = default;


6706    json_sax(const json_sax&) = default;


6707    json_sax(json_sax&&) noexcept = default;


6708    json_sax& operator=(const json_sax&) = default;


6709    json_sax& operator=(json_sax&&) noexcept = default;


6710    virtual ~json_sax() = default;


6711};


6712


6713


6714namespace detail


6715{


6716/*!


6717@brief SAX implementation to create a JSON value from SAX events


6718


6719This class implements the @ref json_sax interface and processes the SAX events


6720to create a JSON value which makes it basically a DOM parser. The structure or


6721hierarchy of the JSON value is managed by the stack `ref_stack` which contains


6722a pointer to the respective array or object for each recursion depth.


6723


6724After successful parsing, the value that is passed by reference to the


6725constructor contains the parsed value.


6726


6727@tparam BasicJsonType  the JSON type


6728*/


6729template<typename BasicJsonType>


6730class json_sax_dom_parser


6731{


6732  public:


6733    using number_integer_t = typename BasicJsonType::number_integer_t;


6734    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


6735    using number_float_t = typename BasicJsonType::number_float_t;


6736    using string_t = typename BasicJsonType::string_t;


6737    using binary_t = typename BasicJsonType::binary_t;


6738


6739    /*!


6740    @param[in,out] r  reference to a JSON value that is manipulated while


6741                       parsing


6742    @param[in] allow_exceptions_  whether parse errors yield exceptions


6743    */


6744    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)


6745        : root(r), allow_exceptions(allow_exceptions_)


6746    {}


6747


6748    // make class move-only


6749    json_sax_dom_parser(const json_sax_dom_parser&) = delete;


6750    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


6751    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;


6752    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


6753    ~json_sax_dom_parser() = default;


6754


6755    bool null()


6756    {


6757        handle_value(nullptr);


6758        return true;


6759    }


6760


6761    bool boolean(bool val)


6762    {


6763        handle_value(val);


6764        return true;


6765    }


6766


6767    bool number_integer(number_integer_t val)


6768    {


6769        handle_value(val);


6770        return true;


6771    }


6772


6773    bool number_unsigned(number_unsigned_t val)


6774    {


6775        handle_value(val);


6776        return true;


6777    }


6778


6779    bool number_float(number_float_t val, const string_t& /*unused*/)


6780    {


6781        handle_value(val);


6782        return true;


6783    }


6784


6785    bool string(string_t& val)


6786    {


6787        handle_value(val);


6788        return true;


6789    }


6790


6791    bool binary(binary_t& val)


6792    {


6793        handle_value(std::move(val));


6794        return true;


6795    }


6796


6797    bool start_object(std::size_t len)


6798    {


6799        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));


6800


6801        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))


6802        {


6803            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));


6804        }


6805


6806        return true;


6807    }


6808


6809    bool key(string_t& val)


6810    {


6811        JSON_ASSERT(!ref_stack.empty());


6812        JSON_ASSERT(ref_stack.back()->is_object());


6813


6814        // add null at given key and store the reference for later


6815        object_element = &(ref_stack.back()->m_value.object->operator[](val));


6816        return true;


6817    }


6818


6819    bool end_object()


6820    {


6821        JSON_ASSERT(!ref_stack.empty());


6822        JSON_ASSERT(ref_stack.back()->is_object());


6823


6824        ref_stack.back()->set_parents();


6825        ref_stack.pop_back();


6826        return true;


6827    }


6828


6829    bool start_array(std::size_t len)


6830    {


6831        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));


6832


6833        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))


6834        {


6835            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));


6836        }


6837


6838        return true;


6839    }


6840


6841    bool end_array()


6842    {


6843        JSON_ASSERT(!ref_stack.empty());


6844        JSON_ASSERT(ref_stack.back()->is_array());


6845


6846        ref_stack.back()->set_parents();


6847        ref_stack.pop_back();


6848        return true;


6849    }


6850


6851    template<class Exception>


6852    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,


6853                     const Exception& ex)


6854    {


6855        errored = true;


6856        static_cast<void>(ex);


6857        if (allow_exceptions)


6858        {


6859            JSON_THROW(ex);


6860        }


6861        return false;


6862    }


6863


6864    constexpr bool is_errored() const


6865    {


6866        return errored;


6867    }


6868


6869  private:


6870    /*!


6871    @invariant If the ref stack is empty, then the passed value will be the new


6872               root.


6873    @invariant If the ref stack contains a value, then it is an array or an


6874               object to which we can add elements


6875    */


6876    template<typename Value>


6877    JSON_HEDLEY_RETURNS_NON_NULL


6878    BasicJsonType* handle_value(Value&& v)


6879    {


6880        if (ref_stack.empty())


6881        {


6882            root = BasicJsonType(std::forward<Value>(v));


6883            return &root;


6884        }


6885


6886        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());


6887


6888        if (ref_stack.back()->is_array())


6889        {


6890            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));


6891            return &(ref_stack.back()->m_value.array->back());


6892        }


6893


6894        JSON_ASSERT(ref_stack.back()->is_object());


6895        JSON_ASSERT(object_element);


6896        *object_element = BasicJsonType(std::forward<Value>(v));


6897        return object_element;


6898    }


6899


6900    /// the parsed JSON value


6901    BasicJsonType& root;


6902    /// stack to model hierarchy of values


6903    std::vector<BasicJsonType*> ref_stack {};


6904    /// helper to hold the reference for the next object element


6905    BasicJsonType* object_element = nullptr;


6906    /// whether a syntax error occurred


6907    bool errored = false;


6908    /// whether to throw exceptions in case of errors


6909    const bool allow_exceptions = true;


6910};


6911


6912template<typename BasicJsonType>


6913class json_sax_dom_callback_parser


6914{


6915  public:


6916    using number_integer_t = typename BasicJsonType::number_integer_t;


6917    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


6918    using number_float_t = typename BasicJsonType::number_float_t;


6919    using string_t = typename BasicJsonType::string_t;


6920    using binary_t = typename BasicJsonType::binary_t;


6921    using parser_callback_t = typename BasicJsonType::parser_callback_t;


6922    using parse_event_t = typename BasicJsonType::parse_event_t;


6923


6924    json_sax_dom_callback_parser(BasicJsonType& r,


6925                                 const parser_callback_t cb,


6926                                 const bool allow_exceptions_ = true)


6927        : root(r), callback(cb), allow_exceptions(allow_exceptions_)


6928    {


6929        keep_stack.push_back(true);


6930    }


6931


6932    // make class move-only


6933    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;


6934    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


6935    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;


6936    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


6937    ~json_sax_dom_callback_parser() = default;


6938


6939    bool null()


6940    {


6941        handle_value(nullptr);


6942        return true;


6943    }


6944


6945    bool boolean(bool val)


6946    {


6947        handle_value(val);


6948        return true;


6949    }


6950


6951    bool number_integer(number_integer_t val)


6952    {


6953        handle_value(val);


6954        return true;


6955    }


6956


6957    bool number_unsigned(number_unsigned_t val)


6958    {


6959        handle_value(val);


6960        return true;


6961    }


6962


6963    bool number_float(number_float_t val, const string_t& /*unused*/)


6964    {


6965        handle_value(val);


6966        return true;


6967    }


6968


6969    bool string(string_t& val)


6970    {


6971        handle_value(val);


6972        return true;


6973    }


6974


6975    bool binary(binary_t& val)


6976    {


6977        handle_value(std::move(val));


6978        return true;


6979    }


6980


6981    bool start_object(std::size_t len)


6982    {


6983        // check callback for object start


6984        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);


6985        keep_stack.push_back(keep);


6986


6987        auto val = handle_value(BasicJsonType::value_t::object, true);


6988        ref_stack.push_back(val.second);


6989


6990        // check object limit


6991        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))


6992        {


6993            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));


6994        }


6995


6996        return true;


6997    }


6998


6999    bool key(string_t& val)


7000    {


7001        BasicJsonType k = BasicJsonType(val);


7002


7003        // check callback for key


7004        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);


7005        key_keep_stack.push_back(keep);


7006


7007        // add discarded value at given key and store the reference for later


7008        if (keep && ref_stack.back())


7009        {


7010            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);


7011        }


7012


7013        return true;


7014    }


7015


7016    bool end_object()


7017    {


7018        if (ref_stack.back())


7019        {


7020            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))


7021            {


7022                // discard object


7023                *ref_stack.back() = discarded;


7024            }


7025            else


7026            {


7027                ref_stack.back()->set_parents();


7028            }


7029        }


7030


7031        JSON_ASSERT(!ref_stack.empty());


7032        JSON_ASSERT(!keep_stack.empty());


7033        ref_stack.pop_back();


7034        keep_stack.pop_back();


7035


7036        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())


7037        {


7038            // remove discarded value


7039            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)


7040            {


7041                if (it->is_discarded())


7042                {


7043                    ref_stack.back()->erase(it);


7044                    break;


7045                }


7046            }


7047        }


7048


7049        return true;


7050    }


7051


7052    bool start_array(std::size_t len)


7053    {


7054        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);


7055        keep_stack.push_back(keep);


7056


7057        auto val = handle_value(BasicJsonType::value_t::array, true);


7058        ref_stack.push_back(val.second);


7059


7060        // check array limit


7061        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))


7062        {


7063            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));


7064        }


7065


7066        return true;


7067    }


7068


7069    bool end_array()


7070    {


7071        bool keep = true;


7072


7073        if (ref_stack.back())


7074        {


7075            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());


7076            if (keep)


7077            {


7078                ref_stack.back()->set_parents();


7079            }


7080            else


7081            {


7082                // discard array


7083                *ref_stack.back() = discarded;


7084            }


7085        }


7086


7087        JSON_ASSERT(!ref_stack.empty());


7088        JSON_ASSERT(!keep_stack.empty());


7089        ref_stack.pop_back();


7090        keep_stack.pop_back();


7091


7092        // remove discarded value


7093        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())


7094        {


7095            ref_stack.back()->m_value.array->pop_back();


7096        }


7097


7098        return true;


7099    }


7100


7101    template<class Exception>


7102    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,


7103                     const Exception& ex)


7104    {


7105        errored = true;


7106        static_cast<void>(ex);


7107        if (allow_exceptions)


7108        {


7109            JSON_THROW(ex);


7110        }


7111        return false;


7112    }


7113


7114    constexpr bool is_errored() const


7115    {


7116        return errored;


7117    }


7118


7119  private:


7120    /*!


7121    @param[in] v  value to add to the JSON value we build during parsing


7122    @param[in] skip_callback  whether we should skip calling the callback


7123               function; this is required after start_array() and


7124               start_object() SAX events, because otherwise we would call the


7125               callback function with an empty array or object, respectively.


7126


7127    @invariant If the ref stack is empty, then the passed value will be the new


7128               root.


7129    @invariant If the ref stack contains a value, then it is an array or an


7130               object to which we can add elements


7131


7132    @return pair of boolean (whether value should be kept) and pointer (to the


7133            passed value in the ref_stack hierarchy; nullptr if not kept)


7134    */


7135    template<typename Value>


7136    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)


7137    {


7138        JSON_ASSERT(!keep_stack.empty());


7139


7140        // do not handle this value if we know it would be added to a discarded


7141        // container


7142        if (!keep_stack.back())


7143        {


7144            return {false, nullptr};


7145        }


7146


7147        // create value


7148        auto value = BasicJsonType(std::forward<Value>(v));


7149


7150        // check callback


7151        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);


7152


7153        // do not handle this value if we just learnt it shall be discarded


7154        if (!keep)


7155        {


7156            return {false, nullptr};


7157        }


7158


7159        if (ref_stack.empty())


7160        {


7161            root = std::move(value);


7162            return {true, &root};


7163        }


7164


7165        // skip this value if we already decided to skip the parent


7166        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)


7167        if (!ref_stack.back())


7168        {


7169            return {false, nullptr};


7170        }


7171


7172        // we now only expect arrays and objects


7173        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());


7174


7175        // array


7176        if (ref_stack.back()->is_array())


7177        {


7178            ref_stack.back()->m_value.array->emplace_back(std::move(value));


7179            return {true, &(ref_stack.back()->m_value.array->back())};


7180        }


7181


7182        // object


7183        JSON_ASSERT(ref_stack.back()->is_object());


7184        // check if we should store an element for the current key


7185        JSON_ASSERT(!key_keep_stack.empty());


7186        const bool store_element = key_keep_stack.back();


7187        key_keep_stack.pop_back();


7188


7189        if (!store_element)


7190        {


7191            return {false, nullptr};


7192        }


7193


7194        JSON_ASSERT(object_element);


7195        *object_element = std::move(value);


7196        return {true, object_element};


7197    }


7198


7199    /// the parsed JSON value


7200    BasicJsonType& root;


7201    /// stack to model hierarchy of values


7202    std::vector<BasicJsonType*> ref_stack {};


7203    /// stack to manage which values to keep


7204    std::vector<bool> keep_stack {};


7205    /// stack to manage which object keys to keep


7206    std::vector<bool> key_keep_stack {};


7207    /// helper to hold the reference for the next object element


7208    BasicJsonType* object_element = nullptr;


7209    /// whether a syntax error occurred


7210    bool errored = false;


7211    /// callback function


7212    const parser_callback_t callback = nullptr;


7213    /// whether to throw exceptions in case of errors


7214    const bool allow_exceptions = true;


7215    /// a discarded value for the callback


7216    BasicJsonType discarded = BasicJsonType::value_t::discarded;


7217};


7218


7219template<typename BasicJsonType>


7220class json_sax_acceptor


7221{


7222  public:


7223    using number_integer_t = typename BasicJsonType::number_integer_t;


7224    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


7225    using number_float_t = typename BasicJsonType::number_float_t;


7226    using string_t = typename BasicJsonType::string_t;


7227    using binary_t = typename BasicJsonType::binary_t;


7228


7229    bool null()


7230    {


7231        return true;


7232    }


7233


7234    bool boolean(bool /*unused*/)


7235    {


7236        return true;


7237    }


7238


7239    bool number_integer(number_integer_t /*unused*/)


7240    {


7241        return true;


7242    }


7243


7244    bool number_unsigned(number_unsigned_t /*unused*/)


7245    {


7246        return true;


7247    }


7248


7249    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)


7250    {


7251        return true;


7252    }


7253


7254    bool string(string_t& /*unused*/)


7255    {


7256        return true;


7257    }


7258


7259    bool binary(binary_t& /*unused*/)


7260    {


7261        return true;


7262    }


7263


7264    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))


7265    {


7266        return true;


7267    }


7268


7269    bool key(string_t& /*unused*/)


7270    {


7271        return true;


7272    }


7273


7274    bool end_object()


7275    {


7276        return true;


7277    }


7278


7279    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))


7280    {


7281        return true;


7282    }


7283


7284    bool end_array()


7285    {


7286        return true;


7287    }


7288


7289    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)


7290    {


7291        return false;


7292    }


7293};


7294


7295}  // namespace detail


7296NLOHMANN_JSON_NAMESPACE_END


7297


7298// #include <nlohmann/detail/input/lexer.hpp>


7299//     __ _____ _____ _____


7300//  __|  |   __|     |   | |  JSON for Modern C++


7301// |  |  |__   |  |  | | | |  version 3.11.2


7302// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


7303//


7304// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


7305// SPDX-License-Identifier: MIT


7306


7307


7308


7309#include <array> // array


7310#include <clocale> // localeconv


7311#include <cstddef> // size_t


7312#include <cstdio> // snprintf


7313#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull


7314#include <initializer_list> // initializer_list


7315#include <string> // char_traits, string


7316#include <utility> // move


7317#include <vector> // vector


7318


7319// #include <nlohmann/detail/input/input_adapters.hpp>


7320


7321// #include <nlohmann/detail/input/position_t.hpp>


7322


7323// #include <nlohmann/detail/macro_scope.hpp>


7324


7325


7326NLOHMANN_JSON_NAMESPACE_BEGIN


7327namespace detail


7328{


7329


7330///////////


7331// lexer //


7332///////////


7333


7334template<typename BasicJsonType>


7335class lexer_base


7336{


7337  public:


7338    /// token types for the parser


7339    enum class token_type


7340    {


7341        uninitialized,    ///< indicating the scanner is uninitialized


7342        literal_true,     ///< the `true` literal


7343        literal_false,    ///< the `false` literal


7344        literal_null,     ///< the `null` literal


7345        value_string,     ///< a string -- use get_string() for actual value


7346        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value


7347        value_integer,    ///< a signed integer -- use get_number_integer() for actual value


7348        value_float,      ///< an floating point number -- use get_number_float() for actual value


7349        begin_array,      ///< the character for array begin `[`


7350        begin_object,     ///< the character for object begin `{`


7351        end_array,        ///< the character for array end `]`


7352        end_object,       ///< the character for object end `}`


7353        name_separator,   ///< the name separator `:`


7354        value_separator,  ///< the value separator `,`


7355        parse_error,      ///< indicating a parse error


7356        end_of_input,     ///< indicating the end of the input buffer


7357        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)


7358    };


7359


7360    /// return name of values of type token_type (only used for errors)


7361    JSON_HEDLEY_RETURNS_NON_NULL


7362    JSON_HEDLEY_CONST


7363    static const char* token_type_name(const token_type t) noexcept


7364    {


7365        switch (t)


7366        {


7367            case token_type::uninitialized:


7368                return "<uninitialized>";


7369            case token_type::literal_true:


7370                return "true literal";


7371            case token_type::literal_false:


7372                return "false literal";


7373            case token_type::literal_null:


7374                return "null literal";


7375            case token_type::value_string:


7376                return "string literal";


7377            case token_type::value_unsigned:


7378            case token_type::value_integer:


7379            case token_type::value_float:


7380                return "number literal";


7381            case token_type::begin_array:


7382                return "'['";


7383            case token_type::begin_object:


7384                return "'{'";


7385            case token_type::end_array:


7386                return "']'";


7387            case token_type::end_object:


7388                return "'}'";


7389            case token_type::name_separator:


7390                return "':'";


7391            case token_type::value_separator:


7392                return "','";


7393            case token_type::parse_error:


7394                return "<parse error>";


7395            case token_type::end_of_input:


7396                return "end of input";


7397            case token_type::literal_or_value:


7398                return "'[', '{', or a literal";


7399            // LCOV_EXCL_START


7400            default: // catch non-enum values


7401                return "unknown token";


7402                // LCOV_EXCL_STOP


7403        }


7404    }


7405};


7406/*!


7407@brief lexical analysis


7408


7409This class organizes the lexical analysis during JSON deserialization.


7410*/


7411template<typename BasicJsonType, typename InputAdapterType>


7412class lexer : public lexer_base<BasicJsonType>


7413{


7414    using number_integer_t = typename BasicJsonType::number_integer_t;


7415    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


7416    using number_float_t = typename BasicJsonType::number_float_t;


7417    using string_t = typename BasicJsonType::string_t;


7418    using char_type = typename InputAdapterType::char_type;


7419    using char_int_type = typename std::char_traits<char_type>::int_type;


7420


7421  public:


7422    using token_type = typename lexer_base<BasicJsonType>::token_type;


7423


7424    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept


7425        : ia(std::move(adapter))


7426        , ignore_comments(ignore_comments_)


7427        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))


7428    {}


7429


7430    // delete because of pointer members


7431    lexer(const lexer&) = delete;


7432    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


7433    lexer& operator=(lexer&) = delete;


7434    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


7435    ~lexer() = default;


7436


7437  private:


7438    /////////////////////


7439    // locales


7440    /////////////////////


7441


7442    /// return the locale-dependent decimal point


7443    JSON_HEDLEY_PURE


7444    static char get_decimal_point() noexcept


7445    {


7446        const auto* loc = localeconv();


7447        JSON_ASSERT(loc != nullptr);


7448        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);


7449    }


7450


7451    /////////////////////


7452    // scan functions


7453    /////////////////////


7454


7455    /*!


7456    @brief get codepoint from 4 hex characters following `\u`


7457


7458    For input "\u c1 c2 c3 c4" the codepoint is:


7459      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4


7460    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)


7461


7462    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'


7463    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The


7464    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)


7465    between the ASCII value of the character and the desired integer value.


7466


7467    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or


7468            non-hex character)


7469    */


7470    int get_codepoint()


7471    {


7472        // this function only makes sense after reading `\u`


7473        JSON_ASSERT(current == 'u');


7474        int codepoint = 0;


7475


7476        const auto factors = { 12u, 8u, 4u, 0u };


7477        for (const auto factor : factors)


7478        {


7479            get();


7480


7481            if (current >= '0' && current <= '9')


7482            {


7483                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);


7484            }


7485            else if (current >= 'A' && current <= 'F')


7486            {


7487                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);


7488            }


7489            else if (current >= 'a' && current <= 'f')


7490            {


7491                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);


7492            }


7493            else


7494            {


7495                return -1;


7496            }


7497        }


7498


7499        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);


7500        return codepoint;


7501    }


7502


7503    /*!


7504    @brief check if the next byte(s) are inside a given range


7505


7506    Adds the current byte and, for each passed range, reads a new byte and


7507    checks if it is inside the range. If a violation was detected, set up an


7508    error message and return false. Otherwise, return true.


7509


7510    @param[in] ranges  list of integers; interpreted as list of pairs of


7511                       inclusive lower and upper bound, respectively


7512


7513    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,


7514         1, 2, or 3 pairs. This precondition is enforced by an assertion.


7515


7516    @return true if and only if no range violation was detected


7517    */


7518    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)


7519    {


7520        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);


7521        add(current);


7522


7523        for (auto range = ranges.begin(); range != ranges.end(); ++range)


7524        {


7525            get();


7526            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))


7527            {


7528                add(current);


7529            }


7530            else


7531            {


7532                error_message = "invalid string: ill-formed UTF-8 byte";


7533                return false;


7534            }


7535        }


7536


7537        return true;


7538    }


7539


7540    /*!


7541    @brief scan a string literal


7542


7543    This function scans a string according to Sect. 7 of RFC 8259. While


7544    scanning, bytes are escaped and copied into buffer token_buffer. Then the


7545    function returns successfully, token_buffer is *not* null-terminated (as it


7546    may contain \0 bytes), and token_buffer.size() is the number of bytes in the


7547    string.


7548


7549    @return token_type::value_string if string could be successfully scanned,


7550            token_type::parse_error otherwise


7551


7552    @note In case of errors, variable error_message contains a textual


7553          description.


7554    */


7555    token_type scan_string()


7556    {


7557        // reset token_buffer (ignore opening quote)


7558        reset();


7559


7560        // we entered the function by reading an open quote


7561        JSON_ASSERT(current == '\"');


7562


7563        while (true)


7564        {


7565            // get next character


7566            switch (get())


7567            {


7568                // end of file while parsing string


7569                case std::char_traits<char_type>::eof():


7570                {


7571                    error_message = "invalid string: missing closing quote";


7572                    return token_type::parse_error;


7573                }


7574


7575                // closing quote


7576                case '\"':


7577                {


7578                    return token_type::value_string;


7579                }


7580


7581                // escapes


7582                case '\\':


7583                {


7584                    switch (get())


7585                    {


7586                        // quotation mark


7587                        case '\"':


7588                            add('\"');


7589                            break;


7590                        // reverse solidus


7591                        case '\\':


7592                            add('\\');


7593                            break;


7594                        // solidus


7595                        case '/':


7596                            add('/');


7597                            break;


7598                        // backspace


7599                        case 'b':


7600                            add('\b');


7601                            break;


7602                        // form feed


7603                        case 'f':


7604                            add('\f');


7605                            break;


7606                        // line feed


7607                        case 'n':


7608                            add('\n');


7609                            break;


7610                        // carriage return


7611                        case 'r':


7612                            add('\r');


7613                            break;


7614                        // tab


7615                        case 't':


7616                            add('\t');


7617                            break;


7618


7619                        // unicode escapes


7620                        case 'u':


7621                        {


7622                            const int codepoint1 = get_codepoint();


7623                            int codepoint = codepoint1; // start with codepoint1


7624


7625                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))


7626                            {


7627                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";


7628                                return token_type::parse_error;


7629                            }


7630


7631                            // check if code point is a high surrogate


7632                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)


7633                            {


7634                                // expect next \uxxxx entry


7635                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))


7636                                {


7637                                    const int codepoint2 = get_codepoint();


7638


7639                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))


7640                                    {


7641                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";


7642                                        return token_type::parse_error;


7643                                    }


7644


7645                                    // check if codepoint2 is a low surrogate


7646                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))


7647                                    {


7648                                        // overwrite codepoint


7649                                        codepoint = static_cast<int>(


7650                                                        // high surrogate occupies the most significant 22 bits


7651                                                        (static_cast<unsigned int>(codepoint1) << 10u)


7652                                                        // low surrogate occupies the least significant 15 bits


7653                                                        + static_cast<unsigned int>(codepoint2)


7654                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise


7655                                                        // in the result, so we have to subtract with:


7656                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00


7657                                                        - 0x35FDC00u);


7658                                    }


7659                                    else


7660                                    {


7661                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";


7662                                        return token_type::parse_error;


7663                                    }


7664                                }


7665                                else


7666                                {


7667                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";


7668                                    return token_type::parse_error;


7669                                }


7670                            }


7671                            else


7672                            {


7673                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))


7674                                {


7675                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";


7676                                    return token_type::parse_error;


7677                                }


7678                            }


7679


7680                            // result of the above calculation yields a proper codepoint


7681                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);


7682


7683                            // translate codepoint into bytes


7684                            if (codepoint < 0x80)


7685                            {


7686                                // 1-byte characters: 0xxxxxxx (ASCII)


7687                                add(static_cast<char_int_type>(codepoint));


7688                            }


7689                            else if (codepoint <= 0x7FF)


7690                            {


7691                                // 2-byte characters: 110xxxxx 10xxxxxx


7692                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));


7693                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));


7694                            }


7695                            else if (codepoint <= 0xFFFF)


7696                            {


7697                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx


7698                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));


7699                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));


7700                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));


7701                            }


7702                            else


7703                            {


7704                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx


7705                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));


7706                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));


7707                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));


7708                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));


7709                            }


7710


7711                            break;


7712                        }


7713


7714                        // other characters after escape


7715                        default:


7716                            error_message = "invalid string: forbidden character after backslash";


7717                            return token_type::parse_error;


7718                    }


7719


7720                    break;


7721                }


7722


7723                // invalid control characters


7724                case 0x00:


7725                {


7726                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";


7727                    return token_type::parse_error;


7728                }


7729


7730                case 0x01:


7731                {


7732                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";


7733                    return token_type::parse_error;


7734                }


7735


7736                case 0x02:


7737                {


7738                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";


7739                    return token_type::parse_error;


7740                }


7741


7742                case 0x03:


7743                {


7744                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";


7745                    return token_type::parse_error;


7746                }


7747


7748                case 0x04:


7749                {


7750                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";


7751                    return token_type::parse_error;


7752                }


7753


7754                case 0x05:


7755                {


7756                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";


7757                    return token_type::parse_error;


7758                }


7759


7760                case 0x06:


7761                {


7762                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";


7763                    return token_type::parse_error;


7764                }


7765


7766                case 0x07:


7767                {


7768                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";


7769                    return token_type::parse_error;


7770                }


7771


7772                case 0x08:


7773                {


7774                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";


7775                    return token_type::parse_error;


7776                }


7777


7778                case 0x09:


7779                {


7780                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";


7781                    return token_type::parse_error;


7782                }


7783


7784                case 0x0A:


7785                {


7786                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";


7787                    return token_type::parse_error;


7788                }


7789


7790                case 0x0B:


7791                {


7792                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";


7793                    return token_type::parse_error;


7794                }


7795


7796                case 0x0C:


7797                {


7798                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";


7799                    return token_type::parse_error;


7800                }


7801


7802                case 0x0D:


7803                {


7804                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";


7805                    return token_type::parse_error;


7806                }


7807


7808                case 0x0E:


7809                {


7810                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";


7811                    return token_type::parse_error;


7812                }


7813


7814                case 0x0F:


7815                {


7816                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";


7817                    return token_type::parse_error;


7818                }


7819


7820                case 0x10:


7821                {


7822                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";


7823                    return token_type::parse_error;


7824                }


7825


7826                case 0x11:


7827                {


7828                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";


7829                    return token_type::parse_error;


7830                }


7831


7832                case 0x12:


7833                {


7834                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";


7835                    return token_type::parse_error;


7836                }


7837


7838                case 0x13:


7839                {


7840                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";


7841                    return token_type::parse_error;


7842                }


7843


7844                case 0x14:


7845                {


7846                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";


7847                    return token_type::parse_error;


7848                }


7849


7850                case 0x15:


7851                {


7852                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";


7853                    return token_type::parse_error;


7854                }


7855


7856                case 0x16:


7857                {


7858                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";


7859                    return token_type::parse_error;


7860                }


7861


7862                case 0x17:


7863                {


7864                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";


7865                    return token_type::parse_error;


7866                }


7867


7868                case 0x18:


7869                {


7870                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";


7871                    return token_type::parse_error;


7872                }


7873


7874                case 0x19:


7875                {


7876                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";


7877                    return token_type::parse_error;


7878                }


7879


7880                case 0x1A:


7881                {


7882                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";


7883                    return token_type::parse_error;


7884                }


7885


7886                case 0x1B:


7887                {


7888                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";


7889                    return token_type::parse_error;


7890                }


7891


7892                case 0x1C:


7893                {


7894                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";


7895                    return token_type::parse_error;


7896                }


7897


7898                case 0x1D:


7899                {


7900                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";


7901                    return token_type::parse_error;


7902                }


7903


7904                case 0x1E:


7905                {


7906                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";


7907                    return token_type::parse_error;


7908                }


7909


7910                case 0x1F:


7911                {


7912                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";


7913                    return token_type::parse_error;


7914                }


7915


7916                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))


7917                case 0x20:


7918                case 0x21:


7919                case 0x23:


7920                case 0x24:


7921                case 0x25:


7922                case 0x26:


7923                case 0x27:


7924                case 0x28:


7925                case 0x29:


7926                case 0x2A:


7927                case 0x2B:


7928                case 0x2C:


7929                case 0x2D:


7930                case 0x2E:


7931                case 0x2F:


7932                case 0x30:


7933                case 0x31:


7934                case 0x32:


7935                case 0x33:


7936                case 0x34:


7937                case 0x35:


7938                case 0x36:


7939                case 0x37:


7940                case 0x38:


7941                case 0x39:


7942                case 0x3A:


7943                case 0x3B:


7944                case 0x3C:


7945                case 0x3D:


7946                case 0x3E:


7947                case 0x3F:


7948                case 0x40:


7949                case 0x41:


7950                case 0x42:


7951                case 0x43:


7952                case 0x44:


7953                case 0x45:


7954                case 0x46:


7955                case 0x47:


7956                case 0x48:


7957                case 0x49:


7958                case 0x4A:


7959                case 0x4B:


7960                case 0x4C:


7961                case 0x4D:


7962                case 0x4E:


7963                case 0x4F:


7964                case 0x50:


7965                case 0x51:


7966                case 0x52:


7967                case 0x53:


7968                case 0x54:


7969                case 0x55:


7970                case 0x56:


7971                case 0x57:


7972                case 0x58:


7973                case 0x59:


7974                case 0x5A:


7975                case 0x5B:


7976                case 0x5D:


7977                case 0x5E:


7978                case 0x5F:


7979                case 0x60:


7980                case 0x61:


7981                case 0x62:


7982                case 0x63:


7983                case 0x64:


7984                case 0x65:


7985                case 0x66:


7986                case 0x67:


7987                case 0x68:


7988                case 0x69:


7989                case 0x6A:


7990                case 0x6B:


7991                case 0x6C:


7992                case 0x6D:


7993                case 0x6E:


7994                case 0x6F:


7995                case 0x70:


7996                case 0x71:


7997                case 0x72:


7998                case 0x73:


7999                case 0x74:


8000                case 0x75:


8001                case 0x76:


8002                case 0x77:


8003                case 0x78:


8004                case 0x79:


8005                case 0x7A:


8006                case 0x7B:


8007                case 0x7C:


8008                case 0x7D:


8009                case 0x7E:


8010                case 0x7F:


8011                {


8012                    add(current);


8013                    break;


8014                }


8015


8016                // U+0080..U+07FF: bytes C2..DF 80..BF


8017                case 0xC2:


8018                case 0xC3:


8019                case 0xC4:


8020                case 0xC5:


8021                case 0xC6:


8022                case 0xC7:


8023                case 0xC8:


8024                case 0xC9:


8025                case 0xCA:


8026                case 0xCB:


8027                case 0xCC:


8028                case 0xCD:


8029                case 0xCE:


8030                case 0xCF:


8031                case 0xD0:


8032                case 0xD1:


8033                case 0xD2:


8034                case 0xD3:


8035                case 0xD4:


8036                case 0xD5:


8037                case 0xD6:


8038                case 0xD7:


8039                case 0xD8:


8040                case 0xD9:


8041                case 0xDA:


8042                case 0xDB:


8043                case 0xDC:


8044                case 0xDD:


8045                case 0xDE:


8046                case 0xDF:


8047                {


8048                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))


8049                    {


8050                        return token_type::parse_error;


8051                    }


8052                    break;


8053                }


8054


8055                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF


8056                case 0xE0:


8057                {


8058                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))


8059                    {


8060                        return token_type::parse_error;


8061                    }


8062                    break;


8063                }


8064


8065                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF


8066                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF


8067                case 0xE1:


8068                case 0xE2:


8069                case 0xE3:


8070                case 0xE4:


8071                case 0xE5:


8072                case 0xE6:


8073                case 0xE7:


8074                case 0xE8:


8075                case 0xE9:


8076                case 0xEA:


8077                case 0xEB:


8078                case 0xEC:


8079                case 0xEE:


8080                case 0xEF:


8081                {


8082                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))


8083                    {


8084                        return token_type::parse_error;


8085                    }


8086                    break;


8087                }


8088


8089                // U+D000..U+D7FF: bytes ED 80..9F 80..BF


8090                case 0xED:


8091                {


8092                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))


8093                    {


8094                        return token_type::parse_error;


8095                    }


8096                    break;


8097                }


8098


8099                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF


8100                case 0xF0:


8101                {


8102                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))


8103                    {


8104                        return token_type::parse_error;


8105                    }


8106                    break;


8107                }


8108


8109                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF


8110                case 0xF1:


8111                case 0xF2:


8112                case 0xF3:


8113                {


8114                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))


8115                    {


8116                        return token_type::parse_error;


8117                    }


8118                    break;


8119                }


8120


8121                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF


8122                case 0xF4:


8123                {


8124                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))


8125                    {


8126                        return token_type::parse_error;


8127                    }


8128                    break;


8129                }


8130


8131                // remaining bytes (80..C1 and F5..FF) are ill-formed


8132                default:


8133                {


8134                    error_message = "invalid string: ill-formed UTF-8 byte";


8135                    return token_type::parse_error;


8136                }


8137            }


8138        }


8139    }


8140


8141    /*!


8142     * @brief scan a comment


8143     * @return whether comment could be scanned successfully


8144     */


8145    bool scan_comment()


8146    {


8147        switch (get())


8148        {


8149            // single-line comments skip input until a newline or EOF is read


8150            case '/':


8151            {


8152                while (true)


8153                {


8154                    switch (get())


8155                    {


8156                        case '\n':


8157                        case '\r':


8158                        case std::char_traits<char_type>::eof():


8159                        case '\0':


8160                            return true;


8161


8162                        default:


8163                            break;


8164                    }


8165                }


8166            }


8167


8168            // multi-line comments skip input until */ is read


8169            case '*':


8170            {


8171                while (true)


8172                {


8173                    switch (get())


8174                    {


8175                        case std::char_traits<char_type>::eof():


8176                        case '\0':


8177                        {


8178                            error_message = "invalid comment; missing closing '*/'";


8179                            return false;


8180                        }


8181


8182                        case '*':


8183                        {


8184                            switch (get())


8185                            {


8186                                case '/':


8187                                    return true;


8188


8189                                default:


8190                                {


8191                                    unget();


8192                                    continue;


8193                                }


8194                            }


8195                        }


8196


8197                        default:


8198                            continue;


8199                    }


8200                }


8201            }


8202


8203            // unexpected character after reading '/'


8204            default:


8205            {


8206                error_message = "invalid comment; expecting '/' or '*' after '/'";


8207                return false;


8208            }


8209        }


8210    }


8211


8212    JSON_HEDLEY_NON_NULL(2)


8213    static void strtof(float& f, const char* str, char** endptr) noexcept


8214    {


8215        f = std::strtof(str, endptr);


8216    }


8217


8218    JSON_HEDLEY_NON_NULL(2)


8219    static void strtof(double& f, const char* str, char** endptr) noexcept


8220    {


8221        f = std::strtod(str, endptr);


8222    }


8223


8224    JSON_HEDLEY_NON_NULL(2)


8225    static void strtof(long double& f, const char* str, char** endptr) noexcept


8226    {


8227        f = std::strtold(str, endptr);


8228    }


8229


8230    /*!


8231    @brief scan a number literal


8232


8233    This function scans a string according to Sect. 6 of RFC 8259.


8234


8235    The function is realized with a deterministic finite state machine derived


8236    from the grammar described in RFC 8259. Starting in state "init", the


8237    input is read and used to determined the next state. Only state "done"


8238    accepts the number. State "error" is a trap state to model errors. In the


8239    table below, "anything" means any character but the ones listed before.


8240


8241    state    | 0        | 1-9      | e E      | +       | -       | .        | anything


8242    ---------|----------|----------|----------|---------|---------|----------|-----------


8243    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]


8244    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]


8245    zero     | done     | done     | exponent | done    | done    | decimal1 | done


8246    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done


8247    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]


8248    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done


8249    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]


8250    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]


8251    any2     | any2     | any2     | done     | done    | done    | done     | done


8252


8253    The state machine is realized with one label per state (prefixed with


8254    "scan_number_") and `goto` statements between them. The state machine


8255    contains cycles, but any cycle can be left when EOF is read. Therefore,


8256    the function is guaranteed to terminate.


8257


8258    During scanning, the read bytes are stored in token_buffer. This string is


8259    then converted to a signed integer, an unsigned integer, or a


8260    floating-point number.


8261


8262    @return token_type::value_unsigned, token_type::value_integer, or


8263            token_type::value_float if number could be successfully scanned,


8264            token_type::parse_error otherwise


8265


8266    @note The scanner is independent of the current locale. Internally, the


8267          locale's decimal point is used instead of `.` to work with the


8268          locale-dependent converters.


8269    */


8270    token_type scan_number()  // lgtm [cpp/use-of-goto]


8271    {


8272        // reset token_buffer to store the number's bytes


8273        reset();


8274


8275        // the type of the parsed number; initially set to unsigned; will be


8276        // changed if minus sign, decimal point or exponent is read


8277        token_type number_type = token_type::value_unsigned;


8278


8279        // state (init): we just found out we need to scan a number


8280        switch (current)


8281        {


8282            case '-':


8283            {


8284                add(current);


8285                goto scan_number_minus;


8286            }


8287


8288            case '0':


8289            {


8290                add(current);


8291                goto scan_number_zero;


8292            }


8293


8294            case '1':


8295            case '2':


8296            case '3':


8297            case '4':


8298            case '5':


8299            case '6':


8300            case '7':


8301            case '8':


8302            case '9':


8303            {


8304                add(current);


8305                goto scan_number_any1;


8306            }


8307


8308            // all other characters are rejected outside scan_number()


8309            default:            // LCOV_EXCL_LINE


8310                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


8311        }


8312


8313scan_number_minus:


8314        // state: we just parsed a leading minus sign


8315        number_type = token_type::value_integer;


8316        switch (get())


8317        {


8318            case '0':


8319            {


8320                add(current);


8321                goto scan_number_zero;


8322            }


8323


8324            case '1':


8325            case '2':


8326            case '3':


8327            case '4':


8328            case '5':


8329            case '6':


8330            case '7':


8331            case '8':


8332            case '9':


8333            {


8334                add(current);


8335                goto scan_number_any1;


8336            }


8337


8338            default:


8339            {


8340                error_message = "invalid number; expected digit after '-'";


8341                return token_type::parse_error;


8342            }


8343        }


8344


8345scan_number_zero:


8346        // state: we just parse a zero (maybe with a leading minus sign)


8347        switch (get())


8348        {


8349            case '.':


8350            {


8351                add(decimal_point_char);


8352                goto scan_number_decimal1;


8353            }


8354


8355            case 'e':


8356            case 'E':


8357            {


8358                add(current);


8359                goto scan_number_exponent;


8360            }


8361


8362            default:


8363                goto scan_number_done;


8364        }


8365


8366scan_number_any1:


8367        // state: we just parsed a number 0-9 (maybe with a leading minus sign)


8368        switch (get())


8369        {


8370            case '0':


8371            case '1':


8372            case '2':


8373            case '3':


8374            case '4':


8375            case '5':


8376            case '6':


8377            case '7':


8378            case '8':


8379            case '9':


8380            {


8381                add(current);


8382                goto scan_number_any1;


8383            }


8384


8385            case '.':


8386            {


8387                add(decimal_point_char);


8388                goto scan_number_decimal1;


8389            }


8390


8391            case 'e':


8392            case 'E':


8393            {


8394                add(current);


8395                goto scan_number_exponent;


8396            }


8397


8398            default:


8399                goto scan_number_done;


8400        }


8401


8402scan_number_decimal1:


8403        // state: we just parsed a decimal point


8404        number_type = token_type::value_float;


8405        switch (get())


8406        {


8407            case '0':


8408            case '1':


8409            case '2':


8410            case '3':


8411            case '4':


8412            case '5':


8413            case '6':


8414            case '7':


8415            case '8':


8416            case '9':


8417            {


8418                add(current);


8419                goto scan_number_decimal2;


8420            }


8421


8422            default:


8423            {


8424                error_message = "invalid number; expected digit after '.'";


8425                return token_type::parse_error;


8426            }


8427        }


8428


8429scan_number_decimal2:


8430        // we just parsed at least one number after a decimal point


8431        switch (get())


8432        {


8433            case '0':


8434            case '1':


8435            case '2':


8436            case '3':


8437            case '4':


8438            case '5':


8439            case '6':


8440            case '7':


8441            case '8':


8442            case '9':


8443            {


8444                add(current);


8445                goto scan_number_decimal2;


8446            }


8447


8448            case 'e':


8449            case 'E':


8450            {


8451                add(current);


8452                goto scan_number_exponent;


8453            }


8454


8455            default:


8456                goto scan_number_done;


8457        }


8458


8459scan_number_exponent:


8460        // we just parsed an exponent


8461        number_type = token_type::value_float;


8462        switch (get())


8463        {


8464            case '+':


8465            case '-':


8466            {


8467                add(current);


8468                goto scan_number_sign;


8469            }


8470


8471            case '0':


8472            case '1':


8473            case '2':


8474            case '3':


8475            case '4':


8476            case '5':


8477            case '6':


8478            case '7':


8479            case '8':


8480            case '9':


8481            {


8482                add(current);


8483                goto scan_number_any2;


8484            }


8485


8486            default:


8487            {


8488                error_message =


8489                    "invalid number; expected '+', '-', or digit after exponent";


8490                return token_type::parse_error;


8491            }


8492        }


8493


8494scan_number_sign:


8495        // we just parsed an exponent sign


8496        switch (get())


8497        {


8498            case '0':


8499            case '1':


8500            case '2':


8501            case '3':


8502            case '4':


8503            case '5':


8504            case '6':


8505            case '7':


8506            case '8':


8507            case '9':


8508            {


8509                add(current);


8510                goto scan_number_any2;


8511            }


8512


8513            default:


8514            {


8515                error_message = "invalid number; expected digit after exponent sign";


8516                return token_type::parse_error;


8517            }


8518        }


8519


8520scan_number_any2:


8521        // we just parsed a number after the exponent or exponent sign


8522        switch (get())


8523        {


8524            case '0':


8525            case '1':


8526            case '2':


8527            case '3':


8528            case '4':


8529            case '5':


8530            case '6':


8531            case '7':


8532            case '8':


8533            case '9':


8534            {


8535                add(current);


8536                goto scan_number_any2;


8537            }


8538


8539            default:


8540                goto scan_number_done;


8541        }


8542


8543scan_number_done:


8544        // unget the character after the number (we only read it to know that


8545        // we are done scanning a number)


8546        unget();


8547


8548        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


8549        errno = 0;


8550


8551        // try to parse integers first and fall back to floats


8552        if (number_type == token_type::value_unsigned)


8553        {


8554            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);


8555


8556            // we checked the number format before


8557            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());


8558


8559            if (errno == 0)


8560            {


8561                value_unsigned = static_cast<number_unsigned_t>(x);


8562                if (value_unsigned == x)


8563                {


8564                    return token_type::value_unsigned;


8565                }


8566            }


8567        }


8568        else if (number_type == token_type::value_integer)


8569        {


8570            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);


8571


8572            // we checked the number format before


8573            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());


8574


8575            if (errno == 0)


8576            {


8577                value_integer = static_cast<number_integer_t>(x);


8578                if (value_integer == x)


8579                {


8580                    return token_type::value_integer;


8581                }


8582            }


8583        }


8584


8585        // this code is reached if we parse a floating-point number or if an


8586        // integer conversion above failed


8587        strtof(value_float, token_buffer.data(), &endptr);


8588


8589        // we checked the number format before


8590        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());


8591


8592        return token_type::value_float;


8593    }


8594


8595    /*!


8596    @param[in] literal_text  the literal text to expect


8597    @param[in] length        the length of the passed literal text


8598    @param[in] return_type   the token type to return on success


8599    */


8600    JSON_HEDLEY_NON_NULL(2)


8601    token_type scan_literal(const char_type* literal_text, const std::size_t length,


8602                            token_type return_type)


8603    {


8604        JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);


8605        for (std::size_t i = 1; i < length; ++i)


8606        {


8607            if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))


8608            {


8609                error_message = "invalid literal";


8610                return token_type::parse_error;


8611            }


8612        }


8613        return return_type;


8614    }


8615


8616    /////////////////////


8617    // input management


8618    /////////////////////


8619


8620    /// reset token_buffer; current character is beginning of token


8621    void reset() noexcept


8622    {


8623        token_buffer.clear();


8624        token_string.clear();


8625        token_string.push_back(std::char_traits<char_type>::to_char_type(current));


8626    }


8627


8628    /*


8629    @brief get next character from the input


8630


8631    This function provides the interface to the used input adapter. It does


8632    not throw in case the input reached EOF, but returns a


8633    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters


8634    for use in error messages.


8635


8636    @return character read from the input


8637    */


8638    char_int_type get()


8639    {


8640        ++position.chars_read_total;


8641        ++position.chars_read_current_line;


8642


8643        if (next_unget)


8644        {


8645            // just reset the next_unget variable and work with current


8646            next_unget = false;


8647        }


8648        else


8649        {


8650            current = ia.get_character();


8651        }


8652


8653        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))


8654        {


8655            token_string.push_back(std::char_traits<char_type>::to_char_type(current));


8656        }


8657


8658        if (current == '\n')


8659        {


8660            ++position.lines_read;


8661            position.chars_read_current_line = 0;


8662        }


8663


8664        return current;


8665    }


8666


8667    /*!


8668    @brief unget current character (read it again on next get)


8669


8670    We implement unget by setting variable next_unget to true. The input is not


8671    changed - we just simulate ungetting by modifying chars_read_total,


8672    chars_read_current_line, and token_string. The next call to get() will


8673    behave as if the unget character is read again.


8674    */


8675    void unget()


8676    {


8677        next_unget = true;


8678


8679        --position.chars_read_total;


8680


8681        // in case we "unget" a newline, we have to also decrement the lines_read


8682        if (position.chars_read_current_line == 0)


8683        {


8684            if (position.lines_read > 0)


8685            {


8686                --position.lines_read;


8687            }


8688        }


8689        else


8690        {


8691            --position.chars_read_current_line;


8692        }


8693


8694        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))


8695        {


8696            JSON_ASSERT(!token_string.empty());


8697            token_string.pop_back();


8698        }


8699    }


8700


8701    /// add a character to token_buffer


8702    void add(char_int_type c)


8703    {


8704        token_buffer.push_back(static_cast<typename string_t::value_type>(c));


8705    }


8706


8707  public:


8708    /////////////////////


8709    // value getters


8710    /////////////////////


8711


8712    /// return integer value


8713    constexpr number_integer_t get_number_integer() const noexcept


8714    {


8715        return value_integer;


8716    }


8717


8718    /// return unsigned integer value


8719    constexpr number_unsigned_t get_number_unsigned() const noexcept


8720    {


8721        return value_unsigned;


8722    }


8723


8724    /// return floating-point value


8725    constexpr number_float_t get_number_float() const noexcept


8726    {


8727        return value_float;


8728    }


8729


8730    /// return current string value (implicitly resets the token; useful only once)


8731    string_t& get_string()


8732    {


8733        return token_buffer;


8734    }


8735


8736    /////////////////////


8737    // diagnostics


8738    /////////////////////


8739


8740    /// return position of last read token


8741    constexpr position_t get_position() const noexcept


8742    {


8743        return position;


8744    }


8745


8746    /// return the last read token (for errors only).  Will never contain EOF


8747    /// (an arbitrary value that is not a valid char value, often -1), because


8748    /// 255 may legitimately occur.  May contain NUL, which should be escaped.


8749    std::string get_token_string() const


8750    {


8751        // escape control characters


8752        std::string result;


8753        for (const auto c : token_string)


8754        {


8755            if (static_cast<unsigned char>(c) <= '\x1F')


8756            {


8757                // escape control characters


8758                std::array<char, 9> cs{{}};


8759                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


8760                result += cs.data();


8761            }


8762            else


8763            {


8764                // add character as is


8765                result.push_back(static_cast<std::string::value_type>(c));


8766            }


8767        }


8768


8769        return result;


8770    }


8771


8772    /// return syntax error message


8773    JSON_HEDLEY_RETURNS_NON_NULL


8774    constexpr const char* get_error_message() const noexcept


8775    {


8776        return error_message;


8777    }


8778


8779    /////////////////////


8780    // actual scanner


8781    /////////////////////


8782


8783    /*!


8784    @brief skip the UTF-8 byte order mark


8785    @return true iff there is no BOM or the correct BOM has been skipped


8786    */


8787    bool skip_bom()


8788    {


8789        if (get() == 0xEF)


8790        {


8791            // check if we completely parse the BOM


8792            return get() == 0xBB && get() == 0xBF;


8793        }


8794


8795        // the first character is not the beginning of the BOM; unget it to


8796        // process is later


8797        unget();


8798        return true;


8799    }


8800


8801    void skip_whitespace()


8802    {


8803        do


8804        {


8805            get();


8806        }


8807        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');


8808    }


8809


8810    token_type scan()


8811    {


8812        // initially, skip the BOM


8813        if (position.chars_read_total == 0 && !skip_bom())


8814        {


8815            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";


8816            return token_type::parse_error;


8817        }


8818


8819        // read next character and ignore whitespace


8820        skip_whitespace();


8821


8822        // ignore comments


8823        while (ignore_comments && current == '/')


8824        {


8825            if (!scan_comment())


8826            {


8827                return token_type::parse_error;


8828            }


8829


8830            // skip following whitespace


8831            skip_whitespace();


8832        }


8833


8834        switch (current)


8835        {


8836            // structural characters


8837            case '[':


8838                return token_type::begin_array;


8839            case ']':


8840                return token_type::end_array;


8841            case '{':


8842                return token_type::begin_object;


8843            case '}':


8844                return token_type::end_object;


8845            case ':':


8846                return token_type::name_separator;


8847            case ',':


8848                return token_type::value_separator;


8849


8850            // literals


8851            case 't':


8852            {


8853                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')}};


8854                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);


8855            }


8856            case 'f':


8857            {


8858                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')}};


8859                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);


8860            }


8861            case 'n':


8862            {


8863                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')}};


8864                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);


8865            }


8866


8867            // string


8868            case '\"':


8869                return scan_string();


8870


8871            // number


8872            case '-':


8873            case '0':


8874            case '1':


8875            case '2':


8876            case '3':


8877            case '4':


8878            case '5':


8879            case '6':


8880            case '7':


8881            case '8':


8882            case '9':


8883                return scan_number();


8884


8885            // end of input (the null byte is needed when parsing from


8886            // string literals)


8887            case '\0':


8888            case std::char_traits<char_type>::eof():


8889                return token_type::end_of_input;


8890


8891            // error


8892            default:


8893                error_message = "invalid literal";


8894                return token_type::parse_error;


8895        }


8896    }


8897


8898  private:


8899    /// input adapter


8900    InputAdapterType ia;


8901


8902    /// whether comments should be ignored (true) or signaled as errors (false)


8903    const bool ignore_comments = false;


8904


8905    /// the current character


8906    char_int_type current = std::char_traits<char_type>::eof();


8907


8908    /// whether the next get() call should just return current


8909    bool next_unget = false;


8910


8911    /// the start position of the current token


8912    position_t position {};


8913


8914    /// raw input token string (for error messages)


8915    std::vector<char_type> token_string {};


8916


8917    /// buffer for variable-length tokens (numbers, strings)


8918    string_t token_buffer {};


8919


8920    /// a description of occurred lexer errors


8921    const char* error_message = "";


8922


8923    // number values


8924    number_integer_t value_integer = 0;


8925    number_unsigned_t value_unsigned = 0;


8926    number_float_t value_float = 0;


8927


8928    /// the decimal point


8929    const char_int_type decimal_point_char = '.';


8930};


8931


8932}  // namespace detail


8933NLOHMANN_JSON_NAMESPACE_END


8934


8935// #include <nlohmann/detail/macro_scope.hpp>


8936


8937// #include <nlohmann/detail/meta/is_sax.hpp>


8938//     __ _____ _____ _____


8939//  __|  |   __|     |   | |  JSON for Modern C++


8940// |  |  |__   |  |  | | | |  version 3.11.2


8941// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


8942//


8943// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


8944// SPDX-License-Identifier: MIT


8945


8946


8947


8948#include <cstdint> // size_t


8949#include <utility> // declval


8950#include <string> // string


8951


8952// #include <nlohmann/detail/abi_macros.hpp>


8953


8954// #include <nlohmann/detail/meta/detected.hpp>


8955


8956// #include <nlohmann/detail/meta/type_traits.hpp>


8957


8958


8959NLOHMANN_JSON_NAMESPACE_BEGIN


8960namespace detail


8961{


8962


8963template<typename T>


8964using null_function_t = decltype(std::declval<T&>().null());


8965


8966template<typename T>


8967using boolean_function_t =


8968    decltype(std::declval<T&>().boolean(std::declval<bool>()));


8969


8970template<typename T, typename Integer>


8971using number_integer_function_t =


8972    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));


8973


8974template<typename T, typename Unsigned>


8975using number_unsigned_function_t =


8976    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));


8977


8978template<typename T, typename Float, typename String>


8979using number_float_function_t = decltype(std::declval<T&>().number_float(


8980                                    std::declval<Float>(), std::declval<const String&>()));


8981


8982template<typename T, typename String>


8983using string_function_t =


8984    decltype(std::declval<T&>().string(std::declval<String&>()));


8985


8986template<typename T, typename Binary>


8987using binary_function_t =


8988    decltype(std::declval<T&>().binary(std::declval<Binary&>()));


8989


8990template<typename T>


8991using start_object_function_t =


8992    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));


8993


8994template<typename T, typename String>


8995using key_function_t =


8996    decltype(std::declval<T&>().key(std::declval<String&>()));


8997


8998template<typename T>


8999using end_object_function_t = decltype(std::declval<T&>().end_object());


9000


9001template<typename T>


9002using start_array_function_t =


9003    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));


9004


9005template<typename T>


9006using end_array_function_t = decltype(std::declval<T&>().end_array());


9007


9008template<typename T, typename Exception>


9009using parse_error_function_t = decltype(std::declval<T&>().parse_error(


9010        std::declval<std::size_t>(), std::declval<const std::string&>(),


9011        std::declval<const Exception&>()));


9012


9013template<typename SAX, typename BasicJsonType>


9014struct is_sax


9015{


9016  private:


9017    static_assert(is_basic_json<BasicJsonType>::value,


9018                  "BasicJsonType must be of type basic_json<...>");


9019


9020    using number_integer_t = typename BasicJsonType::number_integer_t;


9021    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


9022    using number_float_t = typename BasicJsonType::number_float_t;


9023    using string_t = typename BasicJsonType::string_t;


9024    using binary_t = typename BasicJsonType::binary_t;


9025    using exception_t = typename BasicJsonType::exception;


9026


9027  public:


9028    static constexpr bool value =


9029        is_detected_exact<bool, null_function_t, SAX>::value &&


9030        is_detected_exact<bool, boolean_function_t, SAX>::value &&


9031        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&


9032        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&


9033        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&


9034        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&


9035        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&


9036        is_detected_exact<bool, start_object_function_t, SAX>::value &&


9037        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&


9038        is_detected_exact<bool, end_object_function_t, SAX>::value &&


9039        is_detected_exact<bool, start_array_function_t, SAX>::value &&


9040        is_detected_exact<bool, end_array_function_t, SAX>::value &&


9041        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;


9042};


9043


9044template<typename SAX, typename BasicJsonType>


9045struct is_sax_static_asserts


9046{


9047  private:


9048    static_assert(is_basic_json<BasicJsonType>::value,


9049                  "BasicJsonType must be of type basic_json<...>");


9050


9051    using number_integer_t = typename BasicJsonType::number_integer_t;


9052    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


9053    using number_float_t = typename BasicJsonType::number_float_t;


9054    using string_t = typename BasicJsonType::string_t;


9055    using binary_t = typename BasicJsonType::binary_t;


9056    using exception_t = typename BasicJsonType::exception;


9057


9058  public:


9059    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,


9060                  "Missing/invalid function: bool null()");


9061    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,


9062                  "Missing/invalid function: bool boolean(bool)");


9063    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,


9064                  "Missing/invalid function: bool boolean(bool)");


9065    static_assert(


9066        is_detected_exact<bool, number_integer_function_t, SAX,


9067        number_integer_t>::value,


9068        "Missing/invalid function: bool number_integer(number_integer_t)");


9069    static_assert(


9070        is_detected_exact<bool, number_unsigned_function_t, SAX,


9071        number_unsigned_t>::value,


9072        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");


9073    static_assert(is_detected_exact<bool, number_float_function_t, SAX,


9074                  number_float_t, string_t>::value,


9075                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");


9076    static_assert(


9077        is_detected_exact<bool, string_function_t, SAX, string_t>::value,


9078        "Missing/invalid function: bool string(string_t&)");


9079    static_assert(


9080        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,


9081        "Missing/invalid function: bool binary(binary_t&)");


9082    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,


9083                  "Missing/invalid function: bool start_object(std::size_t)");


9084    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,


9085                  "Missing/invalid function: bool key(string_t&)");


9086    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,


9087                  "Missing/invalid function: bool end_object()");


9088    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,


9089                  "Missing/invalid function: bool start_array(std::size_t)");


9090    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,


9091                  "Missing/invalid function: bool end_array()");


9092    static_assert(


9093        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,


9094        "Missing/invalid function: bool parse_error(std::size_t, const "


9095        "std::string&, const exception&)");


9096};


9097


9098}  // namespace detail


9099NLOHMANN_JSON_NAMESPACE_END


9100


9101// #include <nlohmann/detail/meta/type_traits.hpp>


9102


9103// #include <nlohmann/detail/string_concat.hpp>


9104


9105// #include <nlohmann/detail/value_t.hpp>


9106


9107


9108NLOHMANN_JSON_NAMESPACE_BEGIN


9109namespace detail


9110{


9111


9112/// how to treat CBOR tags


9113enum class cbor_tag_handler_t


9114{


9115    error,   ///< throw a parse_error exception in case of a tag


9116    ignore,  ///< ignore tags


9117    store    ///< store tags as binary type


9118};


9119


9120/*!


9121@brief determine system byte order


9122


9123@return true if and only if system's byte order is little endian


9124


9125@note from https://stackoverflow.com/a/1001328/266378


9126*/


9127static inline bool little_endianness(int num = 1) noexcept


9128{


9129    return *reinterpret_cast<char*>(&num) == 1;


9130}


9131


9132


9133///////////////////


9134// binary reader //


9135///////////////////


9136


9137/*!


9138@brief deserialization of CBOR, MessagePack, and UBJSON values


9139*/


9140template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>


9141class binary_reader


9142{


9143    using number_integer_t = typename BasicJsonType::number_integer_t;


9144    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


9145    using number_float_t = typename BasicJsonType::number_float_t;


9146    using string_t = typename BasicJsonType::string_t;


9147    using binary_t = typename BasicJsonType::binary_t;


9148    using json_sax_t = SAX;


9149    using char_type = typename InputAdapterType::char_type;


9150    using char_int_type = typename std::char_traits<char_type>::int_type;


9151


9152  public:


9153    /*!


9154    @brief create a binary reader


9155


9156    @param[in] adapter  input adapter to read from


9157    */


9158    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)


9159    {


9160        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};


9161    }


9162


9163    // make class move-only


9164    binary_reader(const binary_reader&) = delete;


9165    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


9166    binary_reader& operator=(const binary_reader&) = delete;


9167    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)


9168    ~binary_reader() = default;


9169


9170    /*!


9171    @param[in] format  the binary format to parse


9172    @param[in] sax_    a SAX event processor


9173    @param[in] strict  whether to expect the input to be consumed completed


9174    @param[in] tag_handler  how to treat CBOR tags


9175


9176    @return whether parsing was successful


9177    */


9178    JSON_HEDLEY_NON_NULL(3)


9179    bool sax_parse(const input_format_t format,


9180                   json_sax_t* sax_,


9181                   const bool strict = true,


9182                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)


9183    {


9184        sax = sax_;


9185        bool result = false;


9186


9187        switch (format)


9188        {


9189            case input_format_t::bson:


9190                result = parse_bson_internal();


9191                break;


9192


9193            case input_format_t::cbor:


9194                result = parse_cbor_internal(true, tag_handler);


9195                break;


9196


9197            case input_format_t::msgpack:


9198                result = parse_msgpack_internal();


9199                break;


9200


9201            case input_format_t::ubjson:


9202            case input_format_t::bjdata:


9203                result = parse_ubjson_internal();


9204                break;


9205


9206            case input_format_t::json: // LCOV_EXCL_LINE


9207            default:            // LCOV_EXCL_LINE


9208                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


9209        }


9210


9211        // strict mode: next byte must be EOF


9212        if (result && strict)


9213        {


9214            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)


9215            {


9216                get_ignore_noop();


9217            }


9218            else


9219            {


9220                get();


9221            }


9222


9223            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))


9224            {


9225                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,


9226                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));


9227            }


9228        }


9229


9230        return result;


9231    }


9232


9233  private:


9234    //////////


9235    // BSON //


9236    //////////


9237


9238    /*!


9239    @brief Reads in a BSON-object and passes it to the SAX-parser.


9240    @return whether a valid BSON-value was passed to the SAX parser


9241    */


9242    bool parse_bson_internal()


9243    {


9244        std::int32_t document_size{};


9245        get_number<std::int32_t, true>(input_format_t::bson, document_size);


9246


9247        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))


9248        {


9249            return false;


9250        }


9251


9252        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))


9253        {


9254            return false;


9255        }


9256


9257        return sax->end_object();


9258    }


9259


9260    /*!


9261    @brief Parses a C-style string from the BSON input.


9262    @param[in,out] result  A reference to the string variable where the read


9263                            string is to be stored.


9264    @return `true` if the \x00-byte indicating the end of the string was


9265             encountered before the EOF; false` indicates an unexpected EOF.


9266    */


9267    bool get_bson_cstr(string_t& result)


9268    {


9269        auto out = std::back_inserter(result);


9270        while (true)


9271        {


9272            get();


9273            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))


9274            {


9275                return false;


9276            }


9277            if (current == 0x00)


9278            {


9279                return true;


9280            }


9281            *out++ = static_cast<typename string_t::value_type>(current);


9282        }


9283    }


9284


9285    /*!


9286    @brief Parses a zero-terminated string of length @a len from the BSON


9287           input.


9288    @param[in] len  The length (including the zero-byte at the end) of the


9289                    string to be read.


9290    @param[in,out] result  A reference to the string variable where the read


9291                            string is to be stored.


9292    @tparam NumberType The type of the length @a len


9293    @pre len >= 1


9294    @return `true` if the string was successfully parsed


9295    */


9296    template<typename NumberType>


9297    bool get_bson_string(const NumberType len, string_t& result)


9298    {


9299        if (JSON_HEDLEY_UNLIKELY(len < 1))


9300        {


9301            auto last_token = get_token_string();


9302            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


9303                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));


9304        }


9305


9306        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();


9307    }


9308


9309    /*!


9310    @brief Parses a byte array input of length @a len from the BSON input.


9311    @param[in] len  The length of the byte array to be read.


9312    @param[in,out] result  A reference to the binary variable where the read


9313                            array is to be stored.


9314    @tparam NumberType The type of the length @a len


9315    @pre len >= 0


9316    @return `true` if the byte array was successfully parsed


9317    */


9318    template<typename NumberType>


9319    bool get_bson_binary(const NumberType len, binary_t& result)


9320    {


9321        if (JSON_HEDLEY_UNLIKELY(len < 0))


9322        {


9323            auto last_token = get_token_string();


9324            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


9325                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));


9326        }


9327


9328        // All BSON binary values have a subtype


9329        std::uint8_t subtype{};


9330        get_number<std::uint8_t>(input_format_t::bson, subtype);


9331        result.set_subtype(subtype);


9332


9333        return get_binary(input_format_t::bson, len, result);


9334    }


9335


9336    /*!


9337    @brief Read a BSON document element of the given @a element_type.


9338    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html


9339    @param[in] element_type_parse_position The position in the input stream,


9340               where the `element_type` was read.


9341    @warning Not all BSON element types are supported yet. An unsupported


9342             @a element_type will give rise to a parse_error.114:


9343             Unsupported BSON record type 0x...


9344    @return whether a valid BSON-object/array was passed to the SAX parser


9345    */


9346    bool parse_bson_element_internal(const char_int_type element_type,


9347                                     const std::size_t element_type_parse_position)


9348    {


9349        switch (element_type)


9350        {


9351            case 0x01: // double


9352            {


9353                double number{};


9354                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");


9355            }


9356


9357            case 0x02: // string


9358            {


9359                std::int32_t len{};


9360                string_t value;


9361                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);


9362            }


9363


9364            case 0x03: // object


9365            {


9366                return parse_bson_internal();


9367            }


9368


9369            case 0x04: // array


9370            {


9371                return parse_bson_array();


9372            }


9373


9374            case 0x05: // binary


9375            {


9376                std::int32_t len{};


9377                binary_t value;


9378                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);


9379            }


9380


9381            case 0x08: // boolean


9382            {


9383                return sax->boolean(get() != 0);


9384            }


9385


9386            case 0x0A: // null


9387            {


9388                return sax->null();


9389            }


9390


9391            case 0x10: // int32


9392            {


9393                std::int32_t value{};


9394                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);


9395            }


9396


9397            case 0x12: // int64


9398            {


9399                std::int64_t value{};


9400                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);


9401            }


9402


9403            default: // anything else not supported (yet)


9404            {


9405                std::array<char, 3> cr{{}};


9406                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


9407                std::string cr_str{cr.data()};


9408                return sax->parse_error(element_type_parse_position, cr_str,


9409                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));


9410            }


9411        }


9412    }


9413


9414    /*!


9415    @brief Read a BSON element list (as specified in the BSON-spec)


9416


9417    The same binary layout is used for objects and arrays, hence it must be


9418    indicated with the argument @a is_array which one is expected


9419    (true --> array, false --> object).


9420


9421    @param[in] is_array Determines if the element list being read is to be


9422                        treated as an object (@a is_array == false), or as an


9423                        array (@a is_array == true).


9424    @return whether a valid BSON-object/array was passed to the SAX parser


9425    */


9426    bool parse_bson_element_list(const bool is_array)


9427    {


9428        string_t key;


9429


9430        while (auto element_type = get())


9431        {


9432            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))


9433            {


9434                return false;


9435            }


9436


9437            const std::size_t element_type_parse_position = chars_read;


9438            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))


9439            {


9440                return false;


9441            }


9442


9443            if (!is_array && !sax->key(key))


9444            {


9445                return false;


9446            }


9447


9448            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))


9449            {


9450                return false;


9451            }


9452


9453            // get_bson_cstr only appends


9454            key.clear();


9455        }


9456


9457        return true;


9458    }


9459


9460    /*!


9461    @brief Reads an array from the BSON input and passes it to the SAX-parser.


9462    @return whether a valid BSON-array was passed to the SAX parser


9463    */


9464    bool parse_bson_array()


9465    {


9466        std::int32_t document_size{};


9467        get_number<std::int32_t, true>(input_format_t::bson, document_size);


9468


9469        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))


9470        {


9471            return false;


9472        }


9473


9474        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))


9475        {


9476            return false;


9477        }


9478


9479        return sax->end_array();


9480    }


9481


9482    //////////


9483    // CBOR //


9484    //////////


9485


9486    /*!


9487    @param[in] get_char  whether a new character should be retrieved from the


9488                         input (true) or whether the last read character should


9489                         be considered instead (false)


9490    @param[in] tag_handler how CBOR tags should be treated


9491


9492    @return whether a valid CBOR value was passed to the SAX parser


9493    */


9494    bool parse_cbor_internal(const bool get_char,


9495                             const cbor_tag_handler_t tag_handler)


9496    {


9497        switch (get_char ? get() : current)


9498        {


9499            // EOF


9500            case std::char_traits<char_type>::eof():


9501                return unexpect_eof(input_format_t::cbor, "value");


9502


9503            // Integer 0x00..0x17 (0..23)


9504            case 0x00:


9505            case 0x01:


9506            case 0x02:


9507            case 0x03:


9508            case 0x04:


9509            case 0x05:


9510            case 0x06:


9511            case 0x07:


9512            case 0x08:


9513            case 0x09:


9514            case 0x0A:


9515            case 0x0B:


9516            case 0x0C:


9517            case 0x0D:


9518            case 0x0E:


9519            case 0x0F:


9520            case 0x10:


9521            case 0x11:


9522            case 0x12:


9523            case 0x13:


9524            case 0x14:


9525            case 0x15:


9526            case 0x16:


9527            case 0x17:


9528                return sax->number_unsigned(static_cast<number_unsigned_t>(current));


9529


9530            case 0x18: // Unsigned integer (one-byte uint8_t follows)


9531            {


9532                std::uint8_t number{};


9533                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);


9534            }


9535


9536            case 0x19: // Unsigned integer (two-byte uint16_t follows)


9537            {


9538                std::uint16_t number{};


9539                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);


9540            }


9541


9542            case 0x1A: // Unsigned integer (four-byte uint32_t follows)


9543            {


9544                std::uint32_t number{};


9545                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);


9546            }


9547


9548            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)


9549            {


9550                std::uint64_t number{};


9551                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);


9552            }


9553


9554            // Negative integer -1-0x00..-1-0x17 (-1..-24)


9555            case 0x20:


9556            case 0x21:


9557            case 0x22:


9558            case 0x23:


9559            case 0x24:


9560            case 0x25:


9561            case 0x26:


9562            case 0x27:


9563            case 0x28:


9564            case 0x29:


9565            case 0x2A:


9566            case 0x2B:


9567            case 0x2C:


9568            case 0x2D:


9569            case 0x2E:


9570            case 0x2F:


9571            case 0x30:


9572            case 0x31:


9573            case 0x32:


9574            case 0x33:


9575            case 0x34:


9576            case 0x35:


9577            case 0x36:


9578            case 0x37:


9579                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));


9580


9581            case 0x38: // Negative integer (one-byte uint8_t follows)


9582            {


9583                std::uint8_t number{};


9584                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);


9585            }


9586


9587            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)


9588            {


9589                std::uint16_t number{};


9590                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);


9591            }


9592


9593            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)


9594            {


9595                std::uint32_t number{};


9596                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);


9597            }


9598


9599            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)


9600            {


9601                std::uint64_t number{};


9602                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)


9603                        - static_cast<number_integer_t>(number));


9604            }


9605


9606            // Binary data (0x00..0x17 bytes follow)


9607            case 0x40:


9608            case 0x41:


9609            case 0x42:


9610            case 0x43:


9611            case 0x44:


9612            case 0x45:


9613            case 0x46:


9614            case 0x47:


9615            case 0x48:


9616            case 0x49:


9617            case 0x4A:


9618            case 0x4B:


9619            case 0x4C:


9620            case 0x4D:


9621            case 0x4E:


9622            case 0x4F:


9623            case 0x50:


9624            case 0x51:


9625            case 0x52:


9626            case 0x53:


9627            case 0x54:


9628            case 0x55:


9629            case 0x56:


9630            case 0x57:


9631            case 0x58: // Binary data (one-byte uint8_t for n follows)


9632            case 0x59: // Binary data (two-byte uint16_t for n follow)


9633            case 0x5A: // Binary data (four-byte uint32_t for n follow)


9634            case 0x5B: // Binary data (eight-byte uint64_t for n follow)


9635            case 0x5F: // Binary data (indefinite length)


9636            {


9637                binary_t b;


9638                return get_cbor_binary(b) && sax->binary(b);


9639            }


9640


9641            // UTF-8 string (0x00..0x17 bytes follow)


9642            case 0x60:


9643            case 0x61:


9644            case 0x62:


9645            case 0x63:


9646            case 0x64:


9647            case 0x65:


9648            case 0x66:


9649            case 0x67:


9650            case 0x68:


9651            case 0x69:


9652            case 0x6A:


9653            case 0x6B:


9654            case 0x6C:


9655            case 0x6D:


9656            case 0x6E:


9657            case 0x6F:


9658            case 0x70:


9659            case 0x71:


9660            case 0x72:


9661            case 0x73:


9662            case 0x74:


9663            case 0x75:


9664            case 0x76:


9665            case 0x77:


9666            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)


9667            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)


9668            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)


9669            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)


9670            case 0x7F: // UTF-8 string (indefinite length)


9671            {


9672                string_t s;


9673                return get_cbor_string(s) && sax->string(s);


9674            }


9675


9676            // array (0x00..0x17 data items follow)


9677            case 0x80:


9678            case 0x81:


9679            case 0x82:


9680            case 0x83:


9681            case 0x84:


9682            case 0x85:


9683            case 0x86:


9684            case 0x87:


9685            case 0x88:


9686            case 0x89:


9687            case 0x8A:


9688            case 0x8B:


9689            case 0x8C:


9690            case 0x8D:


9691            case 0x8E:


9692            case 0x8F:


9693            case 0x90:


9694            case 0x91:


9695            case 0x92:


9696            case 0x93:


9697            case 0x94:


9698            case 0x95:


9699            case 0x96:


9700            case 0x97:


9701                return get_cbor_array(


9702                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);


9703


9704            case 0x98: // array (one-byte uint8_t for n follows)


9705            {


9706                std::uint8_t len{};


9707                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);


9708            }


9709


9710            case 0x99: // array (two-byte uint16_t for n follow)


9711            {


9712                std::uint16_t len{};


9713                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);


9714            }


9715


9716            case 0x9A: // array (four-byte uint32_t for n follow)


9717            {


9718                std::uint32_t len{};


9719                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);


9720            }


9721


9722            case 0x9B: // array (eight-byte uint64_t for n follow)


9723            {


9724                std::uint64_t len{};


9725                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);


9726            }


9727


9728            case 0x9F: // array (indefinite length)


9729                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);


9730


9731            // map (0x00..0x17 pairs of data items follow)


9732            case 0xA0:


9733            case 0xA1:


9734            case 0xA2:


9735            case 0xA3:


9736            case 0xA4:


9737            case 0xA5:


9738            case 0xA6:


9739            case 0xA7:


9740            case 0xA8:


9741            case 0xA9:


9742            case 0xAA:


9743            case 0xAB:


9744            case 0xAC:


9745            case 0xAD:


9746            case 0xAE:


9747            case 0xAF:


9748            case 0xB0:


9749            case 0xB1:


9750            case 0xB2:


9751            case 0xB3:


9752            case 0xB4:


9753            case 0xB5:


9754            case 0xB6:


9755            case 0xB7:


9756                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);


9757


9758            case 0xB8: // map (one-byte uint8_t for n follows)


9759            {


9760                std::uint8_t len{};


9761                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);


9762            }


9763


9764            case 0xB9: // map (two-byte uint16_t for n follow)


9765            {


9766                std::uint16_t len{};


9767                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);


9768            }


9769


9770            case 0xBA: // map (four-byte uint32_t for n follow)


9771            {


9772                std::uint32_t len{};


9773                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);


9774            }


9775


9776            case 0xBB: // map (eight-byte uint64_t for n follow)


9777            {


9778                std::uint64_t len{};


9779                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);


9780            }


9781


9782            case 0xBF: // map (indefinite length)


9783                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);


9784


9785            case 0xC6: // tagged item


9786            case 0xC7:


9787            case 0xC8:


9788            case 0xC9:


9789            case 0xCA:


9790            case 0xCB:


9791            case 0xCC:


9792            case 0xCD:


9793            case 0xCE:


9794            case 0xCF:


9795            case 0xD0:


9796            case 0xD1:


9797            case 0xD2:


9798            case 0xD3:


9799            case 0xD4:


9800            case 0xD8: // tagged item (1 bytes follow)


9801            case 0xD9: // tagged item (2 bytes follow)


9802            case 0xDA: // tagged item (4 bytes follow)


9803            case 0xDB: // tagged item (8 bytes follow)


9804            {


9805                switch (tag_handler)


9806                {


9807                    case cbor_tag_handler_t::error:


9808                    {


9809                        auto last_token = get_token_string();


9810                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


9811                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));


9812                    }


9813


9814                    case cbor_tag_handler_t::ignore:


9815                    {


9816                        // ignore binary subtype


9817                        switch (current)


9818                        {


9819                            case 0xD8:


9820                            {


9821                                std::uint8_t subtype_to_ignore{};


9822                                get_number(input_format_t::cbor, subtype_to_ignore);


9823                                break;


9824                            }


9825                            case 0xD9:


9826                            {


9827                                std::uint16_t subtype_to_ignore{};


9828                                get_number(input_format_t::cbor, subtype_to_ignore);


9829                                break;


9830                            }


9831                            case 0xDA:


9832                            {


9833                                std::uint32_t subtype_to_ignore{};


9834                                get_number(input_format_t::cbor, subtype_to_ignore);


9835                                break;


9836                            }


9837                            case 0xDB:


9838                            {


9839                                std::uint64_t subtype_to_ignore{};


9840                                get_number(input_format_t::cbor, subtype_to_ignore);


9841                                break;


9842                            }


9843                            default:


9844                                break;


9845                        }


9846                        return parse_cbor_internal(true, tag_handler);


9847                    }


9848


9849                    case cbor_tag_handler_t::store:


9850                    {


9851                        binary_t b;


9852                        // use binary subtype and store in binary container


9853                        switch (current)


9854                        {


9855                            case 0xD8:


9856                            {


9857                                std::uint8_t subtype{};


9858                                get_number(input_format_t::cbor, subtype);


9859                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));


9860                                break;


9861                            }


9862                            case 0xD9:


9863                            {


9864                                std::uint16_t subtype{};


9865                                get_number(input_format_t::cbor, subtype);


9866                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));


9867                                break;


9868                            }


9869                            case 0xDA:


9870                            {


9871                                std::uint32_t subtype{};


9872                                get_number(input_format_t::cbor, subtype);


9873                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));


9874                                break;


9875                            }


9876                            case 0xDB:


9877                            {


9878                                std::uint64_t subtype{};


9879                                get_number(input_format_t::cbor, subtype);


9880                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));


9881                                break;


9882                            }


9883                            default:


9884                                return parse_cbor_internal(true, tag_handler);


9885                        }


9886                        get();


9887                        return get_cbor_binary(b) && sax->binary(b);


9888                    }


9889


9890                    default:                 // LCOV_EXCL_LINE


9891                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


9892                        return false;        // LCOV_EXCL_LINE


9893                }


9894            }


9895


9896            case 0xF4: // false


9897                return sax->boolean(false);


9898


9899            case 0xF5: // true


9900                return sax->boolean(true);


9901


9902            case 0xF6: // null


9903                return sax->null();


9904


9905            case 0xF9: // Half-Precision Float (two-byte IEEE 754)


9906            {


9907                const auto byte1_raw = get();


9908                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))


9909                {


9910                    return false;


9911                }


9912                const auto byte2_raw = get();


9913                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))


9914                {


9915                    return false;


9916                }


9917


9918                const auto byte1 = static_cast<unsigned char>(byte1_raw);


9919                const auto byte2 = static_cast<unsigned char>(byte2_raw);


9920


9921                // code from RFC 7049, Appendix D, Figure 3:


9922                // As half-precision floating-point numbers were only added


9923                // to IEEE 754 in 2008, today's programming platforms often


9924                // still only have limited support for them. It is very


9925                // easy to include at least decoding support for them even


9926                // without such support. An example of a small decoder for


9927                // half-precision floating-point numbers in the C language


9928                // is shown in Fig. 3.


9929                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);


9930                const double val = [&half]


9931                {


9932                    const int exp = (half >> 10u) & 0x1Fu;


9933                    const unsigned int mant = half & 0x3FFu;


9934                    JSON_ASSERT(0 <= exp&& exp <= 32);


9935                    JSON_ASSERT(mant <= 1024);


9936                    switch (exp)


9937                    {


9938                        case 0:


9939                            return std::ldexp(mant, -24);


9940                        case 31:


9941                            return (mant == 0)


9942                            ? std::numeric_limits<double>::infinity()


9943                            : std::numeric_limits<double>::quiet_NaN();


9944                        default:


9945                            return std::ldexp(mant + 1024, exp - 25);


9946                    }


9947                }();


9948                return sax->number_float((half & 0x8000u) != 0


9949                                         ? static_cast<number_float_t>(-val)


9950                                         : static_cast<number_float_t>(val), "");


9951            }


9952


9953            case 0xFA: // Single-Precision Float (four-byte IEEE 754)


9954            {


9955                float number{};


9956                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");


9957            }


9958


9959            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)


9960            {


9961                double number{};


9962                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");


9963            }


9964


9965            default: // anything else (0xFF is handled inside the other types)


9966            {


9967                auto last_token = get_token_string();


9968                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


9969                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));


9970            }


9971        }


9972    }


9973


9974    /*!


9975    @brief reads a CBOR string


9976


9977    This function first reads starting bytes to determine the expected


9978    string length and then copies this number of bytes into a string.


9979    Additionally, CBOR's strings with indefinite lengths are supported.


9980


9981    @param[out] result  created string


9982


9983    @return whether string creation completed


9984    */


9985    bool get_cbor_string(string_t& result)


9986    {


9987        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))


9988        {


9989            return false;


9990        }


9991


9992        switch (current)


9993        {


9994            // UTF-8 string (0x00..0x17 bytes follow)


9995            case 0x60:


9996            case 0x61:


9997            case 0x62:


9998            case 0x63:


9999            case 0x64:


10000            case 0x65:


10001            case 0x66:


10002            case 0x67:


10003            case 0x68:


10004            case 0x69:


10005            case 0x6A:


10006            case 0x6B:


10007            case 0x6C:


10008            case 0x6D:


10009            case 0x6E:


10010            case 0x6F:


10011            case 0x70:


10012            case 0x71:


10013            case 0x72:


10014            case 0x73:


10015            case 0x74:


10016            case 0x75:


10017            case 0x76:


10018            case 0x77:


10019            {


10020                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);


10021            }


10022


10023            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)


10024            {


10025                std::uint8_t len{};


10026                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);


10027            }


10028


10029            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)


10030            {


10031                std::uint16_t len{};


10032                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);


10033            }


10034


10035            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)


10036            {


10037                std::uint32_t len{};


10038                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);


10039            }


10040


10041            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)


10042            {


10043                std::uint64_t len{};


10044                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);


10045            }


10046


10047            case 0x7F: // UTF-8 string (indefinite length)


10048            {


10049                while (get() != 0xFF)


10050                {


10051                    string_t chunk;


10052                    if (!get_cbor_string(chunk))


10053                    {


10054                        return false;


10055                    }


10056                    result.append(chunk);


10057                }


10058                return true;


10059            }


10060


10061            default:


10062            {


10063                auto last_token = get_token_string();


10064                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,


10065                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));


10066            }


10067        }


10068    }


10069


10070    /*!


10071    @brief reads a CBOR byte array


10072


10073    This function first reads starting bytes to determine the expected


10074    byte array length and then copies this number of bytes into the byte array.


10075    Additionally, CBOR's byte arrays with indefinite lengths are supported.


10076


10077    @param[out] result  created byte array


10078


10079    @return whether byte array creation completed


10080    */


10081    bool get_cbor_binary(binary_t& result)


10082    {


10083        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))


10084        {


10085            return false;


10086        }


10087


10088        switch (current)


10089        {


10090            // Binary data (0x00..0x17 bytes follow)


10091            case 0x40:


10092            case 0x41:


10093            case 0x42:


10094            case 0x43:


10095            case 0x44:


10096            case 0x45:


10097            case 0x46:


10098            case 0x47:


10099            case 0x48:


10100            case 0x49:


10101            case 0x4A:


10102            case 0x4B:


10103            case 0x4C:


10104            case 0x4D:


10105            case 0x4E:


10106            case 0x4F:


10107            case 0x50:


10108            case 0x51:


10109            case 0x52:


10110            case 0x53:


10111            case 0x54:


10112            case 0x55:


10113            case 0x56:


10114            case 0x57:


10115            {


10116                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);


10117            }


10118


10119            case 0x58: // Binary data (one-byte uint8_t for n follows)


10120            {


10121                std::uint8_t len{};


10122                return get_number(input_format_t::cbor, len) &&


10123                       get_binary(input_format_t::cbor, len, result);


10124            }


10125


10126            case 0x59: // Binary data (two-byte uint16_t for n follow)


10127            {


10128                std::uint16_t len{};


10129                return get_number(input_format_t::cbor, len) &&


10130                       get_binary(input_format_t::cbor, len, result);


10131            }


10132


10133            case 0x5A: // Binary data (four-byte uint32_t for n follow)


10134            {


10135                std::uint32_t len{};


10136                return get_number(input_format_t::cbor, len) &&


10137                       get_binary(input_format_t::cbor, len, result);


10138            }


10139


10140            case 0x5B: // Binary data (eight-byte uint64_t for n follow)


10141            {


10142                std::uint64_t len{};


10143                return get_number(input_format_t::cbor, len) &&


10144                       get_binary(input_format_t::cbor, len, result);


10145            }


10146


10147            case 0x5F: // Binary data (indefinite length)


10148            {


10149                while (get() != 0xFF)


10150                {


10151                    binary_t chunk;


10152                    if (!get_cbor_binary(chunk))


10153                    {


10154                        return false;


10155                    }


10156                    result.insert(result.end(), chunk.begin(), chunk.end());


10157                }


10158                return true;


10159            }


10160


10161            default:


10162            {


10163                auto last_token = get_token_string();


10164                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,


10165                                        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));


10166            }


10167        }


10168    }


10169


10170    /*!


10171    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an


10172                    array of indefinite size


10173    @param[in] tag_handler how CBOR tags should be treated


10174    @return whether array creation completed


10175    */


10176    bool get_cbor_array(const std::size_t len,


10177                        const cbor_tag_handler_t tag_handler)


10178    {


10179        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))


10180        {


10181            return false;


10182        }


10183


10184        if (len != static_cast<std::size_t>(-1))


10185        {


10186            for (std::size_t i = 0; i < len; ++i)


10187            {


10188                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))


10189                {


10190                    return false;


10191                }


10192            }


10193        }


10194        else


10195        {


10196            while (get() != 0xFF)


10197            {


10198                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))


10199                {


10200                    return false;


10201                }


10202            }


10203        }


10204


10205        return sax->end_array();


10206    }


10207


10208    /*!


10209    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an


10210                    object of indefinite size


10211    @param[in] tag_handler how CBOR tags should be treated


10212    @return whether object creation completed


10213    */


10214    bool get_cbor_object(const std::size_t len,


10215                         const cbor_tag_handler_t tag_handler)


10216    {


10217        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))


10218        {


10219            return false;


10220        }


10221


10222        if (len != 0)


10223        {


10224            string_t key;


10225            if (len != static_cast<std::size_t>(-1))


10226            {


10227                for (std::size_t i = 0; i < len; ++i)


10228                {


10229                    get();


10230                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))


10231                    {


10232                        return false;


10233                    }


10234


10235                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))


10236                    {


10237                        return false;


10238                    }


10239                    key.clear();


10240                }


10241            }


10242            else


10243            {


10244                while (get() != 0xFF)


10245                {


10246                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))


10247                    {


10248                        return false;


10249                    }


10250


10251                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))


10252                    {


10253                        return false;


10254                    }


10255                    key.clear();


10256                }


10257            }


10258        }


10259


10260        return sax->end_object();


10261    }


10262


10263    /////////////


10264    // MsgPack //


10265    /////////////


10266


10267    /*!


10268    @return whether a valid MessagePack value was passed to the SAX parser


10269    */


10270    bool parse_msgpack_internal()


10271    {


10272        switch (get())


10273        {


10274            // EOF


10275            case std::char_traits<char_type>::eof():


10276                return unexpect_eof(input_format_t::msgpack, "value");


10277


10278            // positive fixint


10279            case 0x00:


10280            case 0x01:


10281            case 0x02:


10282            case 0x03:


10283            case 0x04:


10284            case 0x05:


10285            case 0x06:


10286            case 0x07:


10287            case 0x08:


10288            case 0x09:


10289            case 0x0A:


10290            case 0x0B:


10291            case 0x0C:


10292            case 0x0D:


10293            case 0x0E:


10294            case 0x0F:


10295            case 0x10:


10296            case 0x11:


10297            case 0x12:


10298            case 0x13:


10299            case 0x14:


10300            case 0x15:


10301            case 0x16:


10302            case 0x17:


10303            case 0x18:


10304            case 0x19:


10305            case 0x1A:


10306            case 0x1B:


10307            case 0x1C:


10308            case 0x1D:


10309            case 0x1E:


10310            case 0x1F:


10311            case 0x20:


10312            case 0x21:


10313            case 0x22:


10314            case 0x23:


10315            case 0x24:


10316            case 0x25:


10317            case 0x26:


10318            case 0x27:


10319            case 0x28:


10320            case 0x29:


10321            case 0x2A:


10322            case 0x2B:


10323            case 0x2C:


10324            case 0x2D:


10325            case 0x2E:


10326            case 0x2F:


10327            case 0x30:


10328            case 0x31:


10329            case 0x32:


10330            case 0x33:


10331            case 0x34:


10332            case 0x35:


10333            case 0x36:


10334            case 0x37:


10335            case 0x38:


10336            case 0x39:


10337            case 0x3A:


10338            case 0x3B:


10339            case 0x3C:


10340            case 0x3D:


10341            case 0x3E:


10342            case 0x3F:


10343            case 0x40:


10344            case 0x41:


10345            case 0x42:


10346            case 0x43:


10347            case 0x44:


10348            case 0x45:


10349            case 0x46:


10350            case 0x47:


10351            case 0x48:


10352            case 0x49:


10353            case 0x4A:


10354            case 0x4B:


10355            case 0x4C:


10356            case 0x4D:


10357            case 0x4E:


10358            case 0x4F:


10359            case 0x50:


10360            case 0x51:


10361            case 0x52:


10362            case 0x53:


10363            case 0x54:


10364            case 0x55:


10365            case 0x56:


10366            case 0x57:


10367            case 0x58:


10368            case 0x59:


10369            case 0x5A:


10370            case 0x5B:


10371            case 0x5C:


10372            case 0x5D:


10373            case 0x5E:


10374            case 0x5F:


10375            case 0x60:


10376            case 0x61:


10377            case 0x62:


10378            case 0x63:


10379            case 0x64:


10380            case 0x65:


10381            case 0x66:


10382            case 0x67:


10383            case 0x68:


10384            case 0x69:


10385            case 0x6A:


10386            case 0x6B:


10387            case 0x6C:


10388            case 0x6D:


10389            case 0x6E:


10390            case 0x6F:


10391            case 0x70:


10392            case 0x71:


10393            case 0x72:


10394            case 0x73:


10395            case 0x74:


10396            case 0x75:


10397            case 0x76:


10398            case 0x77:


10399            case 0x78:


10400            case 0x79:


10401            case 0x7A:


10402            case 0x7B:


10403            case 0x7C:


10404            case 0x7D:


10405            case 0x7E:


10406            case 0x7F:


10407                return sax->number_unsigned(static_cast<number_unsigned_t>(current));


10408


10409            // fixmap


10410            case 0x80:


10411            case 0x81:


10412            case 0x82:


10413            case 0x83:


10414            case 0x84:


10415            case 0x85:


10416            case 0x86:


10417            case 0x87:


10418            case 0x88:


10419            case 0x89:


10420            case 0x8A:


10421            case 0x8B:


10422            case 0x8C:


10423            case 0x8D:


10424            case 0x8E:


10425            case 0x8F:


10426                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));


10427


10428            // fixarray


10429            case 0x90:


10430            case 0x91:


10431            case 0x92:


10432            case 0x93:


10433            case 0x94:


10434            case 0x95:


10435            case 0x96:


10436            case 0x97:


10437            case 0x98:


10438            case 0x99:


10439            case 0x9A:


10440            case 0x9B:


10441            case 0x9C:


10442            case 0x9D:


10443            case 0x9E:


10444            case 0x9F:


10445                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));


10446


10447            // fixstr


10448            case 0xA0:


10449            case 0xA1:


10450            case 0xA2:


10451            case 0xA3:


10452            case 0xA4:


10453            case 0xA5:


10454            case 0xA6:


10455            case 0xA7:


10456            case 0xA8:


10457            case 0xA9:


10458            case 0xAA:


10459            case 0xAB:


10460            case 0xAC:


10461            case 0xAD:


10462            case 0xAE:


10463            case 0xAF:


10464            case 0xB0:


10465            case 0xB1:


10466            case 0xB2:


10467            case 0xB3:


10468            case 0xB4:


10469            case 0xB5:


10470            case 0xB6:


10471            case 0xB7:


10472            case 0xB8:


10473            case 0xB9:


10474            case 0xBA:


10475            case 0xBB:


10476            case 0xBC:


10477            case 0xBD:


10478            case 0xBE:


10479            case 0xBF:


10480            case 0xD9: // str 8


10481            case 0xDA: // str 16


10482            case 0xDB: // str 32


10483            {


10484                string_t s;


10485                return get_msgpack_string(s) && sax->string(s);


10486            }


10487


10488            case 0xC0: // nil


10489                return sax->null();


10490


10491            case 0xC2: // false


10492                return sax->boolean(false);


10493


10494            case 0xC3: // true


10495                return sax->boolean(true);


10496


10497            case 0xC4: // bin 8


10498            case 0xC5: // bin 16


10499            case 0xC6: // bin 32


10500            case 0xC7: // ext 8


10501            case 0xC8: // ext 16


10502            case 0xC9: // ext 32


10503            case 0xD4: // fixext 1


10504            case 0xD5: // fixext 2


10505            case 0xD6: // fixext 4


10506            case 0xD7: // fixext 8


10507            case 0xD8: // fixext 16


10508            {


10509                binary_t b;


10510                return get_msgpack_binary(b) && sax->binary(b);


10511            }


10512


10513            case 0xCA: // float 32


10514            {


10515                float number{};


10516                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");


10517            }


10518


10519            case 0xCB: // float 64


10520            {


10521                double number{};


10522                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");


10523            }


10524


10525            case 0xCC: // uint 8


10526            {


10527                std::uint8_t number{};


10528                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);


10529            }


10530


10531            case 0xCD: // uint 16


10532            {


10533                std::uint16_t number{};


10534                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);


10535            }


10536


10537            case 0xCE: // uint 32


10538            {


10539                std::uint32_t number{};


10540                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);


10541            }


10542


10543            case 0xCF: // uint 64


10544            {


10545                std::uint64_t number{};


10546                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);


10547            }


10548


10549            case 0xD0: // int 8


10550            {


10551                std::int8_t number{};


10552                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);


10553            }


10554


10555            case 0xD1: // int 16


10556            {


10557                std::int16_t number{};


10558                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);


10559            }


10560


10561            case 0xD2: // int 32


10562            {


10563                std::int32_t number{};


10564                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);


10565            }


10566


10567            case 0xD3: // int 64


10568            {


10569                std::int64_t number{};


10570                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);


10571            }


10572


10573            case 0xDC: // array 16


10574            {


10575                std::uint16_t len{};


10576                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));


10577            }


10578


10579            case 0xDD: // array 32


10580            {


10581                std::uint32_t len{};


10582                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));


10583            }


10584


10585            case 0xDE: // map 16


10586            {


10587                std::uint16_t len{};


10588                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));


10589            }


10590


10591            case 0xDF: // map 32


10592            {


10593                std::uint32_t len{};


10594                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));


10595            }


10596


10597            // negative fixint


10598            case 0xE0:


10599            case 0xE1:


10600            case 0xE2:


10601            case 0xE3:


10602            case 0xE4:


10603            case 0xE5:


10604            case 0xE6:


10605            case 0xE7:


10606            case 0xE8:


10607            case 0xE9:


10608            case 0xEA:


10609            case 0xEB:


10610            case 0xEC:


10611            case 0xED:


10612            case 0xEE:


10613            case 0xEF:


10614            case 0xF0:


10615            case 0xF1:


10616            case 0xF2:


10617            case 0xF3:


10618            case 0xF4:


10619            case 0xF5:


10620            case 0xF6:


10621            case 0xF7:


10622            case 0xF8:


10623            case 0xF9:


10624            case 0xFA:


10625            case 0xFB:


10626            case 0xFC:


10627            case 0xFD:


10628            case 0xFE:


10629            case 0xFF:


10630                return sax->number_integer(static_cast<std::int8_t>(current));


10631


10632            default: // anything else


10633            {


10634                auto last_token = get_token_string();


10635                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


10636                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));


10637            }


10638        }


10639    }


10640


10641    /*!


10642    @brief reads a MessagePack string


10643


10644    This function first reads starting bytes to determine the expected


10645    string length and then copies this number of bytes into a string.


10646


10647    @param[out] result  created string


10648


10649    @return whether string creation completed


10650    */


10651    bool get_msgpack_string(string_t& result)


10652    {


10653        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))


10654        {


10655            return false;


10656        }


10657


10658        switch (current)


10659        {


10660            // fixstr


10661            case 0xA0:


10662            case 0xA1:


10663            case 0xA2:


10664            case 0xA3:


10665            case 0xA4:


10666            case 0xA5:


10667            case 0xA6:


10668            case 0xA7:


10669            case 0xA8:


10670            case 0xA9:


10671            case 0xAA:


10672            case 0xAB:


10673            case 0xAC:


10674            case 0xAD:


10675            case 0xAE:


10676            case 0xAF:


10677            case 0xB0:


10678            case 0xB1:


10679            case 0xB2:


10680            case 0xB3:


10681            case 0xB4:


10682            case 0xB5:


10683            case 0xB6:


10684            case 0xB7:


10685            case 0xB8:


10686            case 0xB9:


10687            case 0xBA:


10688            case 0xBB:


10689            case 0xBC:


10690            case 0xBD:


10691            case 0xBE:


10692            case 0xBF:


10693            {


10694                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);


10695            }


10696


10697            case 0xD9: // str 8


10698            {


10699                std::uint8_t len{};


10700                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);


10701            }


10702


10703            case 0xDA: // str 16


10704            {


10705                std::uint16_t len{};


10706                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);


10707            }


10708


10709            case 0xDB: // str 32


10710            {


10711                std::uint32_t len{};


10712                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);


10713            }


10714


10715            default:


10716            {


10717                auto last_token = get_token_string();


10718                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,


10719                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));


10720            }


10721        }


10722    }


10723


10724    /*!


10725    @brief reads a MessagePack byte array


10726


10727    This function first reads starting bytes to determine the expected


10728    byte array length and then copies this number of bytes into a byte array.


10729


10730    @param[out] result  created byte array


10731


10732    @return whether byte array creation completed


10733    */


10734    bool get_msgpack_binary(binary_t& result)


10735    {


10736        // helper function to set the subtype


10737        auto assign_and_return_true = [&result](std::int8_t subtype)


10738        {


10739            result.set_subtype(static_cast<std::uint8_t>(subtype));


10740            return true;


10741        };


10742


10743        switch (current)


10744        {


10745            case 0xC4: // bin 8


10746            {


10747                std::uint8_t len{};


10748                return get_number(input_format_t::msgpack, len) &&


10749                       get_binary(input_format_t::msgpack, len, result);


10750            }


10751


10752            case 0xC5: // bin 16


10753            {


10754                std::uint16_t len{};


10755                return get_number(input_format_t::msgpack, len) &&


10756                       get_binary(input_format_t::msgpack, len, result);


10757            }


10758


10759            case 0xC6: // bin 32


10760            {


10761                std::uint32_t len{};


10762                return get_number(input_format_t::msgpack, len) &&


10763                       get_binary(input_format_t::msgpack, len, result);


10764            }


10765


10766            case 0xC7: // ext 8


10767            {


10768                std::uint8_t len{};


10769                std::int8_t subtype{};


10770                return get_number(input_format_t::msgpack, len) &&


10771                       get_number(input_format_t::msgpack, subtype) &&


10772                       get_binary(input_format_t::msgpack, len, result) &&


10773                       assign_and_return_true(subtype);


10774            }


10775


10776            case 0xC8: // ext 16


10777            {


10778                std::uint16_t len{};


10779                std::int8_t subtype{};


10780                return get_number(input_format_t::msgpack, len) &&


10781                       get_number(input_format_t::msgpack, subtype) &&


10782                       get_binary(input_format_t::msgpack, len, result) &&


10783                       assign_and_return_true(subtype);


10784            }


10785


10786            case 0xC9: // ext 32


10787            {


10788                std::uint32_t len{};


10789                std::int8_t subtype{};


10790                return get_number(input_format_t::msgpack, len) &&


10791                       get_number(input_format_t::msgpack, subtype) &&


10792                       get_binary(input_format_t::msgpack, len, result) &&


10793                       assign_and_return_true(subtype);


10794            }


10795


10796            case 0xD4: // fixext 1


10797            {


10798                std::int8_t subtype{};


10799                return get_number(input_format_t::msgpack, subtype) &&


10800                       get_binary(input_format_t::msgpack, 1, result) &&


10801                       assign_and_return_true(subtype);


10802            }


10803


10804            case 0xD5: // fixext 2


10805            {


10806                std::int8_t subtype{};


10807                return get_number(input_format_t::msgpack, subtype) &&


10808                       get_binary(input_format_t::msgpack, 2, result) &&


10809                       assign_and_return_true(subtype);


10810            }


10811


10812            case 0xD6: // fixext 4


10813            {


10814                std::int8_t subtype{};


10815                return get_number(input_format_t::msgpack, subtype) &&


10816                       get_binary(input_format_t::msgpack, 4, result) &&


10817                       assign_and_return_true(subtype);


10818            }


10819


10820            case 0xD7: // fixext 8


10821            {


10822                std::int8_t subtype{};


10823                return get_number(input_format_t::msgpack, subtype) &&


10824                       get_binary(input_format_t::msgpack, 8, result) &&


10825                       assign_and_return_true(subtype);


10826            }


10827


10828            case 0xD8: // fixext 16


10829            {


10830                std::int8_t subtype{};


10831                return get_number(input_format_t::msgpack, subtype) &&


10832                       get_binary(input_format_t::msgpack, 16, result) &&


10833                       assign_and_return_true(subtype);


10834            }


10835


10836            default:           // LCOV_EXCL_LINE


10837                return false;  // LCOV_EXCL_LINE


10838        }


10839    }


10840


10841    /*!


10842    @param[in] len  the length of the array


10843    @return whether array creation completed


10844    */


10845    bool get_msgpack_array(const std::size_t len)


10846    {


10847        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))


10848        {


10849            return false;


10850        }


10851


10852        for (std::size_t i = 0; i < len; ++i)


10853        {


10854            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))


10855            {


10856                return false;


10857            }


10858        }


10859


10860        return sax->end_array();


10861    }


10862


10863    /*!


10864    @param[in] len  the length of the object


10865    @return whether object creation completed


10866    */


10867    bool get_msgpack_object(const std::size_t len)


10868    {


10869        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))


10870        {


10871            return false;


10872        }


10873


10874        string_t key;


10875        for (std::size_t i = 0; i < len; ++i)


10876        {


10877            get();


10878            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))


10879            {


10880                return false;


10881            }


10882


10883            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))


10884            {


10885                return false;


10886            }


10887            key.clear();


10888        }


10889


10890        return sax->end_object();


10891    }


10892


10893    ////////////


10894    // UBJSON //


10895    ////////////


10896


10897    /*!


10898    @param[in] get_char  whether a new character should be retrieved from the


10899                         input (true, default) or whether the last read


10900                         character should be considered instead


10901


10902    @return whether a valid UBJSON value was passed to the SAX parser


10903    */


10904    bool parse_ubjson_internal(const bool get_char = true)


10905    {


10906        return get_ubjson_value(get_char ? get_ignore_noop() : current);


10907    }


10908


10909    /*!


10910    @brief reads a UBJSON string


10911


10912    This function is either called after reading the 'S' byte explicitly


10913    indicating a string, or in case of an object key where the 'S' byte can be


10914    left out.


10915


10916    @param[out] result   created string


10917    @param[in] get_char  whether a new character should be retrieved from the


10918                         input (true, default) or whether the last read


10919                         character should be considered instead


10920


10921    @return whether string creation completed


10922    */


10923    bool get_ubjson_string(string_t& result, const bool get_char = true)


10924    {


10925        if (get_char)


10926        {


10927            get();  // TODO(niels): may we ignore N here?


10928        }


10929


10930        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))


10931        {


10932            return false;


10933        }


10934


10935        switch (current)


10936        {


10937            case 'U':


10938            {


10939                std::uint8_t len{};


10940                return get_number(input_format, len) && get_string(input_format, len, result);


10941            }


10942


10943            case 'i':


10944            {


10945                std::int8_t len{};


10946                return get_number(input_format, len) && get_string(input_format, len, result);


10947            }


10948


10949            case 'I':


10950            {


10951                std::int16_t len{};


10952                return get_number(input_format, len) && get_string(input_format, len, result);


10953            }


10954


10955            case 'l':


10956            {


10957                std::int32_t len{};


10958                return get_number(input_format, len) && get_string(input_format, len, result);


10959            }


10960


10961            case 'L':


10962            {


10963                std::int64_t len{};


10964                return get_number(input_format, len) && get_string(input_format, len, result);


10965            }


10966


10967            case 'u':


10968            {


10969                if (input_format != input_format_t::bjdata)


10970                {


10971                    break;


10972                }


10973                std::uint16_t len{};


10974                return get_number(input_format, len) && get_string(input_format, len, result);


10975            }


10976


10977            case 'm':


10978            {


10979                if (input_format != input_format_t::bjdata)


10980                {


10981                    break;


10982                }


10983                std::uint32_t len{};


10984                return get_number(input_format, len) && get_string(input_format, len, result);


10985            }


10986


10987            case 'M':


10988            {


10989                if (input_format != input_format_t::bjdata)


10990                {


10991                    break;


10992                }


10993                std::uint64_t len{};


10994                return get_number(input_format, len) && get_string(input_format, len, result);


10995            }


10996


10997            default:


10998                break;


10999        }


11000        auto last_token = get_token_string();


11001        std::string message;


11002


11003        if (input_format != input_format_t::bjdata)


11004        {


11005            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;


11006        }


11007        else


11008        {


11009            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;


11010        }


11011        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));


11012    }


11013


11014    /*!


11015    @param[out] dim  an integer vector storing the ND array dimensions


11016    @return whether reading ND array size vector is successful


11017    */


11018    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)


11019    {


11020        std::pair<std::size_t, char_int_type> size_and_type;


11021        size_t dimlen = 0;


11022        bool no_ndarray = true;


11023


11024        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))


11025        {


11026            return false;


11027        }


11028


11029        if (size_and_type.first != npos)


11030        {


11031            if (size_and_type.second != 0)


11032            {


11033                if (size_and_type.second != 'N')


11034                {


11035                    for (std::size_t i = 0; i < size_and_type.first; ++i)


11036                    {


11037                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))


11038                        {


11039                            return false;


11040                        }


11041                        dim.push_back(dimlen);


11042                    }


11043                }


11044            }


11045            else


11046            {


11047                for (std::size_t i = 0; i < size_and_type.first; ++i)


11048                {


11049                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))


11050                    {


11051                        return false;


11052                    }


11053                    dim.push_back(dimlen);


11054                }


11055            }


11056        }


11057        else


11058        {


11059            while (current != ']')


11060            {


11061                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))


11062                {


11063                    return false;


11064                }


11065                dim.push_back(dimlen);


11066                get_ignore_noop();


11067            }


11068        }


11069        return true;


11070    }


11071


11072    /*!


11073    @param[out] result  determined size


11074    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector


11075                               or ndarray dimension is not allowed; `false` means ndarray


11076                               is allowed; for output, `true` means an ndarray is found;


11077                               is_ndarray can only return `true` when its initial value


11078                               is `false`


11079    @param[in] prefix  type marker if already read, otherwise set to 0


11080


11081    @return whether size determination completed


11082    */


11083    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)


11084    {


11085        if (prefix == 0)


11086        {


11087            prefix = get_ignore_noop();


11088        }


11089


11090        switch (prefix)


11091        {


11092            case 'U':


11093            {


11094                std::uint8_t number{};


11095                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11096                {


11097                    return false;


11098                }


11099                result = static_cast<std::size_t>(number);


11100                return true;


11101            }


11102


11103            case 'i':


11104            {


11105                std::int8_t number{};


11106                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11107                {


11108                    return false;


11109                }


11110                if (number < 0)


11111                {


11112                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,


11113                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));


11114                }


11115                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char


11116                return true;


11117            }


11118


11119            case 'I':


11120            {


11121                std::int16_t number{};


11122                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11123                {


11124                    return false;


11125                }


11126                if (number < 0)


11127                {


11128                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,


11129                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));


11130                }


11131                result = static_cast<std::size_t>(number);


11132                return true;


11133            }


11134


11135            case 'l':


11136            {


11137                std::int32_t number{};


11138                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11139                {


11140                    return false;


11141                }


11142                if (number < 0)


11143                {


11144                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,


11145                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));


11146                }


11147                result = static_cast<std::size_t>(number);


11148                return true;


11149            }


11150


11151            case 'L':


11152            {


11153                std::int64_t number{};


11154                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11155                {


11156                    return false;


11157                }


11158                if (number < 0)


11159                {


11160                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,


11161                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));


11162                }


11163                if (!value_in_range_of<std::size_t>(number))


11164                {


11165                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,


11166                                            exception_message(input_format, "integer value overflow", "size"), nullptr));


11167                }


11168                result = static_cast<std::size_t>(number);


11169                return true;


11170            }


11171


11172            case 'u':


11173            {


11174                if (input_format != input_format_t::bjdata)


11175                {


11176                    break;


11177                }


11178                std::uint16_t number{};


11179                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11180                {


11181                    return false;


11182                }


11183                result = static_cast<std::size_t>(number);


11184                return true;


11185            }


11186


11187            case 'm':


11188            {


11189                if (input_format != input_format_t::bjdata)


11190                {


11191                    break;


11192                }


11193                std::uint32_t number{};


11194                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11195                {


11196                    return false;


11197                }


11198                result = conditional_static_cast<std::size_t>(number);


11199                return true;


11200            }


11201


11202            case 'M':


11203            {


11204                if (input_format != input_format_t::bjdata)


11205                {


11206                    break;


11207                }


11208                std::uint64_t number{};


11209                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))


11210                {


11211                    return false;


11212                }


11213                if (!value_in_range_of<std::size_t>(number))


11214                {


11215                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,


11216                                            exception_message(input_format, "integer value overflow", "size"), nullptr));


11217                }


11218                result = detail::conditional_static_cast<std::size_t>(number);


11219                return true;


11220            }


11221


11222            case '[':


11223            {


11224                if (input_format != input_format_t::bjdata)


11225                {


11226                    break;


11227                }


11228                if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array


11229                {


11230                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimentional vector is not allowed", "size"), nullptr));


11231                }


11232                std::vector<size_t> dim;


11233                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))


11234                {


11235                    return false;


11236                }


11237                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector


11238                {


11239                    result = dim.at(dim.size() - 1);


11240                    return true;


11241                }


11242                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format


11243                {


11244                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container


11245                    {


11246                        if ( i == 0 )


11247                        {


11248                            result = 0;


11249                            return true;


11250                        }


11251                    }


11252


11253                    string_t key = "_ArraySize_";


11254                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))


11255                    {


11256                        return false;


11257                    }


11258                    result = 1;


11259                    for (auto i : dim)


11260                    {


11261                        result *= i;


11262                        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()


11263                        {


11264                            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));


11265                        }


11266                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))


11267                        {


11268                            return false;


11269                        }


11270                    }


11271                    is_ndarray = true;


11272                    return sax->end_array();


11273                }


11274                result = 0;


11275                return true;


11276            }


11277


11278            default:


11279                break;


11280        }


11281        auto last_token = get_token_string();


11282        std::string message;


11283


11284        if (input_format != input_format_t::bjdata)


11285        {


11286            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;


11287        }


11288        else


11289        {


11290            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;


11291        }


11292        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));


11293    }


11294


11295    /*!


11296    @brief determine the type and size for a container


11297


11298    In the optimized UBJSON format, a type and a size can be provided to allow


11299    for a more compact representation.


11300


11301    @param[out] result  pair of the size and the type


11302    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector


11303


11304    @return whether pair creation completed


11305    */


11306    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)


11307    {


11308        result.first = npos; // size


11309        result.second = 0; // type


11310        bool is_ndarray = false;


11311


11312        get_ignore_noop();


11313


11314        if (current == '$')


11315        {


11316            result.second = get();  // must not ignore 'N', because 'N' maybe the type


11317            if (input_format == input_format_t::bjdata


11318                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))


11319            {


11320                auto last_token = get_token_string();


11321                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


11322                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));


11323            }


11324


11325            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))


11326            {


11327                return false;


11328            }


11329


11330            get_ignore_noop();


11331            if (JSON_HEDLEY_UNLIKELY(current != '#'))


11332            {


11333                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))


11334                {


11335                    return false;


11336                }


11337                auto last_token = get_token_string();


11338                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


11339                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));


11340            }


11341


11342            bool is_error = get_ubjson_size_value(result.first, is_ndarray);


11343            if (input_format == input_format_t::bjdata && is_ndarray)


11344            {


11345                if (inside_ndarray)


11346                {


11347                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,


11348                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));


11349                }


11350                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters


11351            }


11352            return is_error;


11353        }


11354


11355        if (current == '#')


11356        {


11357            bool is_error = get_ubjson_size_value(result.first, is_ndarray);


11358            if (input_format == input_format_t::bjdata && is_ndarray)


11359            {


11360                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,


11361                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));


11362            }


11363            return is_error;


11364        }


11365


11366        return true;


11367    }


11368


11369    /*!


11370    @param prefix  the previously read or set type prefix


11371    @return whether value creation completed


11372    */


11373    bool get_ubjson_value(const char_int_type prefix)


11374    {


11375        switch (prefix)


11376        {


11377            case std::char_traits<char_type>::eof():  // EOF


11378                return unexpect_eof(input_format, "value");


11379


11380            case 'T':  // true


11381                return sax->boolean(true);


11382            case 'F':  // false


11383                return sax->boolean(false);


11384


11385            case 'Z':  // null


11386                return sax->null();


11387


11388            case 'U':


11389            {


11390                std::uint8_t number{};


11391                return get_number(input_format, number) && sax->number_unsigned(number);


11392            }


11393


11394            case 'i':


11395            {


11396                std::int8_t number{};


11397                return get_number(input_format, number) && sax->number_integer(number);


11398            }


11399


11400            case 'I':


11401            {


11402                std::int16_t number{};


11403                return get_number(input_format, number) && sax->number_integer(number);


11404            }


11405


11406            case 'l':


11407            {


11408                std::int32_t number{};


11409                return get_number(input_format, number) && sax->number_integer(number);


11410            }


11411


11412            case 'L':


11413            {


11414                std::int64_t number{};


11415                return get_number(input_format, number) && sax->number_integer(number);


11416            }


11417


11418            case 'u':


11419            {


11420                if (input_format != input_format_t::bjdata)


11421                {


11422                    break;


11423                }


11424                std::uint16_t number{};


11425                return get_number(input_format, number) && sax->number_unsigned(number);


11426            }


11427


11428            case 'm':


11429            {


11430                if (input_format != input_format_t::bjdata)


11431                {


11432                    break;


11433                }


11434                std::uint32_t number{};


11435                return get_number(input_format, number) && sax->number_unsigned(number);


11436            }


11437


11438            case 'M':


11439            {


11440                if (input_format != input_format_t::bjdata)


11441                {


11442                    break;


11443                }


11444                std::uint64_t number{};


11445                return get_number(input_format, number) && sax->number_unsigned(number);


11446            }


11447


11448            case 'h':


11449            {


11450                if (input_format != input_format_t::bjdata)


11451                {


11452                    break;


11453                }


11454                const auto byte1_raw = get();


11455                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))


11456                {


11457                    return false;


11458                }


11459                const auto byte2_raw = get();


11460                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))


11461                {


11462                    return false;


11463                }


11464


11465                const auto byte1 = static_cast<unsigned char>(byte1_raw);


11466                const auto byte2 = static_cast<unsigned char>(byte2_raw);


11467


11468                // code from RFC 7049, Appendix D, Figure 3:


11469                // As half-precision floating-point numbers were only added


11470                // to IEEE 754 in 2008, today's programming platforms often


11471                // still only have limited support for them. It is very


11472                // easy to include at least decoding support for them even


11473                // without such support. An example of a small decoder for


11474                // half-precision floating-point numbers in the C language


11475                // is shown in Fig. 3.


11476                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);


11477                const double val = [&half]


11478                {


11479                    const int exp = (half >> 10u) & 0x1Fu;


11480                    const unsigned int mant = half & 0x3FFu;


11481                    JSON_ASSERT(0 <= exp&& exp <= 32);


11482                    JSON_ASSERT(mant <= 1024);


11483                    switch (exp)


11484                    {


11485                        case 0:


11486                            return std::ldexp(mant, -24);


11487                        case 31:


11488                            return (mant == 0)


11489                            ? std::numeric_limits<double>::infinity()


11490                            : std::numeric_limits<double>::quiet_NaN();


11491                        default:


11492                            return std::ldexp(mant + 1024, exp - 25);


11493                    }


11494                }();


11495                return sax->number_float((half & 0x8000u) != 0


11496                                         ? static_cast<number_float_t>(-val)


11497                                         : static_cast<number_float_t>(val), "");


11498            }


11499


11500            case 'd':


11501            {


11502                float number{};


11503                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");


11504            }


11505


11506            case 'D':


11507            {


11508                double number{};


11509                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");


11510            }


11511


11512            case 'H':


11513            {


11514                return get_ubjson_high_precision_number();


11515            }


11516


11517            case 'C':  // char


11518            {


11519                get();


11520                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))


11521                {


11522                    return false;


11523                }


11524                if (JSON_HEDLEY_UNLIKELY(current > 127))


11525                {


11526                    auto last_token = get_token_string();


11527                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,


11528                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));


11529                }


11530                string_t s(1, static_cast<typename string_t::value_type>(current));


11531                return sax->string(s);


11532            }


11533


11534            case 'S':  // string


11535            {


11536                string_t s;


11537                return get_ubjson_string(s) && sax->string(s);


11538            }


11539


11540            case '[':  // array


11541                return get_ubjson_array();


11542


11543            case '{':  // object


11544                return get_ubjson_object();


11545


11546            default: // anything else


11547                break;


11548        }


11549        auto last_token = get_token_string();


11550        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));


11551    }


11552


11553    /*!


11554    @return whether array creation completed


11555    */


11556    bool get_ubjson_array()


11557    {


11558        std::pair<std::size_t, char_int_type> size_and_type;


11559        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))


11560        {


11561            return false;


11562        }


11563


11564        // 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):


11565        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}


11566


11567        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)


11568        {


11569            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


11570            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)


11571            {


11572                return p.first < t;


11573            });


11574            string_t key = "_ArrayType_";


11575            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))


11576            {


11577                auto last_token = get_token_string();


11578                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


11579                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));


11580            }


11581


11582            string_t type = it->second; // sax->string() takes a reference


11583            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))


11584            {


11585                return false;


11586            }


11587


11588            if (size_and_type.second == 'C')


11589            {


11590                size_and_type.second = 'U';


11591            }


11592


11593            key = "_ArrayData_";


11594            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))


11595            {


11596                return false;


11597            }


11598


11599            for (std::size_t i = 0; i < size_and_type.first; ++i)


11600            {


11601                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))


11602                {


11603                    return false;


11604                }


11605            }


11606


11607            return (sax->end_array() && sax->end_object());


11608        }


11609


11610        if (size_and_type.first != npos)


11611        {


11612            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))


11613            {


11614                return false;


11615            }


11616


11617            if (size_and_type.second != 0)


11618            {


11619                if (size_and_type.second != 'N')


11620                {


11621                    for (std::size_t i = 0; i < size_and_type.first; ++i)


11622                    {


11623                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))


11624                        {


11625                            return false;


11626                        }


11627                    }


11628                }


11629            }


11630            else


11631            {


11632                for (std::size_t i = 0; i < size_and_type.first; ++i)


11633                {


11634                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))


11635                    {


11636                        return false;


11637                    }


11638                }


11639            }


11640        }


11641        else


11642        {


11643            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))


11644            {


11645                return false;


11646            }


11647


11648            while (current != ']')


11649            {


11650                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))


11651                {


11652                    return false;


11653                }


11654                get_ignore_noop();


11655            }


11656        }


11657


11658        return sax->end_array();


11659    }


11660


11661    /*!


11662    @return whether object creation completed


11663    */


11664    bool get_ubjson_object()


11665    {


11666        std::pair<std::size_t, char_int_type> size_and_type;


11667        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))


11668        {


11669            return false;


11670        }


11671


11672        // do not accept ND-array size in objects in BJData


11673        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)


11674        {


11675            auto last_token = get_token_string();


11676            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,


11677                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));


11678        }


11679


11680        string_t key;


11681        if (size_and_type.first != npos)


11682        {


11683            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))


11684            {


11685                return false;


11686            }


11687


11688            if (size_and_type.second != 0)


11689            {


11690                for (std::size_t i = 0; i < size_and_type.first; ++i)


11691                {


11692                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))


11693                    {


11694                        return false;


11695                    }


11696                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))


11697                    {


11698                        return false;


11699                    }


11700                    key.clear();


11701                }


11702            }


11703            else


11704            {


11705                for (std::size_t i = 0; i < size_and_type.first; ++i)


11706                {


11707                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))


11708                    {


11709                        return false;


11710                    }


11711                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))


11712                    {


11713                        return false;


11714                    }


11715                    key.clear();


11716                }


11717            }


11718        }


11719        else


11720        {


11721            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))


11722            {


11723                return false;


11724            }


11725


11726            while (current != '}')


11727            {


11728                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))


11729                {


11730                    return false;


11731                }


11732                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))


11733                {


11734                    return false;


11735                }


11736                get_ignore_noop();


11737                key.clear();


11738            }


11739        }


11740


11741        return sax->end_object();


11742    }


11743


11744    // Note, no reader for UBJSON binary types is implemented because they do


11745    // not exist


11746


11747    bool get_ubjson_high_precision_number()


11748    {


11749        // get size of following number string


11750        std::size_t size{};


11751        bool no_ndarray = true;


11752        auto res = get_ubjson_size_value(size, no_ndarray);


11753        if (JSON_HEDLEY_UNLIKELY(!res))


11754        {


11755            return res;


11756        }


11757


11758        // get number string


11759        std::vector<char> number_vector;


11760        for (std::size_t i = 0; i < size; ++i)


11761        {


11762            get();


11763            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))


11764            {


11765                return false;


11766            }


11767            number_vector.push_back(static_cast<char>(current));


11768        }


11769


11770        // parse number string


11771        using ia_type = decltype(detail::input_adapter(number_vector));


11772        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);


11773        const auto result_number = number_lexer.scan();


11774        const auto number_string = number_lexer.get_token_string();


11775        const auto result_remainder = number_lexer.scan();


11776


11777        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;


11778


11779        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))


11780        {


11781            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,


11782                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));


11783        }


11784


11785        switch (result_number)


11786        {


11787            case token_type::value_integer:


11788                return sax->number_integer(number_lexer.get_number_integer());


11789            case token_type::value_unsigned:


11790                return sax->number_unsigned(number_lexer.get_number_unsigned());


11791            case token_type::value_float:


11792                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));


11793            case token_type::uninitialized:


11794            case token_type::literal_true:


11795            case token_type::literal_false:


11796            case token_type::literal_null:


11797            case token_type::value_string:


11798            case token_type::begin_array:


11799            case token_type::begin_object:


11800            case token_type::end_array:


11801            case token_type::end_object:


11802            case token_type::name_separator:


11803            case token_type::value_separator:


11804            case token_type::parse_error:


11805            case token_type::end_of_input:


11806            case token_type::literal_or_value:


11807            default:


11808                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,


11809                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));


11810        }


11811    }


11812


11813    ///////////////////////


11814    // Utility functions //


11815    ///////////////////////


11816


11817    /*!


11818    @brief get next character from the input


11819


11820    This function provides the interface to the used input adapter. It does


11821    not throw in case the input reached EOF, but returns a -'ve valued


11822    `std::char_traits<char_type>::eof()` in that case.


11823


11824    @return character read from the input


11825    */


11826    char_int_type get()


11827    {


11828        ++chars_read;


11829        return current = ia.get_character();


11830    }


11831


11832    /*!


11833    @return character read from the input after ignoring all 'N' entries


11834    */


11835    char_int_type get_ignore_noop()


11836    {


11837        do


11838        {


11839            get();


11840        }


11841        while (current == 'N');


11842


11843        return current;


11844    }


11845


11846    /*


11847    @brief read a number from the input


11848


11849    @tparam NumberType the type of the number


11850    @param[in] format   the current format (for diagnostics)


11851    @param[out] result  number of type @a NumberType


11852


11853    @return whether conversion completed


11854


11855    @note This function needs to respect the system's endianness, because


11856          bytes in CBOR, MessagePack, and UBJSON are stored in network order


11857          (big endian) and therefore need reordering on little endian systems.


11858          On the other hand, BSON and BJData use little endian and should reorder


11859          on big endian systems.


11860    */


11861    template<typename NumberType, bool InputIsLittleEndian = false>


11862    bool get_number(const input_format_t format, NumberType& result)


11863    {


11864        // step 1: read input into array with system's byte order


11865        std::array<std::uint8_t, sizeof(NumberType)> vec{};


11866        for (std::size_t i = 0; i < sizeof(NumberType); ++i)


11867        {


11868            get();


11869            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))


11870            {


11871                return false;


11872            }


11873


11874            // reverse byte order prior to conversion if necessary


11875            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))


11876            {


11877                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);


11878            }


11879            else


11880            {


11881                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE


11882            }


11883        }


11884


11885        // step 2: convert array into number of type T and return


11886        std::memcpy(&result, vec.data(), sizeof(NumberType));


11887        return true;


11888    }


11889


11890    /*!


11891    @brief create a string by reading characters from the input


11892


11893    @tparam NumberType the type of the number


11894    @param[in] format the current format (for diagnostics)


11895    @param[in] len number of characters to read


11896    @param[out] result string created by reading @a len bytes


11897


11898    @return whether string creation completed


11899


11900    @note We can not reserve @a len bytes for the result, because @a len


11901          may be too large. Usually, @ref unexpect_eof() detects the end of


11902          the input before we run out of string memory.


11903    */


11904    template<typename NumberType>


11905    bool get_string(const input_format_t format,


11906                    const NumberType len,


11907                    string_t& result)


11908    {


11909        bool success = true;


11910        for (NumberType i = 0; i < len; i++)


11911        {


11912            get();


11913            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))


11914            {


11915                success = false;


11916                break;


11917            }


11918            result.push_back(static_cast<typename string_t::value_type>(current));


11919        }


11920        return success;


11921    }


11922


11923    /*!


11924    @brief create a byte array by reading bytes from the input


11925


11926    @tparam NumberType the type of the number


11927    @param[in] format the current format (for diagnostics)


11928    @param[in] len number of bytes to read


11929    @param[out] result byte array created by reading @a len bytes


11930


11931    @return whether byte array creation completed


11932


11933    @note We can not reserve @a len bytes for the result, because @a len


11934          may be too large. Usually, @ref unexpect_eof() detects the end of


11935          the input before we run out of memory.


11936    */


11937    template<typename NumberType>


11938    bool get_binary(const input_format_t format,


11939                    const NumberType len,


11940                    binary_t& result)


11941    {


11942        bool success = true;


11943        for (NumberType i = 0; i < len; i++)


11944        {


11945            get();


11946            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))


11947            {


11948                success = false;


11949                break;


11950            }


11951            result.push_back(static_cast<std::uint8_t>(current));


11952        }


11953        return success;


11954    }


11955


11956    /*!


11957    @param[in] format   the current format (for diagnostics)


11958    @param[in] context  further context information (for diagnostics)


11959    @return whether the last read character is not EOF


11960    */


11961    JSON_HEDLEY_NON_NULL(3)


11962    bool unexpect_eof(const input_format_t format, const char* context) const


11963    {


11964        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))


11965        {


11966            return sax->parse_error(chars_read, "<end of file>",


11967                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));


11968        }


11969        return true;


11970    }


11971


11972    /*!


11973    @return a string representation of the last read byte


11974    */


11975    std::string get_token_string() const


11976    {


11977        std::array<char, 3> cr{{}};


11978        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


11979        return std::string{cr.data()};


11980    }


11981


11982    /*!


11983    @param[in] format   the current format


11984    @param[in] detail   a detailed error message


11985    @param[in] context  further context information


11986    @return a message string to use in the parse_error exceptions


11987    */


11988    std::string exception_message(const input_format_t format,


11989                                  const std::string& detail,


11990                                  const std::string& context) const


11991    {


11992        std::string error_msg = "syntax error while parsing ";


11993


11994        switch (format)


11995        {


11996            case input_format_t::cbor:


11997                error_msg += "CBOR";


11998                break;


11999


12000            case input_format_t::msgpack:


12001                error_msg += "MessagePack";


12002                break;


12003


12004            case input_format_t::ubjson:


12005                error_msg += "UBJSON";


12006                break;


12007


12008            case input_format_t::bson:


12009                error_msg += "BSON";


12010                break;


12011


12012            case input_format_t::bjdata:


12013                error_msg += "BJData";


12014                break;


12015


12016            case input_format_t::json: // LCOV_EXCL_LINE


12017            default:            // LCOV_EXCL_LINE


12018                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


12019        }


12020


12021        return concat(error_msg, ' ', context, ": ", detail);


12022    }


12023


12024  private:


12025    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);


12026


12027    /// input adapter


12028    InputAdapterType ia;


12029


12030    /// the current character


12031    char_int_type current = std::char_traits<char_type>::eof();


12032


12033    /// the number of characters read


12034    std::size_t chars_read = 0;


12035


12036    /// whether we can assume little endianness


12037    const bool is_little_endian = little_endianness();


12038


12039    /// input format


12040    const input_format_t input_format = input_format_t::json;


12041


12042    /// the SAX parser


12043    json_sax_t* sax = nullptr;


12044


12045    // excluded markers in bjdata optimized type


12046#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \


12047    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')


12048


12049#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \


12050    make_array<bjd_type>(                      \


12051    bjd_type{'C', "char"},                     \


12052    bjd_type{'D', "double"},                   \


12053    bjd_type{'I', "int16"},                    \


12054    bjd_type{'L', "int64"},                    \


12055    bjd_type{'M', "uint64"},                   \


12056    bjd_type{'U', "uint8"},                    \


12057    bjd_type{'d', "single"},                   \


12058    bjd_type{'i', "int8"},                     \


12059    bjd_type{'l', "int32"},                    \


12060    bjd_type{'m', "uint32"},                   \


12061    bjd_type{'u', "uint16"})


12062


12063  JSON_PRIVATE_UNLESS_TESTED:


12064    // lookup tables


12065    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)


12066    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =


12067        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;


12068


12069    using bjd_type = std::pair<char_int_type, string_t>;


12070    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)


12071    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =


12072        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;


12073


12074#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_


12075#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_


12076};


12077


12078#ifndef JSON_HAS_CPP_17


12079    template<typename BasicJsonType, typename InputAdapterType, typename SAX>


12080    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;


12081#endif


12082


12083}  // namespace detail


12084NLOHMANN_JSON_NAMESPACE_END


12085


12086// #include <nlohmann/detail/input/input_adapters.hpp>


12087


12088// #include <nlohmann/detail/input/lexer.hpp>


12089


12090// #include <nlohmann/detail/input/parser.hpp>


12091//     __ _____ _____ _____


12092//  __|  |   __|     |   | |  JSON for Modern C++


12093// |  |  |__   |  |  | | | |  version 3.11.2


12094// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


12095//


12096// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


12097// SPDX-License-Identifier: MIT


12098


12099


12100


12101#include <cmath> // isfinite


12102#include <cstdint> // uint8_t


12103#include <functional> // function


12104#include <string> // string


12105#include <utility> // move


12106#include <vector> // vector


12107


12108// #include <nlohmann/detail/exceptions.hpp>


12109


12110// #include <nlohmann/detail/input/input_adapters.hpp>


12111


12112// #include <nlohmann/detail/input/json_sax.hpp>


12113


12114// #include <nlohmann/detail/input/lexer.hpp>


12115


12116// #include <nlohmann/detail/macro_scope.hpp>


12117


12118// #include <nlohmann/detail/meta/is_sax.hpp>


12119


12120// #include <nlohmann/detail/string_concat.hpp>


12121


12122// #include <nlohmann/detail/value_t.hpp>


12123


12124


12125NLOHMANN_JSON_NAMESPACE_BEGIN


12126namespace detail


12127{


12128////////////


12129// parser //


12130////////////


12131


12132enum class parse_event_t : std::uint8_t


12133{


12134    /// the parser read `{` and started to process a JSON object


12135    object_start,


12136    /// the parser read `}` and finished processing a JSON object


12137    object_end,


12138    /// the parser read `[` and started to process a JSON array


12139    array_start,


12140    /// the parser read `]` and finished processing a JSON array


12141    array_end,


12142    /// the parser read a key of a value in an object


12143    key,


12144    /// the parser finished reading a JSON value


12145    value


12146};


12147


12148template<typename BasicJsonType>


12149using parser_callback_t =


12150    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;


12151


12152/*!


12153@brief syntax analysis


12154


12155This class implements a recursive descent parser.


12156*/


12157template<typename BasicJsonType, typename InputAdapterType>


12158class parser


12159{


12160    using number_integer_t = typename BasicJsonType::number_integer_t;


12161    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


12162    using number_float_t = typename BasicJsonType::number_float_t;


12163    using string_t = typename BasicJsonType::string_t;


12164    using lexer_t = lexer<BasicJsonType, InputAdapterType>;


12165    using token_type = typename lexer_t::token_type;


12166


12167  public:


12168    /// a parser reading from an input adapter


12169    explicit parser(InputAdapterType&& adapter,


12170                    const parser_callback_t<BasicJsonType> cb = nullptr,


12171                    const bool allow_exceptions_ = true,


12172                    const bool skip_comments = false)


12173        : callback(cb)


12174        , m_lexer(std::move(adapter), skip_comments)


12175        , allow_exceptions(allow_exceptions_)


12176    {


12177        // read first token


12178        get_token();


12179    }


12180


12181    /*!


12182    @brief public parser interface


12183


12184    @param[in] strict      whether to expect the last token to be EOF


12185    @param[in,out] result  parsed JSON value


12186


12187    @throw parse_error.101 in case of an unexpected token


12188    @throw parse_error.102 if to_unicode fails or surrogate error


12189    @throw parse_error.103 if to_unicode fails


12190    */


12191    void parse(const bool strict, BasicJsonType& result)


12192    {


12193        if (callback)


12194        {


12195            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);


12196            sax_parse_internal(&sdp);


12197


12198            // in strict mode, input must be completely read


12199            if (strict && (get_token() != token_type::end_of_input))


12200            {


12201                sdp.parse_error(m_lexer.get_position(),


12202                                m_lexer.get_token_string(),


12203                                parse_error::create(101, m_lexer.get_position(),


12204                                                    exception_message(token_type::end_of_input, "value"), nullptr));


12205            }


12206


12207            // in case of an error, return discarded value


12208            if (sdp.is_errored())


12209            {


12210                result = value_t::discarded;


12211                return;


12212            }


12213


12214            // set top-level value to null if it was discarded by the callback


12215            // function


12216            if (result.is_discarded())


12217            {


12218                result = nullptr;


12219            }


12220        }


12221        else


12222        {


12223            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);


12224            sax_parse_internal(&sdp);


12225


12226            // in strict mode, input must be completely read


12227            if (strict && (get_token() != token_type::end_of_input))


12228            {


12229                sdp.parse_error(m_lexer.get_position(),


12230                                m_lexer.get_token_string(),


12231                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));


12232            }


12233


12234            // in case of an error, return discarded value


12235            if (sdp.is_errored())


12236            {


12237                result = value_t::discarded;


12238                return;


12239            }


12240        }


12241


12242        result.assert_invariant();


12243    }


12244


12245    /*!


12246    @brief public accept interface


12247


12248    @param[in] strict  whether to expect the last token to be EOF


12249    @return whether the input is a proper JSON text


12250    */


12251    bool accept(const bool strict = true)


12252    {


12253        json_sax_acceptor<BasicJsonType> sax_acceptor;


12254        return sax_parse(&sax_acceptor, strict);


12255    }


12256


12257    template<typename SAX>


12258    JSON_HEDLEY_NON_NULL(2)


12259    bool sax_parse(SAX* sax, const bool strict = true)


12260    {


12261        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};


12262        const bool result = sax_parse_internal(sax);


12263


12264        // strict mode: next byte must be EOF


12265        if (result && strict && (get_token() != token_type::end_of_input))


12266        {


12267            return sax->parse_error(m_lexer.get_position(),


12268                                    m_lexer.get_token_string(),


12269                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));


12270        }


12271


12272        return result;


12273    }


12274


12275  private:


12276    template<typename SAX>


12277    JSON_HEDLEY_NON_NULL(2)


12278    bool sax_parse_internal(SAX* sax)


12279    {


12280        // stack to remember the hierarchy of structured values we are parsing


12281        // true = array; false = object


12282        std::vector<bool> states;


12283        // value to avoid a goto (see comment where set to true)


12284        bool skip_to_state_evaluation = false;


12285


12286        while (true)


12287        {


12288            if (!skip_to_state_evaluation)


12289            {


12290                // invariant: get_token() was called before each iteration


12291                switch (last_token)


12292                {


12293                    case token_type::begin_object:


12294                    {


12295                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))


12296                        {


12297                            return false;


12298                        }


12299


12300                        // closing } -> we are done


12301                        if (get_token() == token_type::end_object)


12302                        {


12303                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))


12304                            {


12305                                return false;


12306                            }


12307                            break;


12308                        }


12309


12310                        // parse key


12311                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))


12312                        {


12313                            return sax->parse_error(m_lexer.get_position(),


12314                                                    m_lexer.get_token_string(),


12315                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));


12316                        }


12317                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))


12318                        {


12319                            return false;


12320                        }


12321


12322                        // parse separator (:)


12323                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))


12324                        {


12325                            return sax->parse_error(m_lexer.get_position(),


12326                                                    m_lexer.get_token_string(),


12327                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));


12328                        }


12329


12330                        // remember we are now inside an object


12331                        states.push_back(false);


12332


12333                        // parse values


12334                        get_token();


12335                        continue;


12336                    }


12337


12338                    case token_type::begin_array:


12339                    {


12340                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))


12341                        {


12342                            return false;


12343                        }


12344


12345                        // closing ] -> we are done


12346                        if (get_token() == token_type::end_array)


12347                        {


12348                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))


12349                            {


12350                                return false;


12351                            }


12352                            break;


12353                        }


12354


12355                        // remember we are now inside an array


12356                        states.push_back(true);


12357


12358                        // parse values (no need to call get_token)


12359                        continue;


12360                    }


12361


12362                    case token_type::value_float:


12363                    {


12364                        const auto res = m_lexer.get_number_float();


12365


12366                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))


12367                        {


12368                            return sax->parse_error(m_lexer.get_position(),


12369                                                    m_lexer.get_token_string(),


12370                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));


12371                        }


12372


12373                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))


12374                        {


12375                            return false;


12376                        }


12377


12378                        break;


12379                    }


12380


12381                    case token_type::literal_false:


12382                    {


12383                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))


12384                        {


12385                            return false;


12386                        }


12387                        break;


12388                    }


12389


12390                    case token_type::literal_null:


12391                    {


12392                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))


12393                        {


12394                            return false;


12395                        }


12396                        break;


12397                    }


12398


12399                    case token_type::literal_true:


12400                    {


12401                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))


12402                        {


12403                            return false;


12404                        }


12405                        break;


12406                    }


12407


12408                    case token_type::value_integer:


12409                    {


12410                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))


12411                        {


12412                            return false;


12413                        }


12414                        break;


12415                    }


12416


12417                    case token_type::value_string:


12418                    {


12419                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))


12420                        {


12421                            return false;


12422                        }


12423                        break;


12424                    }


12425


12426                    case token_type::value_unsigned:


12427                    {


12428                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))


12429                        {


12430                            return false;


12431                        }


12432                        break;


12433                    }


12434


12435                    case token_type::parse_error:


12436                    {


12437                        // using "uninitialized" to avoid "expected" message


12438                        return sax->parse_error(m_lexer.get_position(),


12439                                                m_lexer.get_token_string(),


12440                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));


12441                    }


12442


12443                    case token_type::uninitialized:


12444                    case token_type::end_array:


12445                    case token_type::end_object:


12446                    case token_type::name_separator:


12447                    case token_type::value_separator:


12448                    case token_type::end_of_input:


12449                    case token_type::literal_or_value:


12450                    default: // the last token was unexpected


12451                    {


12452                        return sax->parse_error(m_lexer.get_position(),


12453                                                m_lexer.get_token_string(),


12454                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));


12455                    }


12456                }


12457            }


12458            else


12459            {


12460                skip_to_state_evaluation = false;


12461            }


12462


12463            // we reached this line after we successfully parsed a value


12464            if (states.empty())


12465            {


12466                // empty stack: we reached the end of the hierarchy: done


12467                return true;


12468            }


12469


12470            if (states.back())  // array


12471            {


12472                // comma -> next value


12473                if (get_token() == token_type::value_separator)


12474                {


12475                    // parse a new value


12476                    get_token();


12477                    continue;


12478                }


12479


12480                // closing ]


12481                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))


12482                {


12483                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))


12484                    {


12485                        return false;


12486                    }


12487


12488                    // We are done with this array. Before we can parse a


12489                    // new value, we need to evaluate the new state first.


12490                    // By setting skip_to_state_evaluation to false, we


12491                    // are effectively jumping to the beginning of this if.


12492                    JSON_ASSERT(!states.empty());


12493                    states.pop_back();


12494                    skip_to_state_evaluation = true;


12495                    continue;


12496                }


12497


12498                return sax->parse_error(m_lexer.get_position(),


12499                                        m_lexer.get_token_string(),


12500                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));


12501            }


12502


12503            // states.back() is false -> object


12504


12505            // comma -> next value


12506            if (get_token() == token_type::value_separator)


12507            {


12508                // parse key


12509                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))


12510                {


12511                    return sax->parse_error(m_lexer.get_position(),


12512                                            m_lexer.get_token_string(),


12513                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));


12514                }


12515


12516                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))


12517                {


12518                    return false;


12519                }


12520


12521                // parse separator (:)


12522                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))


12523                {


12524                    return sax->parse_error(m_lexer.get_position(),


12525                                            m_lexer.get_token_string(),


12526                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));


12527                }


12528


12529                // parse values


12530                get_token();


12531                continue;


12532            }


12533


12534            // closing }


12535            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))


12536            {


12537                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))


12538                {


12539                    return false;


12540                }


12541


12542                // We are done with this object. Before we can parse a


12543                // new value, we need to evaluate the new state first.


12544                // By setting skip_to_state_evaluation to false, we


12545                // are effectively jumping to the beginning of this if.


12546                JSON_ASSERT(!states.empty());


12547                states.pop_back();


12548                skip_to_state_evaluation = true;


12549                continue;


12550            }


12551


12552            return sax->parse_error(m_lexer.get_position(),


12553                                    m_lexer.get_token_string(),


12554                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));


12555        }


12556    }


12557


12558    /// get next token from lexer


12559    token_type get_token()


12560    {


12561        return last_token = m_lexer.scan();


12562    }


12563


12564    std::string exception_message(const token_type expected, const std::string& context)


12565    {


12566        std::string error_msg = "syntax error ";


12567


12568        if (!context.empty())


12569        {


12570            error_msg += concat("while parsing ", context, ' ');


12571        }


12572


12573        error_msg += "- ";


12574


12575        if (last_token == token_type::parse_error)


12576        {


12577            error_msg += concat(m_lexer.get_error_message(), "; last read: '",


12578                                m_lexer.get_token_string(), '\'');


12579        }


12580        else


12581        {


12582            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));


12583        }


12584


12585        if (expected != token_type::uninitialized)


12586        {


12587            error_msg += concat("; expected ", lexer_t::token_type_name(expected));


12588        }


12589


12590        return error_msg;


12591    }


12592


12593  private:


12594    /// callback function


12595    const parser_callback_t<BasicJsonType> callback = nullptr;


12596    /// the type of the last read token


12597    token_type last_token = token_type::uninitialized;


12598    /// the lexer


12599    lexer_t m_lexer;


12600    /// whether to throw exceptions in case of errors


12601    const bool allow_exceptions = true;


12602};


12603


12604}  // namespace detail


12605NLOHMANN_JSON_NAMESPACE_END


12606


12607// #include <nlohmann/detail/iterators/internal_iterator.hpp>


12608//     __ _____ _____ _____


12609//  __|  |   __|     |   | |  JSON for Modern C++


12610// |  |  |__   |  |  | | | |  version 3.11.2


12611// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


12612//


12613// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


12614// SPDX-License-Identifier: MIT


12615


12616


12617


12618// #include <nlohmann/detail/abi_macros.hpp>


12619


12620// #include <nlohmann/detail/iterators/primitive_iterator.hpp>


12621//     __ _____ _____ _____


12622//  __|  |   __|     |   | |  JSON for Modern C++


12623// |  |  |__   |  |  | | | |  version 3.11.2


12624// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


12625//


12626// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


12627// SPDX-License-Identifier: MIT


12628


12629


12630


12631#include <cstddef> // ptrdiff_t


12632#include <limits>  // numeric_limits


12633


12634// #include <nlohmann/detail/macro_scope.hpp>


12635


12636


12637NLOHMANN_JSON_NAMESPACE_BEGIN


12638namespace detail


12639{


12640


12641/*


12642@brief an iterator for primitive JSON types


12643


12644This class models an iterator for primitive JSON types (boolean, number,


12645string). It's only purpose is to allow the iterator/const_iterator classes


12646to "iterate" over primitive values. Internally, the iterator is modeled by


12647a `difference_type` variable. Value begin_value (`0`) models the begin,


12648end_value (`1`) models past the end.


12649*/


12650class primitive_iterator_t


12651{


12652  private:


12653    using difference_type = std::ptrdiff_t;


12654    static constexpr difference_type begin_value = 0;


12655    static constexpr difference_type end_value = begin_value + 1;


12656


12657  JSON_PRIVATE_UNLESS_TESTED:


12658    /// iterator as signed integer type


12659    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();


12660


12661  public:


12662    constexpr difference_type get_value() const noexcept


12663    {


12664        return m_it;


12665    }


12666


12667    /// set iterator to a defined beginning


12668    void set_begin() noexcept


12669    {


12670        m_it = begin_value;


12671    }


12672


12673    /// set iterator to a defined past the end


12674    void set_end() noexcept


12675    {


12676        m_it = end_value;


12677    }


12678


12679    /// return whether the iterator can be dereferenced


12680    constexpr bool is_begin() const noexcept


12681    {


12682        return m_it == begin_value;


12683    }


12684


12685    /// return whether the iterator is at end


12686    constexpr bool is_end() const noexcept


12687    {


12688        return m_it == end_value;


12689    }


12690


12691    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept


12692    {


12693        return lhs.m_it == rhs.m_it;


12694    }


12695


12696    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept


12697    {


12698        return lhs.m_it < rhs.m_it;


12699    }


12700


12701    primitive_iterator_t operator+(difference_type n) noexcept


12702    {


12703        auto result = *this;


12704        result += n;


12705        return result;


12706    }


12707


12708    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept


12709    {


12710        return lhs.m_it - rhs.m_it;


12711    }


12712


12713    primitive_iterator_t& operator++() noexcept


12714    {


12715        ++m_it;


12716        return *this;


12717    }


12718


12719    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)


12720    {


12721        auto result = *this;


12722        ++m_it;


12723        return result;


12724    }


12725


12726    primitive_iterator_t& operator--() noexcept


12727    {


12728        --m_it;


12729        return *this;


12730    }


12731


12732    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)


12733    {


12734        auto result = *this;


12735        --m_it;


12736        return result;


12737    }


12738


12739    primitive_iterator_t& operator+=(difference_type n) noexcept


12740    {


12741        m_it += n;


12742        return *this;


12743    }


12744


12745    primitive_iterator_t& operator-=(difference_type n) noexcept


12746    {


12747        m_it -= n;


12748        return *this;


12749    }


12750};


12751


12752}  // namespace detail


12753NLOHMANN_JSON_NAMESPACE_END


12754


12755


12756NLOHMANN_JSON_NAMESPACE_BEGIN


12757namespace detail


12758{


12759


12760/*!


12761@brief an iterator value


12762


12763@note This structure could easily be a union, but MSVC currently does not allow


12764unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.


12765*/


12766template<typename BasicJsonType> struct internal_iterator


12767{


12768    /// iterator for JSON objects


12769    typename BasicJsonType::object_t::iterator object_iterator {};


12770    /// iterator for JSON arrays


12771    typename BasicJsonType::array_t::iterator array_iterator {};


12772    /// generic iterator for all other types


12773    primitive_iterator_t primitive_iterator {};


12774};


12775


12776}  // namespace detail


12777NLOHMANN_JSON_NAMESPACE_END


12778


12779// #include <nlohmann/detail/iterators/iter_impl.hpp>


12780//     __ _____ _____ _____


12781//  __|  |   __|     |   | |  JSON for Modern C++


12782// |  |  |__   |  |  | | | |  version 3.11.2


12783// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


12784//


12785// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


12786// SPDX-License-Identifier: MIT


12787


12788


12789


12790#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next


12791#include <type_traits> // conditional, is_const, remove_const


12792


12793// #include <nlohmann/detail/exceptions.hpp>


12794


12795// #include <nlohmann/detail/iterators/internal_iterator.hpp>


12796


12797// #include <nlohmann/detail/iterators/primitive_iterator.hpp>


12798


12799// #include <nlohmann/detail/macro_scope.hpp>


12800


12801// #include <nlohmann/detail/meta/cpp_future.hpp>


12802


12803// #include <nlohmann/detail/meta/type_traits.hpp>


12804


12805// #include <nlohmann/detail/value_t.hpp>


12806


12807


12808NLOHMANN_JSON_NAMESPACE_BEGIN


12809namespace detail


12810{


12811


12812// forward declare, to be able to friend it later on


12813template<typename IteratorType> class iteration_proxy;


12814template<typename IteratorType> class iteration_proxy_value;


12815


12816/*!


12817@brief a template for a bidirectional iterator for the @ref basic_json class


12818This class implements a both iterators (iterator and const_iterator) for the


12819@ref basic_json class.


12820@note An iterator is called *initialized* when a pointer to a JSON value has


12821      been set (e.g., by a constructor or a copy assignment). If the iterator is


12822      default-constructed, it is *uninitialized* and most methods are undefined.


12823      **The library uses assertions to detect calls on uninitialized iterators.**


12824@requirement The class satisfies the following concept requirements:


12825-


12826[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):


12827  The iterator that can be moved can be moved in both directions (i.e.


12828  incremented and decremented).


12829@since version 1.0.0, simplified in version 2.0.9, change to bidirectional


12830       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)


12831*/


12832template<typename BasicJsonType>


12833class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)


12834{


12835    /// the iterator with BasicJsonType of different const-ness


12836    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;


12837    /// allow basic_json to access private members


12838    friend other_iter_impl;


12839    friend BasicJsonType;


12840    friend iteration_proxy<iter_impl>;


12841    friend iteration_proxy_value<iter_impl>;


12842


12843    using object_t = typename BasicJsonType::object_t;


12844    using array_t = typename BasicJsonType::array_t;


12845    // make sure BasicJsonType is basic_json or const basic_json


12846    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,


12847                  "iter_impl only accepts (const) basic_json");


12848    // superficial check for the LegacyBidirectionalIterator named requirement


12849    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value


12850                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,


12851                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");


12852


12853  public:


12854    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.


12855    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.


12856    /// A user-defined iterator should provide publicly accessible typedefs named


12857    /// iterator_category, value_type, difference_type, pointer, and reference.


12858    /// Note that value_type is required to be non-const, even for constant iterators.


12859    using iterator_category = std::bidirectional_iterator_tag;


12860


12861    /// the type of the values when the iterator is dereferenced


12862    using value_type = typename BasicJsonType::value_type;


12863    /// a type to represent differences between iterators


12864    using difference_type = typename BasicJsonType::difference_type;


12865    /// defines a pointer to the type iterated over (value_type)


12866    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,


12867          typename BasicJsonType::const_pointer,


12868          typename BasicJsonType::pointer>::type;


12869    /// defines a reference to the type iterated over (value_type)


12870    using reference =


12871        typename std::conditional<std::is_const<BasicJsonType>::value,


12872        typename BasicJsonType::const_reference,


12873        typename BasicJsonType::reference>::type;


12874


12875    iter_impl() = default;


12876    ~iter_impl() = default;


12877    iter_impl(iter_impl&&) noexcept = default;


12878    iter_impl& operator=(iter_impl&&) noexcept = default;


12879


12880    /*!


12881    @brief constructor for a given JSON instance


12882    @param[in] object  pointer to a JSON object for this iterator


12883    @pre object != nullptr


12884    @post The iterator is initialized; i.e. `m_object != nullptr`.


12885    */


12886    explicit iter_impl(pointer object) noexcept : m_object(object)


12887    {


12888        JSON_ASSERT(m_object != nullptr);


12889


12890        switch (m_object->m_type)


12891        {


12892            case value_t::object:


12893            {


12894                m_it.object_iterator = typename object_t::iterator();


12895                break;


12896            }


12897


12898            case value_t::array:


12899            {


12900                m_it.array_iterator = typename array_t::iterator();


12901                break;


12902            }


12903


12904            case value_t::null:


12905            case value_t::string:


12906            case value_t::boolean:


12907            case value_t::number_integer:


12908            case value_t::number_unsigned:


12909            case value_t::number_float:


12910            case value_t::binary:


12911            case value_t::discarded:


12912            default:


12913            {


12914                m_it.primitive_iterator = primitive_iterator_t();


12915                break;


12916            }


12917        }


12918    }


12919


12920    /*!


12921    @note The conventional copy constructor and copy assignment are implicitly


12922          defined. Combined with the following converting constructor and


12923          assignment, they support: (1) copy from iterator to iterator, (2)


12924          copy from const iterator to const iterator, and (3) conversion from


12925          iterator to const iterator. However conversion from const iterator


12926          to iterator is not defined.


12927    */


12928


12929    /*!


12930    @brief const copy constructor


12931    @param[in] other const iterator to copy from


12932    @note This copy constructor had to be defined explicitly to circumvent a bug


12933          occurring on msvc v19.0 compiler (VS 2015) debug build. For more


12934          information refer to: https://github.com/nlohmann/json/issues/1608


12935    */


12936    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept


12937        : m_object(other.m_object), m_it(other.m_it)


12938    {}


12939


12940    /*!


12941    @brief converting assignment


12942    @param[in] other const iterator to copy from


12943    @return const/non-const iterator


12944    @note It is not checked whether @a other is initialized.


12945    */


12946    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept


12947    {


12948        if (&other != this)


12949        {


12950            m_object = other.m_object;


12951            m_it = other.m_it;


12952        }


12953        return *this;


12954    }


12955


12956    /*!


12957    @brief converting constructor


12958    @param[in] other  non-const iterator to copy from


12959    @note It is not checked whether @a other is initialized.


12960    */


12961    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept


12962        : m_object(other.m_object), m_it(other.m_it)


12963    {}


12964


12965    /*!


12966    @brief converting assignment


12967    @param[in] other  non-const iterator to copy from


12968    @return const/non-const iterator


12969    @note It is not checked whether @a other is initialized.


12970    */


12971    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)


12972    {


12973        m_object = other.m_object;


12974        m_it = other.m_it;


12975        return *this;


12976    }


12977


12978  JSON_PRIVATE_UNLESS_TESTED:


12979    /*!


12980    @brief set the iterator to the first value


12981    @pre The iterator is initialized; i.e. `m_object != nullptr`.


12982    */


12983    void set_begin() noexcept


12984    {


12985        JSON_ASSERT(m_object != nullptr);


12986


12987        switch (m_object->m_type)


12988        {


12989            case value_t::object:


12990            {


12991                m_it.object_iterator = m_object->m_value.object->begin();


12992                break;


12993            }


12994


12995            case value_t::array:


12996            {


12997                m_it.array_iterator = m_object->m_value.array->begin();


12998                break;


12999            }


13000


13001            case value_t::null:


13002            {


13003                // set to end so begin()==end() is true: null is empty


13004                m_it.primitive_iterator.set_end();


13005                break;


13006            }


13007


13008            case value_t::string:


13009            case value_t::boolean:


13010            case value_t::number_integer:


13011            case value_t::number_unsigned:


13012            case value_t::number_float:


13013            case value_t::binary:


13014            case value_t::discarded:


13015            default:


13016            {


13017                m_it.primitive_iterator.set_begin();


13018                break;


13019            }


13020        }


13021    }


13022


13023    /*!


13024    @brief set the iterator past the last value


13025    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13026    */


13027    void set_end() noexcept


13028    {


13029        JSON_ASSERT(m_object != nullptr);


13030


13031        switch (m_object->m_type)


13032        {


13033            case value_t::object:


13034            {


13035                m_it.object_iterator = m_object->m_value.object->end();


13036                break;


13037            }


13038


13039            case value_t::array:


13040            {


13041                m_it.array_iterator = m_object->m_value.array->end();


13042                break;


13043            }


13044


13045            case value_t::null:


13046            case value_t::string:


13047            case value_t::boolean:


13048            case value_t::number_integer:


13049            case value_t::number_unsigned:


13050            case value_t::number_float:


13051            case value_t::binary:


13052            case value_t::discarded:


13053            default:


13054            {


13055                m_it.primitive_iterator.set_end();


13056                break;


13057            }


13058        }


13059    }


13060


13061  public:


13062    /*!


13063    @brief return a reference to the value pointed to by the iterator


13064    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13065    */


13066    reference operator*() const


13067    {


13068        JSON_ASSERT(m_object != nullptr);


13069


13070        switch (m_object->m_type)


13071        {


13072            case value_t::object:


13073            {


13074                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());


13075                return m_it.object_iterator->second;


13076            }


13077


13078            case value_t::array:


13079            {


13080                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());


13081                return *m_it.array_iterator;


13082            }


13083


13084            case value_t::null:


13085                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));


13086


13087            case value_t::string:


13088            case value_t::boolean:


13089            case value_t::number_integer:


13090            case value_t::number_unsigned:


13091            case value_t::number_float:


13092            case value_t::binary:


13093            case value_t::discarded:


13094            default:


13095            {


13096                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))


13097                {


13098                    return *m_object;


13099                }


13100


13101                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));


13102            }


13103        }


13104    }


13105


13106    /*!


13107    @brief dereference the iterator


13108    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13109    */


13110    pointer operator->() const


13111    {


13112        JSON_ASSERT(m_object != nullptr);


13113


13114        switch (m_object->m_type)


13115        {


13116            case value_t::object:


13117            {


13118                JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());


13119                return &(m_it.object_iterator->second);


13120            }


13121


13122            case value_t::array:


13123            {


13124                JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());


13125                return &*m_it.array_iterator;


13126            }


13127


13128            case value_t::null:


13129            case value_t::string:


13130            case value_t::boolean:


13131            case value_t::number_integer:


13132            case value_t::number_unsigned:


13133            case value_t::number_float:


13134            case value_t::binary:


13135            case value_t::discarded:


13136            default:


13137            {


13138                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))


13139                {


13140                    return m_object;


13141                }


13142


13143                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));


13144            }


13145        }


13146    }


13147


13148    /*!


13149    @brief post-increment (it++)


13150    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13151    */


13152    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)


13153    {


13154        auto result = *this;


13155        ++(*this);


13156        return result;


13157    }


13158


13159    /*!


13160    @brief pre-increment (++it)


13161    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13162    */


13163    iter_impl& operator++()


13164    {


13165        JSON_ASSERT(m_object != nullptr);


13166


13167        switch (m_object->m_type)


13168        {


13169            case value_t::object:


13170            {


13171                std::advance(m_it.object_iterator, 1);


13172                break;


13173            }


13174


13175            case value_t::array:


13176            {


13177                std::advance(m_it.array_iterator, 1);


13178                break;


13179            }


13180


13181            case value_t::null:


13182            case value_t::string:


13183            case value_t::boolean:


13184            case value_t::number_integer:


13185            case value_t::number_unsigned:


13186            case value_t::number_float:


13187            case value_t::binary:


13188            case value_t::discarded:


13189            default:


13190            {


13191                ++m_it.primitive_iterator;


13192                break;


13193            }


13194        }


13195


13196        return *this;


13197    }


13198


13199    /*!


13200    @brief post-decrement (it--)


13201    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13202    */


13203    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)


13204    {


13205        auto result = *this;


13206        --(*this);


13207        return result;


13208    }


13209


13210    /*!


13211    @brief pre-decrement (--it)


13212    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13213    */


13214    iter_impl& operator--()


13215    {


13216        JSON_ASSERT(m_object != nullptr);


13217


13218        switch (m_object->m_type)


13219        {


13220            case value_t::object:


13221            {


13222                std::advance(m_it.object_iterator, -1);


13223                break;


13224            }


13225


13226            case value_t::array:


13227            {


13228                std::advance(m_it.array_iterator, -1);


13229                break;


13230            }


13231


13232            case value_t::null:


13233            case value_t::string:


13234            case value_t::boolean:


13235            case value_t::number_integer:


13236            case value_t::number_unsigned:


13237            case value_t::number_float:


13238            case value_t::binary:


13239            case value_t::discarded:


13240            default:


13241            {


13242                --m_it.primitive_iterator;


13243                break;


13244            }


13245        }


13246


13247        return *this;


13248    }


13249


13250    /*!


13251    @brief comparison: equal


13252    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13253    */


13254    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 >


13255    bool operator==(const IterImpl& other) const


13256    {


13257        // if objects are not the same, the comparison is undefined


13258        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))


13259        {


13260            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));


13261        }


13262


13263        JSON_ASSERT(m_object != nullptr);


13264


13265        switch (m_object->m_type)


13266        {


13267            case value_t::object:


13268                return (m_it.object_iterator == other.m_it.object_iterator);


13269


13270            case value_t::array:


13271                return (m_it.array_iterator == other.m_it.array_iterator);


13272


13273            case value_t::null:


13274            case value_t::string:


13275            case value_t::boolean:


13276            case value_t::number_integer:


13277            case value_t::number_unsigned:


13278            case value_t::number_float:


13279            case value_t::binary:


13280            case value_t::discarded:


13281            default:


13282                return (m_it.primitive_iterator == other.m_it.primitive_iterator);


13283        }


13284    }


13285


13286    /*!


13287    @brief comparison: not equal


13288    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13289    */


13290    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 >


13291    bool operator!=(const IterImpl& other) const


13292    {


13293        return !operator==(other);


13294    }


13295


13296    /*!


13297    @brief comparison: smaller


13298    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13299    */


13300    bool operator<(const iter_impl& other) const


13301    {


13302        // if objects are not the same, the comparison is undefined


13303        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))


13304        {


13305            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));


13306        }


13307


13308        JSON_ASSERT(m_object != nullptr);


13309


13310        switch (m_object->m_type)


13311        {


13312            case value_t::object:


13313                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));


13314


13315            case value_t::array:


13316                return (m_it.array_iterator < other.m_it.array_iterator);


13317


13318            case value_t::null:


13319            case value_t::string:


13320            case value_t::boolean:


13321            case value_t::number_integer:


13322            case value_t::number_unsigned:


13323            case value_t::number_float:


13324            case value_t::binary:


13325            case value_t::discarded:


13326            default:


13327                return (m_it.primitive_iterator < other.m_it.primitive_iterator);


13328        }


13329    }


13330


13331    /*!


13332    @brief comparison: less than or equal


13333    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13334    */


13335    bool operator<=(const iter_impl& other) const


13336    {


13337        return !other.operator < (*this);


13338    }


13339


13340    /*!


13341    @brief comparison: greater than


13342    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13343    */


13344    bool operator>(const iter_impl& other) const


13345    {


13346        return !operator<=(other);


13347    }


13348


13349    /*!


13350    @brief comparison: greater than or equal


13351    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13352    */


13353    bool operator>=(const iter_impl& other) const


13354    {


13355        return !operator<(other);


13356    }


13357


13358    /*!


13359    @brief add to iterator


13360    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13361    */


13362    iter_impl& operator+=(difference_type i)


13363    {


13364        JSON_ASSERT(m_object != nullptr);


13365


13366        switch (m_object->m_type)


13367        {


13368            case value_t::object:


13369                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));


13370


13371            case value_t::array:


13372            {


13373                std::advance(m_it.array_iterator, i);


13374                break;


13375            }


13376


13377            case value_t::null:


13378            case value_t::string:


13379            case value_t::boolean:


13380            case value_t::number_integer:


13381            case value_t::number_unsigned:


13382            case value_t::number_float:


13383            case value_t::binary:


13384            case value_t::discarded:


13385            default:


13386            {


13387                m_it.primitive_iterator += i;


13388                break;


13389            }


13390        }


13391


13392        return *this;


13393    }


13394


13395    /*!


13396    @brief subtract from iterator


13397    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13398    */


13399    iter_impl& operator-=(difference_type i)


13400    {


13401        return operator+=(-i);


13402    }


13403


13404    /*!


13405    @brief add to iterator


13406    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13407    */


13408    iter_impl operator+(difference_type i) const


13409    {


13410        auto result = *this;


13411        result += i;


13412        return result;


13413    }


13414


13415    /*!


13416    @brief addition of distance and iterator


13417    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13418    */


13419    friend iter_impl operator+(difference_type i, const iter_impl& it)


13420    {


13421        auto result = it;


13422        result += i;


13423        return result;


13424    }


13425


13426    /*!


13427    @brief subtract from iterator


13428    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13429    */


13430    iter_impl operator-(difference_type i) const


13431    {


13432        auto result = *this;


13433        result -= i;


13434        return result;


13435    }


13436


13437    /*!


13438    @brief return difference


13439    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13440    */


13441    difference_type operator-(const iter_impl& other) const


13442    {


13443        JSON_ASSERT(m_object != nullptr);


13444


13445        switch (m_object->m_type)


13446        {


13447            case value_t::object:


13448                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));


13449


13450            case value_t::array:


13451                return m_it.array_iterator - other.m_it.array_iterator;


13452


13453            case value_t::null:


13454            case value_t::string:


13455            case value_t::boolean:


13456            case value_t::number_integer:


13457            case value_t::number_unsigned:


13458            case value_t::number_float:


13459            case value_t::binary:


13460            case value_t::discarded:


13461            default:


13462                return m_it.primitive_iterator - other.m_it.primitive_iterator;


13463        }


13464    }


13465


13466    /*!


13467    @brief access to successor


13468    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13469    */


13470    reference operator[](difference_type n) const


13471    {


13472        JSON_ASSERT(m_object != nullptr);


13473


13474        switch (m_object->m_type)


13475        {


13476            case value_t::object:


13477                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));


13478


13479            case value_t::array:


13480                return *std::next(m_it.array_iterator, n);


13481


13482            case value_t::null:


13483                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));


13484


13485            case value_t::string:


13486            case value_t::boolean:


13487            case value_t::number_integer:


13488            case value_t::number_unsigned:


13489            case value_t::number_float:


13490            case value_t::binary:


13491            case value_t::discarded:


13492            default:


13493            {


13494                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))


13495                {


13496                    return *m_object;


13497                }


13498


13499                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));


13500            }


13501        }


13502    }


13503


13504    /*!


13505    @brief return the key of an object iterator


13506    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13507    */


13508    const typename object_t::key_type& key() const


13509    {


13510        JSON_ASSERT(m_object != nullptr);


13511


13512        if (JSON_HEDLEY_LIKELY(m_object->is_object()))


13513        {


13514            return m_it.object_iterator->first;


13515        }


13516


13517        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));


13518    }


13519


13520    /*!


13521    @brief return the value of an iterator


13522    @pre The iterator is initialized; i.e. `m_object != nullptr`.


13523    */


13524    reference value() const


13525    {


13526        return operator*();


13527    }


13528


13529  JSON_PRIVATE_UNLESS_TESTED:


13530    /// associated JSON instance


13531    pointer m_object = nullptr;


13532    /// the actual iterator of the associated instance


13533    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};


13534};


13535


13536}  // namespace detail


13537NLOHMANN_JSON_NAMESPACE_END


13538


13539// #include <nlohmann/detail/iterators/iteration_proxy.hpp>


13540


13541// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>


13542//     __ _____ _____ _____


13543//  __|  |   __|     |   | |  JSON for Modern C++


13544// |  |  |__   |  |  | | | |  version 3.11.2


13545// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


13546//


13547// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


13548// SPDX-License-Identifier: MIT


13549


13550


13551


13552#include <cstddef> // ptrdiff_t


13553#include <iterator> // reverse_iterator


13554#include <utility> // declval


13555


13556// #include <nlohmann/detail/abi_macros.hpp>


13557


13558


13559NLOHMANN_JSON_NAMESPACE_BEGIN


13560namespace detail


13561{


13562


13563//////////////////////


13564// reverse_iterator //


13565//////////////////////


13566


13567/*!


13568@brief a template for a reverse iterator class


13569


13570@tparam Base the base iterator type to reverse. Valid types are @ref


13571iterator (to create @ref reverse_iterator) and @ref const_iterator (to


13572create @ref const_reverse_iterator).


13573


13574@requirement The class satisfies the following concept requirements:


13575-


13576[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):


13577  The iterator that can be moved can be moved in both directions (i.e.


13578  incremented and decremented).


13579- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):


13580  It is possible to write to the pointed-to element (only if @a Base is


13581  @ref iterator).


13582


13583@since version 1.0.0


13584*/


13585template<typename Base>


13586class json_reverse_iterator : public std::reverse_iterator<Base>


13587{


13588  public:


13589    using difference_type = std::ptrdiff_t;


13590    /// shortcut to the reverse iterator adapter


13591    using base_iterator = std::reverse_iterator<Base>;


13592    /// the reference type for the pointed-to element


13593    using reference = typename Base::reference;


13594


13595    /// create reverse iterator from iterator


13596    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept


13597        : base_iterator(it) {}


13598


13599    /// create reverse iterator from base class


13600    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}


13601


13602    /// post-increment (it++)


13603    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)


13604    {


13605        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));


13606    }


13607


13608    /// pre-increment (++it)


13609    json_reverse_iterator& operator++()


13610    {


13611        return static_cast<json_reverse_iterator&>(base_iterator::operator++());


13612    }


13613


13614    /// post-decrement (it--)


13615    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)


13616    {


13617        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));


13618    }


13619


13620    /// pre-decrement (--it)


13621    json_reverse_iterator& operator--()


13622    {


13623        return static_cast<json_reverse_iterator&>(base_iterator::operator--());


13624    }


13625


13626    /// add to iterator


13627    json_reverse_iterator& operator+=(difference_type i)


13628    {


13629        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));


13630    }


13631


13632    /// add to iterator


13633    json_reverse_iterator operator+(difference_type i) const


13634    {


13635        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));


13636    }


13637


13638    /// subtract from iterator


13639    json_reverse_iterator operator-(difference_type i) const


13640    {


13641        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));


13642    }


13643


13644    /// return difference


13645    difference_type operator-(const json_reverse_iterator& other) const


13646    {


13647        return base_iterator(*this) - base_iterator(other);


13648    }


13649


13650    /// access to successor


13651    reference operator[](difference_type n) const


13652    {


13653        return *(this->operator+(n));


13654    }


13655


13656    /// return the key of an object iterator


13657    auto key() const -> decltype(std::declval<Base>().key())


13658    {


13659        auto it = --this->base();


13660        return it.key();


13661    }


13662


13663    /// return the value of an iterator


13664    reference value() const


13665    {


13666        auto it = --this->base();


13667        return it.operator * ();


13668    }


13669};


13670


13671}  // namespace detail


13672NLOHMANN_JSON_NAMESPACE_END


13673


13674// #include <nlohmann/detail/iterators/primitive_iterator.hpp>


13675


13676// #include <nlohmann/detail/json_pointer.hpp>


13677//     __ _____ _____ _____


13678//  __|  |   __|     |   | |  JSON for Modern C++


13679// |  |  |__   |  |  | | | |  version 3.11.2


13680// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


13681//


13682// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


13683// SPDX-License-Identifier: MIT


13684


13685


13686


13687#include <algorithm> // all_of


13688#include <cctype> // isdigit


13689#include <cerrno> // errno, ERANGE


13690#include <cstdlib> // strtoull


13691#ifndef JSON_NO_IO


13692    #include <iosfwd> // ostream


13693#endif  // JSON_NO_IO


13694#include <limits> // max


13695#include <numeric> // accumulate


13696#include <string> // string


13697#include <utility> // move


13698#include <vector> // vector


13699


13700// #include <nlohmann/detail/exceptions.hpp>


13701


13702// #include <nlohmann/detail/macro_scope.hpp>


13703


13704// #include <nlohmann/detail/string_concat.hpp>


13705


13706// #include <nlohmann/detail/string_escape.hpp>


13707


13708// #include <nlohmann/detail/value_t.hpp>


13709


13710


13711NLOHMANN_JSON_NAMESPACE_BEGIN


13712


13713/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document


13714/// @sa https://json.nlohmann.me/api/json_pointer/


13715template<typename RefStringType>


13716class json_pointer


13717{


13718    // allow basic_json to access private members


13719    NLOHMANN_BASIC_JSON_TPL_DECLARATION


13720    friend class basic_json;


13721


13722    template<typename>


13723    friend class json_pointer;


13724


13725    template<typename T>


13726    struct string_t_helper


13727    {


13728        using type = T;


13729    };


13730


13731    NLOHMANN_BASIC_JSON_TPL_DECLARATION


13732    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>


13733    {


13734        using type = StringType;


13735    };


13736


13737  public:


13738    // for backwards compatibility accept BasicJsonType


13739    using string_t = typename string_t_helper<RefStringType>::type;


13740


13741    /// @brief create JSON pointer


13742    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/


13743    explicit json_pointer(const string_t& s = "")


13744        : reference_tokens(split(s))


13745    {}


13746


13747    /// @brief return a string representation of the JSON pointer


13748    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/


13749    string_t to_string() const


13750    {


13751        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),


13752                               string_t{},


13753                               [](const string_t& a, const string_t& b)


13754        {


13755            return detail::concat(a, '/', detail::escape(b));


13756        });


13757    }


13758


13759    /// @brief return a string representation of the JSON pointer


13760    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/


13761    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())


13762    operator string_t() const


13763    {


13764        return to_string();


13765    }


13766


13767#ifndef JSON_NO_IO


13768    /// @brief write string representation of the JSON pointer to stream


13769    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/


13770    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)


13771    {


13772        o << ptr.to_string();


13773        return o;


13774    }


13775#endif


13776


13777    /// @brief append another JSON pointer at the end of this JSON pointer


13778    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/


13779    json_pointer& operator/=(const json_pointer& ptr)


13780    {


13781        reference_tokens.insert(reference_tokens.end(),


13782                                ptr.reference_tokens.begin(),


13783                                ptr.reference_tokens.end());


13784        return *this;


13785    }


13786


13787    /// @brief append an unescaped reference token at the end of this JSON pointer


13788    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/


13789    json_pointer& operator/=(string_t token)


13790    {


13791        push_back(std::move(token));


13792        return *this;


13793    }


13794


13795    /// @brief append an array index at the end of this JSON pointer


13796    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/


13797    json_pointer& operator/=(std::size_t array_idx)


13798    {


13799        return *this /= std::to_string(array_idx);


13800    }


13801


13802    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer


13803    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/


13804    friend json_pointer operator/(const json_pointer& lhs,


13805                                  const json_pointer& rhs)


13806    {


13807        return json_pointer(lhs) /= rhs;


13808    }


13809


13810    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer


13811    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/


13812    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)


13813    {


13814        return json_pointer(lhs) /= std::move(token);


13815    }


13816


13817    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer


13818    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/


13819    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)


13820    {


13821        return json_pointer(lhs) /= array_idx;


13822    }


13823


13824    /// @brief returns the parent of this JSON pointer


13825    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/


13826    json_pointer parent_pointer() const


13827    {


13828        if (empty())


13829        {


13830            return *this;


13831        }


13832


13833        json_pointer res = *this;


13834        res.pop_back();


13835        return res;


13836    }


13837


13838    /// @brief remove last reference token


13839    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/


13840    void pop_back()


13841    {


13842        if (JSON_HEDLEY_UNLIKELY(empty()))


13843        {


13844            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));


13845        }


13846


13847        reference_tokens.pop_back();


13848    }


13849


13850    /// @brief return last reference token


13851    /// @sa https://json.nlohmann.me/api/json_pointer/back/


13852    const string_t& back() const


13853    {


13854        if (JSON_HEDLEY_UNLIKELY(empty()))


13855        {


13856            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));


13857        }


13858


13859        return reference_tokens.back();


13860    }


13861


13862    /// @brief append an unescaped token at the end of the reference pointer


13863    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/


13864    void push_back(const string_t& token)


13865    {


13866        reference_tokens.push_back(token);


13867    }


13868


13869    /// @brief append an unescaped token at the end of the reference pointer


13870    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/


13871    void push_back(string_t&& token)


13872    {


13873        reference_tokens.push_back(std::move(token));


13874    }


13875


13876    /// @brief return whether pointer points to the root document


13877    /// @sa https://json.nlohmann.me/api/json_pointer/empty/


13878    bool empty() const noexcept


13879    {


13880        return reference_tokens.empty();


13881    }


13882


13883  private:


13884    /*!


13885    @param[in] s  reference token to be converted into an array index


13886


13887    @return integer representation of @a s


13888


13889    @throw parse_error.106  if an array index begins with '0'


13890    @throw parse_error.109  if an array index begins not with a digit


13891    @throw out_of_range.404 if string @a s could not be converted to an integer


13892    @throw out_of_range.410 if an array index exceeds size_type


13893    */


13894    template<typename BasicJsonType>


13895    static typename BasicJsonType::size_type array_index(const string_t& s)


13896    {


13897        using size_type = typename BasicJsonType::size_type;


13898


13899        // error condition (cf. RFC 6901, Sect. 4)


13900        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))


13901        {


13902            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));


13903        }


13904


13905        // error condition (cf. RFC 6901, Sect. 4)


13906        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))


13907        {


13908            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));


13909        }


13910


13911        const char* p = s.c_str();


13912        char* p_end = nullptr;


13913        errno = 0; // strtoull doesn't reset errno


13914        unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)


13915        if (p == p_end // invalid input or empty string


13916                || errno == ERANGE // out of range


13917                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read


13918        {


13919            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));


13920        }


13921


13922        // only triggered on special platforms (like 32bit), see also


13923        // https://github.com/nlohmann/json/pull/2203


13924        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)


13925        {


13926            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE


13927        }


13928


13929        return static_cast<size_type>(res);


13930    }


13931


13932  JSON_PRIVATE_UNLESS_TESTED:


13933    json_pointer top() const


13934    {


13935        if (JSON_HEDLEY_UNLIKELY(empty()))


13936        {


13937            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));


13938        }


13939


13940        json_pointer result = *this;


13941        result.reference_tokens = {reference_tokens[0]};


13942        return result;


13943    }


13944


13945  private:


13946    /*!


13947    @brief create and return a reference to the pointed to value


13948


13949    @complexity Linear in the number of reference tokens.


13950


13951    @throw parse_error.109 if array index is not a number


13952    @throw type_error.313 if value cannot be unflattened


13953    */


13954    template<typename BasicJsonType>


13955    BasicJsonType& get_and_create(BasicJsonType& j) const


13956    {


13957        auto* result = &j;


13958


13959        // in case no reference tokens exist, return a reference to the JSON value


13960        // j which will be overwritten by a primitive value


13961        for (const auto& reference_token : reference_tokens)


13962        {


13963            switch (result->type())


13964            {


13965                case detail::value_t::null:


13966                {


13967                    if (reference_token == "0")


13968                    {


13969                        // start a new array if reference token is 0


13970                        result = &result->operator[](0);


13971                    }


13972                    else


13973                    {


13974                        // start a new object otherwise


13975                        result = &result->operator[](reference_token);


13976                    }


13977                    break;


13978                }


13979


13980                case detail::value_t::object:


13981                {


13982                    // create an entry in the object


13983                    result = &result->operator[](reference_token);


13984                    break;


13985                }


13986


13987                case detail::value_t::array:


13988                {


13989                    // create an entry in the array


13990                    result = &result->operator[](array_index<BasicJsonType>(reference_token));


13991                    break;


13992                }


13993


13994                /*


13995                The following code is only reached if there exists a reference


13996                token _and_ the current value is primitive. In this case, we have


13997                an error situation, because primitive values may only occur as


13998                single value; that is, with an empty list of reference tokens.


13999                */


14000                case detail::value_t::string:


14001                case detail::value_t::boolean:


14002                case detail::value_t::number_integer:


14003                case detail::value_t::number_unsigned:


14004                case detail::value_t::number_float:


14005                case detail::value_t::binary:


14006                case detail::value_t::discarded:


14007                default:


14008                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));


14009            }


14010        }


14011


14012        return *result;


14013    }


14014


14015    /*!


14016    @brief return a reference to the pointed to value


14017


14018    @note This version does not throw if a value is not present, but tries to


14019          create nested values instead. For instance, calling this function


14020          with pointer `"/this/that"` on a null value is equivalent to calling


14021          `operator[]("this").operator[]("that")` on that value, effectively


14022          changing the null value to an object.


14023


14024    @param[in] ptr  a JSON value


14025


14026    @return reference to the JSON value pointed to by the JSON pointer


14027


14028    @complexity Linear in the length of the JSON pointer.


14029


14030    @throw parse_error.106   if an array index begins with '0'


14031    @throw parse_error.109   if an array index was not a number


14032    @throw out_of_range.404  if the JSON pointer can not be resolved


14033    */


14034    template<typename BasicJsonType>


14035    BasicJsonType& get_unchecked(BasicJsonType* ptr) const


14036    {


14037        for (const auto& reference_token : reference_tokens)


14038        {


14039            // convert null values to arrays or objects before continuing


14040            if (ptr->is_null())


14041            {


14042                // check if reference token is a number


14043                const bool nums =


14044                    std::all_of(reference_token.begin(), reference_token.end(),


14045                                [](const unsigned char x)


14046                {


14047                    return std::isdigit(x);


14048                });


14049


14050                // change value to array for numbers or "-" or to object otherwise


14051                *ptr = (nums || reference_token == "-")


14052                       ? detail::value_t::array


14053                       : detail::value_t::object;


14054            }


14055


14056            switch (ptr->type())


14057            {


14058                case detail::value_t::object:


14059                {


14060                    // use unchecked object access


14061                    ptr = &ptr->operator[](reference_token);


14062                    break;


14063                }


14064


14065                case detail::value_t::array:


14066                {


14067                    if (reference_token == "-")


14068                    {


14069                        // explicitly treat "-" as index beyond the end


14070                        ptr = &ptr->operator[](ptr->m_value.array->size());


14071                    }


14072                    else


14073                    {


14074                        // convert array index to number; unchecked access


14075                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));


14076                    }


14077                    break;


14078                }


14079


14080                case detail::value_t::null:


14081                case detail::value_t::string:


14082                case detail::value_t::boolean:


14083                case detail::value_t::number_integer:


14084                case detail::value_t::number_unsigned:


14085                case detail::value_t::number_float:


14086                case detail::value_t::binary:


14087                case detail::value_t::discarded:


14088                default:


14089                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));


14090            }


14091        }


14092


14093        return *ptr;


14094    }


14095


14096    /*!


14097    @throw parse_error.106   if an array index begins with '0'


14098    @throw parse_error.109   if an array index was not a number


14099    @throw out_of_range.402  if the array index '-' is used


14100    @throw out_of_range.404  if the JSON pointer can not be resolved


14101    */


14102    template<typename BasicJsonType>


14103    BasicJsonType& get_checked(BasicJsonType* ptr) const


14104    {


14105        for (const auto& reference_token : reference_tokens)


14106        {


14107            switch (ptr->type())


14108            {


14109                case detail::value_t::object:


14110                {


14111                    // note: at performs range check


14112                    ptr = &ptr->at(reference_token);


14113                    break;


14114                }


14115


14116                case detail::value_t::array:


14117                {


14118                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))


14119                    {


14120                        // "-" always fails the range check


14121                        JSON_THROW(detail::out_of_range::create(402, detail::concat(


14122                                "array index '-' (", std::to_string(ptr->m_value.array->size()),


14123                                ") is out of range"), ptr));


14124                    }


14125


14126                    // note: at performs range check


14127                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));


14128                    break;


14129                }


14130


14131                case detail::value_t::null:


14132                case detail::value_t::string:


14133                case detail::value_t::boolean:


14134                case detail::value_t::number_integer:


14135                case detail::value_t::number_unsigned:


14136                case detail::value_t::number_float:


14137                case detail::value_t::binary:


14138                case detail::value_t::discarded:


14139                default:


14140                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));


14141            }


14142        }


14143


14144        return *ptr;


14145    }


14146


14147    /*!


14148    @brief return a const reference to the pointed to value


14149


14150    @param[in] ptr  a JSON value


14151


14152    @return const reference to the JSON value pointed to by the JSON


14153    pointer


14154


14155    @throw parse_error.106   if an array index begins with '0'


14156    @throw parse_error.109   if an array index was not a number


14157    @throw out_of_range.402  if the array index '-' is used


14158    @throw out_of_range.404  if the JSON pointer can not be resolved


14159    */


14160    template<typename BasicJsonType>


14161    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const


14162    {


14163        for (const auto& reference_token : reference_tokens)


14164        {


14165            switch (ptr->type())


14166            {


14167                case detail::value_t::object:


14168                {


14169                    // use unchecked object access


14170                    ptr = &ptr->operator[](reference_token);


14171                    break;


14172                }


14173


14174                case detail::value_t::array:


14175                {


14176                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))


14177                    {


14178                        // "-" cannot be used for const access


14179                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_value.array->size()), ") is out of range"), ptr));


14180                    }


14181


14182                    // use unchecked array access


14183                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));


14184                    break;


14185                }


14186


14187                case detail::value_t::null:


14188                case detail::value_t::string:


14189                case detail::value_t::boolean:


14190                case detail::value_t::number_integer:


14191                case detail::value_t::number_unsigned:


14192                case detail::value_t::number_float:


14193                case detail::value_t::binary:


14194                case detail::value_t::discarded:


14195                default:


14196                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));


14197            }


14198        }


14199


14200        return *ptr;


14201    }


14202


14203    /*!


14204    @throw parse_error.106   if an array index begins with '0'


14205    @throw parse_error.109   if an array index was not a number


14206    @throw out_of_range.402  if the array index '-' is used


14207    @throw out_of_range.404  if the JSON pointer can not be resolved


14208    */


14209    template<typename BasicJsonType>


14210    const BasicJsonType& get_checked(const BasicJsonType* ptr) const


14211    {


14212        for (const auto& reference_token : reference_tokens)


14213        {


14214            switch (ptr->type())


14215            {


14216                case detail::value_t::object:


14217                {


14218                    // note: at performs range check


14219                    ptr = &ptr->at(reference_token);


14220                    break;


14221                }


14222


14223                case detail::value_t::array:


14224                {


14225                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))


14226                    {


14227                        // "-" always fails the range check


14228                        JSON_THROW(detail::out_of_range::create(402, detail::concat(


14229                                "array index '-' (", std::to_string(ptr->m_value.array->size()),


14230                                ") is out of range"), ptr));


14231                    }


14232


14233                    // note: at performs range check


14234                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));


14235                    break;


14236                }


14237


14238                case detail::value_t::null:


14239                case detail::value_t::string:


14240                case detail::value_t::boolean:


14241                case detail::value_t::number_integer:


14242                case detail::value_t::number_unsigned:


14243                case detail::value_t::number_float:


14244                case detail::value_t::binary:


14245                case detail::value_t::discarded:


14246                default:


14247                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));


14248            }


14249        }


14250


14251        return *ptr;


14252    }


14253


14254    /*!


14255    @throw parse_error.106   if an array index begins with '0'


14256    @throw parse_error.109   if an array index was not a number


14257    */


14258    template<typename BasicJsonType>


14259    bool contains(const BasicJsonType* ptr) const


14260    {


14261        for (const auto& reference_token : reference_tokens)


14262        {


14263            switch (ptr->type())


14264            {


14265                case detail::value_t::object:


14266                {


14267                    if (!ptr->contains(reference_token))


14268                    {


14269                        // we did not find the key in the object


14270                        return false;


14271                    }


14272


14273                    ptr = &ptr->operator[](reference_token);


14274                    break;


14275                }


14276


14277                case detail::value_t::array:


14278                {


14279                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))


14280                    {


14281                        // "-" always fails the range check


14282                        return false;


14283                    }


14284                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))


14285                    {


14286                        // invalid char


14287                        return false;


14288                    }


14289                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))


14290                    {


14291                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))


14292                        {


14293                            // first char should be between '1' and '9'


14294                            return false;


14295                        }


14296                        for (std::size_t i = 1; i < reference_token.size(); i++)


14297                        {


14298                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))


14299                            {


14300                                // other char should be between '0' and '9'


14301                                return false;


14302                            }


14303                        }


14304                    }


14305


14306                    const auto idx = array_index<BasicJsonType>(reference_token);


14307                    if (idx >= ptr->size())


14308                    {


14309                        // index out of range


14310                        return false;


14311                    }


14312


14313                    ptr = &ptr->operator[](idx);


14314                    break;


14315                }


14316


14317                case detail::value_t::null:


14318                case detail::value_t::string:


14319                case detail::value_t::boolean:


14320                case detail::value_t::number_integer:


14321                case detail::value_t::number_unsigned:


14322                case detail::value_t::number_float:


14323                case detail::value_t::binary:


14324                case detail::value_t::discarded:


14325                default:


14326                {


14327                    // we do not expect primitive values if there is still a


14328                    // reference token to process


14329                    return false;


14330                }


14331            }


14332        }


14333


14334        // no reference token left means we found a primitive value


14335        return true;


14336    }


14337


14338    /*!


14339    @brief split the string input to reference tokens


14340


14341    @note This function is only called by the json_pointer constructor.


14342          All exceptions below are documented there.


14343


14344    @throw parse_error.107  if the pointer is not empty or begins with '/'


14345    @throw parse_error.108  if character '~' is not followed by '0' or '1'


14346    */


14347    static std::vector<string_t> split(const string_t& reference_string)


14348    {


14349        std::vector<string_t> result;


14350


14351        // special case: empty reference string -> no reference tokens


14352        if (reference_string.empty())


14353        {


14354            return result;


14355        }


14356


14357        // check if nonempty reference string begins with slash


14358        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))


14359        {


14360            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));


14361        }


14362


14363        // extract the reference tokens:


14364        // - slash: position of the last read slash (or end of string)


14365        // - start: position after the previous slash


14366        for (


14367            // search for the first slash after the first character


14368            std::size_t slash = reference_string.find_first_of('/', 1),


14369            // set the beginning of the first reference token


14370            start = 1;


14371            // we can stop if start == 0 (if slash == string_t::npos)


14372            start != 0;


14373            // set the beginning of the next reference token


14374            // (will eventually be 0 if slash == string_t::npos)


14375            start = (slash == string_t::npos) ? 0 : slash + 1,


14376            // find next slash


14377            slash = reference_string.find_first_of('/', start))


14378        {


14379            // use the text between the beginning of the reference token


14380            // (start) and the last slash (slash).


14381            auto reference_token = reference_string.substr(start, slash - start);


14382


14383            // check reference tokens are properly escaped


14384            for (std::size_t pos = reference_token.find_first_of('~');


14385                    pos != string_t::npos;


14386                    pos = reference_token.find_first_of('~', pos + 1))


14387            {


14388                JSON_ASSERT(reference_token[pos] == '~');


14389


14390                // ~ must be followed by 0 or 1


14391                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||


14392                                         (reference_token[pos + 1] != '0' &&


14393                                          reference_token[pos + 1] != '1')))


14394                {


14395                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));


14396                }


14397            }


14398


14399            // finally, store the reference token


14400            detail::unescape(reference_token);


14401            result.push_back(reference_token);


14402        }


14403


14404        return result;


14405    }


14406


14407  private:


14408    /*!


14409    @param[in] reference_string  the reference string to the current value


14410    @param[in] value             the value to consider


14411    @param[in,out] result        the result object to insert values to


14412


14413    @note Empty objects or arrays are flattened to `null`.


14414    */


14415    template<typename BasicJsonType>


14416    static void flatten(const string_t& reference_string,


14417                        const BasicJsonType& value,


14418                        BasicJsonType& result)


14419    {


14420        switch (value.type())


14421        {


14422            case detail::value_t::array:


14423            {


14424                if (value.m_value.array->empty())


14425                {


14426                    // flatten empty array as null


14427                    result[reference_string] = nullptr;


14428                }


14429                else


14430                {


14431                    // iterate array and use index as reference string


14432                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)


14433                    {


14434                        flatten(detail::concat(reference_string, '/', std::to_string(i)),


14435                                value.m_value.array->operator[](i), result);


14436                    }


14437                }


14438                break;


14439            }


14440


14441            case detail::value_t::object:


14442            {


14443                if (value.m_value.object->empty())


14444                {


14445                    // flatten empty object as null


14446                    result[reference_string] = nullptr;


14447                }


14448                else


14449                {


14450                    // iterate object and use keys as reference string


14451                    for (const auto& element : *value.m_value.object)


14452                    {


14453                        flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);


14454                    }


14455                }


14456                break;


14457            }


14458


14459            case detail::value_t::null:


14460            case detail::value_t::string:


14461            case detail::value_t::boolean:


14462            case detail::value_t::number_integer:


14463            case detail::value_t::number_unsigned:


14464            case detail::value_t::number_float:


14465            case detail::value_t::binary:


14466            case detail::value_t::discarded:


14467            default:


14468            {


14469                // add primitive value with its reference string


14470                result[reference_string] = value;


14471                break;


14472            }


14473        }


14474    }


14475


14476    /*!


14477    @param[in] value  flattened JSON


14478


14479    @return unflattened JSON


14480


14481    @throw parse_error.109 if array index is not a number


14482    @throw type_error.314  if value is not an object


14483    @throw type_error.315  if object values are not primitive


14484    @throw type_error.313  if value cannot be unflattened


14485    */


14486    template<typename BasicJsonType>


14487    static BasicJsonType


14488    unflatten(const BasicJsonType& value)


14489    {


14490        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))


14491        {


14492            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));


14493        }


14494


14495        BasicJsonType result;


14496


14497        // iterate the JSON object values


14498        for (const auto& element : *value.m_value.object)


14499        {


14500            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))


14501            {


14502                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));


14503            }


14504


14505            // assign value to reference pointed to by JSON pointer; Note that if


14506            // the JSON pointer is "" (i.e., points to the whole value), function


14507            // get_and_create returns a reference to result itself. An assignment


14508            // will then create a primitive value.


14509            json_pointer(element.first).get_and_create(result) = element.second;


14510        }


14511


14512        return result;


14513    }


14514


14515    // can't use conversion operator because of ambiguity


14516    json_pointer<string_t> convert() const&


14517    {


14518        json_pointer<string_t> result;


14519        result.reference_tokens = reference_tokens;


14520        return result;


14521    }


14522


14523    json_pointer<string_t> convert()&&


14524    {


14525        json_pointer<string_t> result;


14526        result.reference_tokens = std::move(reference_tokens);


14527        return result;


14528    }


14529


14530  public:


14531#if JSON_HAS_THREE_WAY_COMPARISON


14532    /// @brief compares two JSON pointers for equality


14533    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/


14534    template<typename RefStringTypeRhs>


14535    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept


14536    {


14537        return reference_tokens == rhs.reference_tokens;


14538    }


14539


14540    /// @brief compares JSON pointer and string for equality


14541    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/


14542    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))


14543    bool operator==(const string_t& rhs) const


14544    {


14545        return *this == json_pointer(rhs);


14546    }


14547


14548    /// @brief 3-way compares two JSON pointers


14549    template<typename RefStringTypeRhs>


14550    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*


14551    {


14552        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*


14553    }


14554#else


14555    /// @brief compares two JSON pointers for equality


14556    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/


14557    template<typename RefStringTypeLhs, typename RefStringTypeRhs>


14558    // NOLINTNEXTLINE(readability-redundant-declaration)


14559    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,


14560                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;


14561


14562    /// @brief compares JSON pointer and string for equality


14563    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/


14564    template<typename RefStringTypeLhs, typename StringType>


14565    // NOLINTNEXTLINE(readability-redundant-declaration)


14566    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,


14567                           const StringType& rhs);


14568


14569    /// @brief compares string and JSON pointer for equality


14570    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/


14571    template<typename RefStringTypeRhs, typename StringType>


14572    // NOLINTNEXTLINE(readability-redundant-declaration)


14573    friend bool operator==(const StringType& lhs,


14574                           const json_pointer<RefStringTypeRhs>& rhs);


14575


14576    /// @brief compares two JSON pointers for inequality


14577    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/


14578    template<typename RefStringTypeLhs, typename RefStringTypeRhs>


14579    // NOLINTNEXTLINE(readability-redundant-declaration)


14580    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,


14581                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;


14582


14583    /// @brief compares JSON pointer and string for inequality


14584    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/


14585    template<typename RefStringTypeLhs, typename StringType>


14586    // NOLINTNEXTLINE(readability-redundant-declaration)


14587    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,


14588                           const StringType& rhs);


14589


14590    /// @brief compares string and JSON pointer for inequality


14591    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/


14592    template<typename RefStringTypeRhs, typename StringType>


14593    // NOLINTNEXTLINE(readability-redundant-declaration)


14594    friend bool operator!=(const StringType& lhs,


14595                           const json_pointer<RefStringTypeRhs>& rhs);


14596


14597    /// @brief compares two JSON pointer for less-than


14598    template<typename RefStringTypeLhs, typename RefStringTypeRhs>


14599    // NOLINTNEXTLINE(readability-redundant-declaration)


14600    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,


14601                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;


14602#endif


14603


14604  private:


14605    /// the reference tokens


14606    std::vector<string_t> reference_tokens;


14607};


14608


14609#if !JSON_HAS_THREE_WAY_COMPARISON


14610// functions cannot be defined inside class due to ODR violations


14611template<typename RefStringTypeLhs, typename RefStringTypeRhs>


14612inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,


14613                       const json_pointer<RefStringTypeRhs>& rhs) noexcept


14614{


14615    return lhs.reference_tokens == rhs.reference_tokens;


14616}


14617


14618template<typename RefStringTypeLhs,


14619         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>


14620JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))


14621inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,


14622                       const StringType& rhs)


14623{


14624    return lhs == json_pointer<RefStringTypeLhs>(rhs);


14625}


14626


14627template<typename RefStringTypeRhs,


14628         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>


14629JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))


14630inline bool operator==(const StringType& lhs,


14631                       const json_pointer<RefStringTypeRhs>& rhs)


14632{


14633    return json_pointer<RefStringTypeRhs>(lhs) == rhs;


14634}


14635


14636template<typename RefStringTypeLhs, typename RefStringTypeRhs>


14637inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,


14638                       const json_pointer<RefStringTypeRhs>& rhs) noexcept


14639{


14640    return !(lhs == rhs);


14641}


14642


14643template<typename RefStringTypeLhs,


14644         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>


14645JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))


14646inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,


14647                       const StringType& rhs)


14648{


14649    return !(lhs == rhs);


14650}


14651


14652template<typename RefStringTypeRhs,


14653         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>


14654JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))


14655inline bool operator!=(const StringType& lhs,


14656                       const json_pointer<RefStringTypeRhs>& rhs)


14657{


14658    return !(lhs == rhs);


14659}


14660


14661template<typename RefStringTypeLhs, typename RefStringTypeRhs>


14662inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,


14663                      const json_pointer<RefStringTypeRhs>& rhs) noexcept


14664{


14665    return lhs.reference_tokens < rhs.reference_tokens;


14666}


14667#endif


14668


14669NLOHMANN_JSON_NAMESPACE_END


14670


14671// #include <nlohmann/detail/json_ref.hpp>


14672//     __ _____ _____ _____


14673//  __|  |   __|     |   | |  JSON for Modern C++


14674// |  |  |__   |  |  | | | |  version 3.11.2


14675// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


14676//


14677// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


14678// SPDX-License-Identifier: MIT


14679


14680


14681


14682#include <initializer_list>


14683#include <utility>


14684


14685// #include <nlohmann/detail/abi_macros.hpp>


14686


14687// #include <nlohmann/detail/meta/type_traits.hpp>


14688


14689


14690NLOHMANN_JSON_NAMESPACE_BEGIN


14691namespace detail


14692{


14693


14694template<typename BasicJsonType>


14695class json_ref


14696{


14697  public:


14698    using value_type = BasicJsonType;


14699


14700    json_ref(value_type&& value)


14701        : owned_value(std::move(value))


14702    {}


14703


14704    json_ref(const value_type& value)


14705        : value_ref(&value)


14706    {}


14707


14708    json_ref(std::initializer_list<json_ref> init)


14709        : owned_value(init)


14710    {}


14711


14712    template <


14713        class... Args,


14714        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >


14715    json_ref(Args && ... args)


14716        : owned_value(std::forward<Args>(args)...)


14717    {}


14718


14719    // class should be movable only


14720    json_ref(json_ref&&) noexcept = default;


14721    json_ref(const json_ref&) = delete;


14722    json_ref& operator=(const json_ref&) = delete;


14723    json_ref& operator=(json_ref&&) = delete;


14724    ~json_ref() = default;


14725


14726    value_type moved_or_copied() const


14727    {


14728        if (value_ref == nullptr)


14729        {


14730            return std::move(owned_value);


14731        }


14732        return *value_ref;


14733    }


14734


14735    value_type const& operator*() const


14736    {


14737        return value_ref ? *value_ref : owned_value;


14738    }


14739


14740    value_type const* operator->() const


14741    {


14742        return &** this;


14743    }


14744


14745  private:


14746    mutable value_type owned_value = nullptr;


14747    value_type const* value_ref = nullptr;


14748};


14749


14750}  // namespace detail


14751NLOHMANN_JSON_NAMESPACE_END


14752


14753// #include <nlohmann/detail/macro_scope.hpp>


14754


14755// #include <nlohmann/detail/string_concat.hpp>


14756


14757// #include <nlohmann/detail/string_escape.hpp>


14758


14759// #include <nlohmann/detail/meta/cpp_future.hpp>


14760


14761// #include <nlohmann/detail/meta/type_traits.hpp>


14762


14763// #include <nlohmann/detail/output/binary_writer.hpp>


14764//     __ _____ _____ _____


14765//  __|  |   __|     |   | |  JSON for Modern C++


14766// |  |  |__   |  |  | | | |  version 3.11.2


14767// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


14768//


14769// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


14770// SPDX-License-Identifier: MIT


14771


14772


14773


14774#include <algorithm> // reverse


14775#include <array> // array


14776#include <map> // map


14777#include <cmath> // isnan, isinf


14778#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t


14779#include <cstring> // memcpy


14780#include <limits> // numeric_limits


14781#include <string> // string


14782#include <utility> // move


14783#include <vector> // vector


14784


14785// #include <nlohmann/detail/input/binary_reader.hpp>


14786


14787// #include <nlohmann/detail/macro_scope.hpp>


14788


14789// #include <nlohmann/detail/output/output_adapters.hpp>


14790//     __ _____ _____ _____


14791//  __|  |   __|     |   | |  JSON for Modern C++


14792// |  |  |__   |  |  | | | |  version 3.11.2


14793// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


14794//


14795// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


14796// SPDX-License-Identifier: MIT


14797


14798


14799


14800#include <algorithm> // copy


14801#include <cstddef> // size_t


14802#include <iterator> // back_inserter


14803#include <memory> // shared_ptr, make_shared


14804#include <string> // basic_string


14805#include <vector> // vector


14806


14807#ifndef JSON_NO_IO


14808    #include <ios>      // streamsize


14809    #include <ostream>  // basic_ostream


14810#endif  // JSON_NO_IO


14811


14812// #include <nlohmann/detail/macro_scope.hpp>


14813


14814


14815NLOHMANN_JSON_NAMESPACE_BEGIN


14816namespace detail


14817{


14818


14819/// abstract output adapter interface


14820template<typename CharType> struct output_adapter_protocol


14821{


14822    virtual void write_character(CharType c) = 0;


14823    virtual void write_characters(const CharType* s, std::size_t length) = 0;


14824    virtual ~output_adapter_protocol() = default;


14825


14826    output_adapter_protocol() = default;


14827    output_adapter_protocol(const output_adapter_protocol&) = default;


14828    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;


14829    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;


14830    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;


14831};


14832


14833/// a type to simplify interfaces


14834template<typename CharType>


14835using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;


14836


14837/// output adapter for byte vectors


14838template<typename CharType, typename AllocatorType = std::allocator<CharType>>


14839class output_vector_adapter : public output_adapter_protocol<CharType>


14840{


14841  public:


14842    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept


14843        : v(vec)


14844    {}


14845


14846    void write_character(CharType c) override


14847    {


14848        v.push_back(c);


14849    }


14850


14851    JSON_HEDLEY_NON_NULL(2)


14852    void write_characters(const CharType* s, std::size_t length) override


14853    {


14854        v.insert(v.end(), s, s + length);


14855    }


14856


14857  private:


14858    std::vector<CharType, AllocatorType>& v;


14859};


14860


14861#ifndef JSON_NO_IO


14862/// output adapter for output streams


14863template<typename CharType>


14864class output_stream_adapter : public output_adapter_protocol<CharType>


14865{


14866  public:


14867    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept


14868        : stream(s)


14869    {}


14870


14871    void write_character(CharType c) override


14872    {


14873        stream.put(c);


14874    }


14875


14876    JSON_HEDLEY_NON_NULL(2)


14877    void write_characters(const CharType* s, std::size_t length) override


14878    {


14879        stream.write(s, static_cast<std::streamsize>(length));


14880    }


14881


14882  private:


14883    std::basic_ostream<CharType>& stream;


14884};


14885#endif  // JSON_NO_IO


14886


14887/// output adapter for basic_string


14888template<typename CharType, typename StringType = std::basic_string<CharType>>


14889class output_string_adapter : public output_adapter_protocol<CharType>


14890{


14891  public:


14892    explicit output_string_adapter(StringType& s) noexcept


14893        : str(s)


14894    {}


14895


14896    void write_character(CharType c) override


14897    {


14898        str.push_back(c);


14899    }


14900


14901    JSON_HEDLEY_NON_NULL(2)


14902    void write_characters(const CharType* s, std::size_t length) override


14903    {


14904        str.append(s, length);


14905    }


14906


14907  private:


14908    StringType& str;


14909};


14910


14911template<typename CharType, typename StringType = std::basic_string<CharType>>


14912class output_adapter


14913{


14914  public:


14915    template<typename AllocatorType = std::allocator<CharType>>


14916    output_adapter(std::vector<CharType, AllocatorType>& vec)


14917        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}


14918


14919#ifndef JSON_NO_IO


14920    output_adapter(std::basic_ostream<CharType>& s)


14921        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}


14922#endif  // JSON_NO_IO


14923


14924    output_adapter(StringType& s)


14925        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}


14926


14927    operator output_adapter_t<CharType>()


14928    {


14929        return oa;


14930    }


14931


14932  private:


14933    output_adapter_t<CharType> oa = nullptr;


14934};


14935


14936}  // namespace detail


14937NLOHMANN_JSON_NAMESPACE_END


14938


14939// #include <nlohmann/detail/string_concat.hpp>


14940


14941


14942NLOHMANN_JSON_NAMESPACE_BEGIN


14943namespace detail


14944{


14945


14946///////////////////


14947// binary writer //


14948///////////////////


14949


14950/*!


14951@brief serialization to CBOR and MessagePack values


14952*/


14953template<typename BasicJsonType, typename CharType>


14954class binary_writer


14955{


14956    using string_t = typename BasicJsonType::string_t;


14957    using binary_t = typename BasicJsonType::binary_t;


14958    using number_float_t = typename BasicJsonType::number_float_t;


14959


14960  public:


14961    /*!


14962    @brief create a binary writer


14963


14964    @param[in] adapter  output adapter to write to


14965    */


14966    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))


14967    {


14968        JSON_ASSERT(oa);


14969    }


14970


14971    /*!


14972    @param[in] j  JSON value to serialize


14973    @pre       j.type() == value_t::object


14974    */


14975    void write_bson(const BasicJsonType& j)


14976    {


14977        switch (j.type())


14978        {


14979            case value_t::object:


14980            {


14981                write_bson_object(*j.m_value.object);


14982                break;


14983            }


14984


14985            case value_t::null:


14986            case value_t::array:


14987            case value_t::string:


14988            case value_t::boolean:


14989            case value_t::number_integer:


14990            case value_t::number_unsigned:


14991            case value_t::number_float:


14992            case value_t::binary:


14993            case value_t::discarded:


14994            default:


14995            {


14996                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));


14997            }


14998        }


14999    }


15000


15001    /*!


15002    @param[in] j  JSON value to serialize


15003    */


15004    void write_cbor(const BasicJsonType& j)


15005    {


15006        switch (j.type())


15007        {


15008            case value_t::null:


15009            {


15010                oa->write_character(to_char_type(0xF6));


15011                break;


15012            }


15013


15014            case value_t::boolean:


15015            {


15016                oa->write_character(j.m_value.boolean


15017                                    ? to_char_type(0xF5)


15018                                    : to_char_type(0xF4));


15019                break;


15020            }


15021


15022            case value_t::number_integer:


15023            {


15024                if (j.m_value.number_integer >= 0)


15025                {


15026                    // CBOR does not differentiate between positive signed


15027                    // integers and unsigned integers. Therefore, we used the


15028                    // code from the value_t::number_unsigned case here.


15029                    if (j.m_value.number_integer <= 0x17)


15030                    {


15031                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));


15032                    }


15033                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())


15034                    {


15035                        oa->write_character(to_char_type(0x18));


15036                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));


15037                    }


15038                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())


15039                    {


15040                        oa->write_character(to_char_type(0x19));


15041                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));


15042                    }


15043                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())


15044                    {


15045                        oa->write_character(to_char_type(0x1A));


15046                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));


15047                    }


15048                    else


15049                    {


15050                        oa->write_character(to_char_type(0x1B));


15051                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));


15052                    }


15053                }


15054                else


15055                {


15056                    // The conversions below encode the sign in the first


15057                    // byte, and the value is converted to a positive number.


15058                    const auto positive_number = -1 - j.m_value.number_integer;


15059                    if (j.m_value.number_integer >= -24)


15060                    {


15061                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));


15062                    }


15063                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())


15064                    {


15065                        oa->write_character(to_char_type(0x38));


15066                        write_number(static_cast<std::uint8_t>(positive_number));


15067                    }


15068                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())


15069                    {


15070                        oa->write_character(to_char_type(0x39));


15071                        write_number(static_cast<std::uint16_t>(positive_number));


15072                    }


15073                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())


15074                    {


15075                        oa->write_character(to_char_type(0x3A));


15076                        write_number(static_cast<std::uint32_t>(positive_number));


15077                    }


15078                    else


15079                    {


15080                        oa->write_character(to_char_type(0x3B));


15081                        write_number(static_cast<std::uint64_t>(positive_number));


15082                    }


15083                }


15084                break;


15085            }


15086


15087            case value_t::number_unsigned:


15088            {


15089                if (j.m_value.number_unsigned <= 0x17)


15090                {


15091                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));


15092                }


15093                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())


15094                {


15095                    oa->write_character(to_char_type(0x18));


15096                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));


15097                }


15098                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())


15099                {


15100                    oa->write_character(to_char_type(0x19));


15101                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));


15102                }


15103                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())


15104                {


15105                    oa->write_character(to_char_type(0x1A));


15106                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));


15107                }


15108                else


15109                {


15110                    oa->write_character(to_char_type(0x1B));


15111                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));


15112                }


15113                break;


15114            }


15115


15116            case value_t::number_float:


15117            {


15118                if (std::isnan(j.m_value.number_float))


15119                {


15120                    // NaN is 0xf97e00 in CBOR


15121                    oa->write_character(to_char_type(0xF9));


15122                    oa->write_character(to_char_type(0x7E));


15123                    oa->write_character(to_char_type(0x00));


15124                }


15125                else if (std::isinf(j.m_value.number_float))


15126                {


15127                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00


15128                    oa->write_character(to_char_type(0xf9));


15129                    oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));


15130                    oa->write_character(to_char_type(0x00));


15131                }


15132                else


15133                {


15134                    write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);


15135                }


15136                break;


15137            }


15138


15139            case value_t::string:


15140            {


15141                // step 1: write control byte and the string length


15142                const auto N = j.m_value.string->size();


15143                if (N <= 0x17)


15144                {


15145                    write_number(static_cast<std::uint8_t>(0x60 + N));


15146                }


15147                else if (N <= (std::numeric_limits<std::uint8_t>::max)())


15148                {


15149                    oa->write_character(to_char_type(0x78));


15150                    write_number(static_cast<std::uint8_t>(N));


15151                }


15152                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15153                {


15154                    oa->write_character(to_char_type(0x79));


15155                    write_number(static_cast<std::uint16_t>(N));


15156                }


15157                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15158                {


15159                    oa->write_character(to_char_type(0x7A));


15160                    write_number(static_cast<std::uint32_t>(N));


15161                }


15162                // LCOV_EXCL_START


15163                else if (N <= (std::numeric_limits<std::uint64_t>::max)())


15164                {


15165                    oa->write_character(to_char_type(0x7B));


15166                    write_number(static_cast<std::uint64_t>(N));


15167                }


15168                // LCOV_EXCL_STOP


15169


15170                // step 2: write the string


15171                oa->write_characters(


15172                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),


15173                    j.m_value.string->size());


15174                break;


15175            }


15176


15177            case value_t::array:


15178            {


15179                // step 1: write control byte and the array size


15180                const auto N = j.m_value.array->size();


15181                if (N <= 0x17)


15182                {


15183                    write_number(static_cast<std::uint8_t>(0x80 + N));


15184                }


15185                else if (N <= (std::numeric_limits<std::uint8_t>::max)())


15186                {


15187                    oa->write_character(to_char_type(0x98));


15188                    write_number(static_cast<std::uint8_t>(N));


15189                }


15190                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15191                {


15192                    oa->write_character(to_char_type(0x99));


15193                    write_number(static_cast<std::uint16_t>(N));


15194                }


15195                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15196                {


15197                    oa->write_character(to_char_type(0x9A));


15198                    write_number(static_cast<std::uint32_t>(N));


15199                }


15200                // LCOV_EXCL_START


15201                else if (N <= (std::numeric_limits<std::uint64_t>::max)())


15202                {


15203                    oa->write_character(to_char_type(0x9B));


15204                    write_number(static_cast<std::uint64_t>(N));


15205                }


15206                // LCOV_EXCL_STOP


15207


15208                // step 2: write each element


15209                for (const auto& el : *j.m_value.array)


15210                {


15211                    write_cbor(el);


15212                }


15213                break;


15214            }


15215


15216            case value_t::binary:


15217            {


15218                if (j.m_value.binary->has_subtype())


15219                {


15220                    if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())


15221                    {


15222                        write_number(static_cast<std::uint8_t>(0xd8));


15223                        write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));


15224                    }


15225                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())


15226                    {


15227                        write_number(static_cast<std::uint8_t>(0xd9));


15228                        write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));


15229                    }


15230                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())


15231                    {


15232                        write_number(static_cast<std::uint8_t>(0xda));


15233                        write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));


15234                    }


15235                    else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())


15236                    {


15237                        write_number(static_cast<std::uint8_t>(0xdb));


15238                        write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));


15239                    }


15240                }


15241


15242                // step 1: write control byte and the binary array size


15243                const auto N = j.m_value.binary->size();


15244                if (N <= 0x17)


15245                {


15246                    write_number(static_cast<std::uint8_t>(0x40 + N));


15247                }


15248                else if (N <= (std::numeric_limits<std::uint8_t>::max)())


15249                {


15250                    oa->write_character(to_char_type(0x58));


15251                    write_number(static_cast<std::uint8_t>(N));


15252                }


15253                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15254                {


15255                    oa->write_character(to_char_type(0x59));


15256                    write_number(static_cast<std::uint16_t>(N));


15257                }


15258                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15259                {


15260                    oa->write_character(to_char_type(0x5A));


15261                    write_number(static_cast<std::uint32_t>(N));


15262                }


15263                // LCOV_EXCL_START


15264                else if (N <= (std::numeric_limits<std::uint64_t>::max)())


15265                {


15266                    oa->write_character(to_char_type(0x5B));


15267                    write_number(static_cast<std::uint64_t>(N));


15268                }


15269                // LCOV_EXCL_STOP


15270


15271                // step 2: write each element


15272                oa->write_characters(


15273                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),


15274                    N);


15275


15276                break;


15277            }


15278


15279            case value_t::object:


15280            {


15281                // step 1: write control byte and the object size


15282                const auto N = j.m_value.object->size();


15283                if (N <= 0x17)


15284                {


15285                    write_number(static_cast<std::uint8_t>(0xA0 + N));


15286                }


15287                else if (N <= (std::numeric_limits<std::uint8_t>::max)())


15288                {


15289                    oa->write_character(to_char_type(0xB8));


15290                    write_number(static_cast<std::uint8_t>(N));


15291                }


15292                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15293                {


15294                    oa->write_character(to_char_type(0xB9));


15295                    write_number(static_cast<std::uint16_t>(N));


15296                }


15297                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15298                {


15299                    oa->write_character(to_char_type(0xBA));


15300                    write_number(static_cast<std::uint32_t>(N));


15301                }


15302                // LCOV_EXCL_START


15303                else if (N <= (std::numeric_limits<std::uint64_t>::max)())


15304                {


15305                    oa->write_character(to_char_type(0xBB));


15306                    write_number(static_cast<std::uint64_t>(N));


15307                }


15308                // LCOV_EXCL_STOP


15309


15310                // step 2: write each element


15311                for (const auto& el : *j.m_value.object)


15312                {


15313                    write_cbor(el.first);


15314                    write_cbor(el.second);


15315                }


15316                break;


15317            }


15318


15319            case value_t::discarded:


15320            default:


15321                break;


15322        }


15323    }


15324


15325    /*!


15326    @param[in] j  JSON value to serialize


15327    */


15328    void write_msgpack(const BasicJsonType& j)


15329    {


15330        switch (j.type())


15331        {


15332            case value_t::null: // nil


15333            {


15334                oa->write_character(to_char_type(0xC0));


15335                break;


15336            }


15337


15338            case value_t::boolean: // true and false


15339            {


15340                oa->write_character(j.m_value.boolean


15341                                    ? to_char_type(0xC3)


15342                                    : to_char_type(0xC2));


15343                break;


15344            }


15345


15346            case value_t::number_integer:


15347            {


15348                if (j.m_value.number_integer >= 0)


15349                {


15350                    // MessagePack does not differentiate between positive


15351                    // signed integers and unsigned integers. Therefore, we used


15352                    // the code from the value_t::number_unsigned case here.


15353                    if (j.m_value.number_unsigned < 128)


15354                    {


15355                        // positive fixnum


15356                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));


15357                    }


15358                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())


15359                    {


15360                        // uint 8


15361                        oa->write_character(to_char_type(0xCC));


15362                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));


15363                    }


15364                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())


15365                    {


15366                        // uint 16


15367                        oa->write_character(to_char_type(0xCD));


15368                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));


15369                    }


15370                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())


15371                    {


15372                        // uint 32


15373                        oa->write_character(to_char_type(0xCE));


15374                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));


15375                    }


15376                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())


15377                    {


15378                        // uint 64


15379                        oa->write_character(to_char_type(0xCF));


15380                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));


15381                    }


15382                }


15383                else


15384                {


15385                    if (j.m_value.number_integer >= -32)


15386                    {


15387                        // negative fixnum


15388                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));


15389                    }


15390                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&


15391                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())


15392                    {


15393                        // int 8


15394                        oa->write_character(to_char_type(0xD0));


15395                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));


15396                    }


15397                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&


15398                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())


15399                    {


15400                        // int 16


15401                        oa->write_character(to_char_type(0xD1));


15402                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));


15403                    }


15404                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&


15405                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())


15406                    {


15407                        // int 32


15408                        oa->write_character(to_char_type(0xD2));


15409                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));


15410                    }


15411                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&


15412                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())


15413                    {


15414                        // int 64


15415                        oa->write_character(to_char_type(0xD3));


15416                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));


15417                    }


15418                }


15419                break;


15420            }


15421


15422            case value_t::number_unsigned:


15423            {


15424                if (j.m_value.number_unsigned < 128)


15425                {


15426                    // positive fixnum


15427                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));


15428                }


15429                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())


15430                {


15431                    // uint 8


15432                    oa->write_character(to_char_type(0xCC));


15433                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));


15434                }


15435                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())


15436                {


15437                    // uint 16


15438                    oa->write_character(to_char_type(0xCD));


15439                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));


15440                }


15441                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())


15442                {


15443                    // uint 32


15444                    oa->write_character(to_char_type(0xCE));


15445                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));


15446                }


15447                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())


15448                {


15449                    // uint 64


15450                    oa->write_character(to_char_type(0xCF));


15451                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));


15452                }


15453                break;


15454            }


15455


15456            case value_t::number_float:


15457            {


15458                write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);


15459                break;


15460            }


15461


15462            case value_t::string:


15463            {


15464                // step 1: write control byte and the string length


15465                const auto N = j.m_value.string->size();


15466                if (N <= 31)


15467                {


15468                    // fixstr


15469                    write_number(static_cast<std::uint8_t>(0xA0 | N));


15470                }


15471                else if (N <= (std::numeric_limits<std::uint8_t>::max)())


15472                {


15473                    // str 8


15474                    oa->write_character(to_char_type(0xD9));


15475                    write_number(static_cast<std::uint8_t>(N));


15476                }


15477                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15478                {


15479                    // str 16


15480                    oa->write_character(to_char_type(0xDA));


15481                    write_number(static_cast<std::uint16_t>(N));


15482                }


15483                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15484                {


15485                    // str 32


15486                    oa->write_character(to_char_type(0xDB));


15487                    write_number(static_cast<std::uint32_t>(N));


15488                }


15489


15490                // step 2: write the string


15491                oa->write_characters(


15492                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),


15493                    j.m_value.string->size());


15494                break;


15495            }


15496


15497            case value_t::array:


15498            {


15499                // step 1: write control byte and the array size


15500                const auto N = j.m_value.array->size();


15501                if (N <= 15)


15502                {


15503                    // fixarray


15504                    write_number(static_cast<std::uint8_t>(0x90 | N));


15505                }


15506                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15507                {


15508                    // array 16


15509                    oa->write_character(to_char_type(0xDC));


15510                    write_number(static_cast<std::uint16_t>(N));


15511                }


15512                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15513                {


15514                    // array 32


15515                    oa->write_character(to_char_type(0xDD));


15516                    write_number(static_cast<std::uint32_t>(N));


15517                }


15518


15519                // step 2: write each element


15520                for (const auto& el : *j.m_value.array)


15521                {


15522                    write_msgpack(el);


15523                }


15524                break;


15525            }


15526


15527            case value_t::binary:


15528            {


15529                // step 0: determine if the binary type has a set subtype to


15530                // determine whether or not to use the ext or fixext types


15531                const bool use_ext = j.m_value.binary->has_subtype();


15532


15533                // step 1: write control byte and the byte string length


15534                const auto N = j.m_value.binary->size();


15535                if (N <= (std::numeric_limits<std::uint8_t>::max)())


15536                {


15537                    std::uint8_t output_type{};


15538                    bool fixed = true;


15539                    if (use_ext)


15540                    {


15541                        switch (N)


15542                        {


15543                            case 1:


15544                                output_type = 0xD4; // fixext 1


15545                                break;


15546                            case 2:


15547                                output_type = 0xD5; // fixext 2


15548                                break;


15549                            case 4:


15550                                output_type = 0xD6; // fixext 4


15551                                break;


15552                            case 8:


15553                                output_type = 0xD7; // fixext 8


15554                                break;


15555                            case 16:


15556                                output_type = 0xD8; // fixext 16


15557                                break;


15558                            default:


15559                                output_type = 0xC7; // ext 8


15560                                fixed = false;


15561                                break;


15562                        }


15563


15564                    }


15565                    else


15566                    {


15567                        output_type = 0xC4; // bin 8


15568                        fixed = false;


15569                    }


15570


15571                    oa->write_character(to_char_type(output_type));


15572                    if (!fixed)


15573                    {


15574                        write_number(static_cast<std::uint8_t>(N));


15575                    }


15576                }


15577                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15578                {


15579                    std::uint8_t output_type = use_ext


15580                                               ? 0xC8 // ext 16


15581                                               : 0xC5; // bin 16


15582


15583                    oa->write_character(to_char_type(output_type));


15584                    write_number(static_cast<std::uint16_t>(N));


15585                }


15586                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15587                {


15588                    std::uint8_t output_type = use_ext


15589                                               ? 0xC9 // ext 32


15590                                               : 0xC6; // bin 32


15591


15592                    oa->write_character(to_char_type(output_type));


15593                    write_number(static_cast<std::uint32_t>(N));


15594                }


15595


15596                // step 1.5: if this is an ext type, write the subtype


15597                if (use_ext)


15598                {


15599                    write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));


15600                }


15601


15602                // step 2: write the byte string


15603                oa->write_characters(


15604                    reinterpret_cast<const CharType*>(j.m_value.binary->data()),


15605                    N);


15606


15607                break;


15608            }


15609


15610            case value_t::object:


15611            {


15612                // step 1: write control byte and the object size


15613                const auto N = j.m_value.object->size();


15614                if (N <= 15)


15615                {


15616                    // fixmap


15617                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));


15618                }


15619                else if (N <= (std::numeric_limits<std::uint16_t>::max)())


15620                {


15621                    // map 16


15622                    oa->write_character(to_char_type(0xDE));


15623                    write_number(static_cast<std::uint16_t>(N));


15624                }


15625                else if (N <= (std::numeric_limits<std::uint32_t>::max)())


15626                {


15627                    // map 32


15628                    oa->write_character(to_char_type(0xDF));


15629                    write_number(static_cast<std::uint32_t>(N));


15630                }


15631


15632                // step 2: write each element


15633                for (const auto& el : *j.m_value.object)


15634                {


15635                    write_msgpack(el.first);


15636                    write_msgpack(el.second);


15637                }


15638                break;


15639            }


15640


15641            case value_t::discarded:


15642            default:


15643                break;


15644        }


15645    }


15646


15647    /*!


15648    @param[in] j  JSON value to serialize


15649    @param[in] use_count   whether to use '#' prefixes (optimized format)


15650    @param[in] use_type    whether to use '$' prefixes (optimized format)


15651    @param[in] add_prefix  whether prefixes need to be used for this value


15652    @param[in] use_bjdata  whether write in BJData format, default is false


15653    */


15654    void write_ubjson(const BasicJsonType& j, const bool use_count,


15655                      const bool use_type, const bool add_prefix = true,


15656                      const bool use_bjdata = false)


15657    {


15658        switch (j.type())


15659        {


15660            case value_t::null:


15661            {


15662                if (add_prefix)


15663                {


15664                    oa->write_character(to_char_type('Z'));


15665                }


15666                break;


15667            }


15668


15669            case value_t::boolean:


15670            {


15671                if (add_prefix)


15672                {


15673                    oa->write_character(j.m_value.boolean


15674                                        ? to_char_type('T')


15675                                        : to_char_type('F'));


15676                }


15677                break;


15678            }


15679


15680            case value_t::number_integer:


15681            {


15682                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix, use_bjdata);


15683                break;


15684            }


15685


15686            case value_t::number_unsigned:


15687            {


15688                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix, use_bjdata);


15689                break;


15690            }


15691


15692            case value_t::number_float:


15693            {


15694                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix, use_bjdata);


15695                break;


15696            }


15697


15698            case value_t::string:


15699            {


15700                if (add_prefix)


15701                {


15702                    oa->write_character(to_char_type('S'));


15703                }


15704                write_number_with_ubjson_prefix(j.m_value.string->size(), true, use_bjdata);


15705                oa->write_characters(


15706                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),


15707                    j.m_value.string->size());


15708                break;


15709            }


15710


15711            case value_t::array:


15712            {


15713                if (add_prefix)


15714                {


15715                    oa->write_character(to_char_type('['));


15716                }


15717


15718                bool prefix_required = true;


15719                if (use_type && !j.m_value.array->empty())


15720                {


15721                    JSON_ASSERT(use_count);


15722                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);


15723                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),


15724                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)


15725                    {


15726                        return ubjson_prefix(v, use_bjdata) == first_prefix;


15727                    });


15728


15729                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type


15730


15731                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))


15732                    {


15733                        prefix_required = false;


15734                        oa->write_character(to_char_type('$'));


15735                        oa->write_character(first_prefix);


15736                    }


15737                }


15738


15739                if (use_count)


15740                {


15741                    oa->write_character(to_char_type('#'));


15742                    write_number_with_ubjson_prefix(j.m_value.array->size(), true, use_bjdata);


15743                }


15744


15745                for (const auto& el : *j.m_value.array)


15746                {


15747                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);


15748                }


15749


15750                if (!use_count)


15751                {


15752                    oa->write_character(to_char_type(']'));


15753                }


15754


15755                break;


15756            }


15757


15758            case value_t::binary:


15759            {


15760                if (add_prefix)


15761                {


15762                    oa->write_character(to_char_type('['));


15763                }


15764


15765                if (use_type && !j.m_value.binary->empty())


15766                {


15767                    JSON_ASSERT(use_count);


15768                    oa->write_character(to_char_type('$'));


15769                    oa->write_character('U');


15770                }


15771


15772                if (use_count)


15773                {


15774                    oa->write_character(to_char_type('#'));


15775                    write_number_with_ubjson_prefix(j.m_value.binary->size(), true, use_bjdata);


15776                }


15777


15778                if (use_type)


15779                {


15780                    oa->write_characters(


15781                        reinterpret_cast<const CharType*>(j.m_value.binary->data()),


15782                        j.m_value.binary->size());


15783                }


15784                else


15785                {


15786                    for (size_t i = 0; i < j.m_value.binary->size(); ++i)


15787                    {


15788                        oa->write_character(to_char_type('U'));


15789                        oa->write_character(j.m_value.binary->data()[i]);


15790                    }


15791                }


15792


15793                if (!use_count)


15794                {


15795                    oa->write_character(to_char_type(']'));


15796                }


15797


15798                break;


15799            }


15800


15801            case value_t::object:


15802            {


15803                if (use_bjdata && j.m_value.object->size() == 3 && j.m_value.object->find("_ArrayType_") != j.m_value.object->end() && j.m_value.object->find("_ArraySize_") != j.m_value.object->end() && j.m_value.object->find("_ArrayData_") != j.m_value.object->end())


15804                {


15805                    if (!write_bjdata_ndarray(*j.m_value.object, use_count, use_type))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)


15806                    {


15807                        break;


15808                    }


15809                }


15810


15811                if (add_prefix)


15812                {


15813                    oa->write_character(to_char_type('{'));


15814                }


15815


15816                bool prefix_required = true;


15817                if (use_type && !j.m_value.object->empty())


15818                {


15819                    JSON_ASSERT(use_count);


15820                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);


15821                    const bool same_prefix = std::all_of(j.begin(), j.end(),


15822                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)


15823                    {


15824                        return ubjson_prefix(v, use_bjdata) == first_prefix;


15825                    });


15826


15827                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type


15828


15829                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))


15830                    {


15831                        prefix_required = false;


15832                        oa->write_character(to_char_type('$'));


15833                        oa->write_character(first_prefix);


15834                    }


15835                }


15836


15837                if (use_count)


15838                {


15839                    oa->write_character(to_char_type('#'));


15840                    write_number_with_ubjson_prefix(j.m_value.object->size(), true, use_bjdata);


15841                }


15842


15843                for (const auto& el : *j.m_value.object)


15844                {


15845                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);


15846                    oa->write_characters(


15847                        reinterpret_cast<const CharType*>(el.first.c_str()),


15848                        el.first.size());


15849                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);


15850                }


15851


15852                if (!use_count)


15853                {


15854                    oa->write_character(to_char_type('}'));


15855                }


15856


15857                break;


15858            }


15859


15860            case value_t::discarded:


15861            default:


15862                break;


15863        }


15864    }


15865


15866  private:


15867    //////////


15868    // BSON //


15869    //////////


15870


15871    /*!


15872    @return The size of a BSON document entry header, including the id marker


15873            and the entry name size (and its null-terminator).


15874    */


15875    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)


15876    {


15877        const auto it = name.find(static_cast<typename string_t::value_type>(0));


15878        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))


15879        {


15880            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));


15881            static_cast<void>(j);


15882        }


15883


15884        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;


15885    }


15886


15887    /*!


15888    @brief Writes the given @a element_type and @a name to the output adapter


15889    */


15890    void write_bson_entry_header(const string_t& name,


15891                                 const std::uint8_t element_type)


15892    {


15893        oa->write_character(to_char_type(element_type)); // boolean


15894        oa->write_characters(


15895            reinterpret_cast<const CharType*>(name.c_str()),


15896            name.size() + 1u);


15897    }


15898


15899    /*!


15900    @brief Writes a BSON element with key @a name and boolean value @a value


15901    */


15902    void write_bson_boolean(const string_t& name,


15903                            const bool value)


15904    {


15905        write_bson_entry_header(name, 0x08);


15906        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));


15907    }


15908


15909    /*!


15910    @brief Writes a BSON element with key @a name and double value @a value


15911    */


15912    void write_bson_double(const string_t& name,


15913                           const double value)


15914    {


15915        write_bson_entry_header(name, 0x01);


15916        write_number<double>(value, true);


15917    }


15918


15919    /*!


15920    @return The size of the BSON-encoded string in @a value


15921    */


15922    static std::size_t calc_bson_string_size(const string_t& value)


15923    {


15924        return sizeof(std::int32_t) + value.size() + 1ul;


15925    }


15926


15927    /*!


15928    @brief Writes a BSON element with key @a name and string value @a value


15929    */


15930    void write_bson_string(const string_t& name,


15931                           const string_t& value)


15932    {


15933        write_bson_entry_header(name, 0x02);


15934


15935        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);


15936        oa->write_characters(


15937            reinterpret_cast<const CharType*>(value.c_str()),


15938            value.size() + 1);


15939    }


15940


15941    /*!


15942    @brief Writes a BSON element with key @a name and null value


15943    */


15944    void write_bson_null(const string_t& name)


15945    {


15946        write_bson_entry_header(name, 0x0A);


15947    }


15948


15949    /*!


15950    @return The size of the BSON-encoded integer @a value


15951    */


15952    static std::size_t calc_bson_integer_size(const std::int64_t value)


15953    {


15954        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()


15955               ? sizeof(std::int32_t)


15956               : sizeof(std::int64_t);


15957    }


15958


15959    /*!


15960    @brief Writes a BSON element with key @a name and integer @a value


15961    */


15962    void write_bson_integer(const string_t& name,


15963                            const std::int64_t value)


15964    {


15965        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())


15966        {


15967            write_bson_entry_header(name, 0x10); // int32


15968            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);


15969        }


15970        else


15971        {


15972            write_bson_entry_header(name, 0x12); // int64


15973            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);


15974        }


15975    }


15976


15977    /*!


15978    @return The size of the BSON-encoded unsigned integer in @a j


15979    */


15980    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept


15981    {


15982        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))


15983               ? sizeof(std::int32_t)


15984               : sizeof(std::int64_t);


15985    }


15986


15987    /*!


15988    @brief Writes a BSON element with key @a name and unsigned @a value


15989    */


15990    void write_bson_unsigned(const string_t& name,


15991                             const BasicJsonType& j)


15992    {


15993        if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))


15994        {


15995            write_bson_entry_header(name, 0x10 /* int32 */);


15996            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_value.number_unsigned), true);


15997        }


15998        else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))


15999        {


16000            write_bson_entry_header(name, 0x12 /* int64 */);


16001            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_value.number_unsigned), true);


16002        }


16003        else


16004        {


16005            JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));


16006        }


16007    }


16008


16009    /*!


16010    @brief Writes a BSON element with key @a name and object @a value


16011    */


16012    void write_bson_object_entry(const string_t& name,


16013                                 const typename BasicJsonType::object_t& value)


16014    {


16015        write_bson_entry_header(name, 0x03); // object


16016        write_bson_object(value);


16017    }


16018


16019    /*!


16020    @return The size of the BSON-encoded array @a value


16021    */


16022    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)


16023    {


16024        std::size_t array_index = 0ul;


16025


16026        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)


16027        {


16028            return result + calc_bson_element_size(std::to_string(array_index++), el);


16029        });


16030


16031        return sizeof(std::int32_t) + embedded_document_size + 1ul;


16032    }


16033


16034    /*!


16035    @return The size of the BSON-encoded binary array @a value


16036    */


16037    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)


16038    {


16039        return sizeof(std::int32_t) + value.size() + 1ul;


16040    }


16041


16042    /*!


16043    @brief Writes a BSON element with key @a name and array @a value


16044    */


16045    void write_bson_array(const string_t& name,


16046                          const typename BasicJsonType::array_t& value)


16047    {


16048        write_bson_entry_header(name, 0x04); // array


16049        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);


16050


16051        std::size_t array_index = 0ul;


16052


16053        for (const auto& el : value)


16054        {


16055            write_bson_element(std::to_string(array_index++), el);


16056        }


16057


16058        oa->write_character(to_char_type(0x00));


16059    }


16060


16061    /*!


16062    @brief Writes a BSON element with key @a name and binary value @a value


16063    */


16064    void write_bson_binary(const string_t& name,


16065                           const binary_t& value)


16066    {


16067        write_bson_entry_header(name, 0x05);


16068


16069        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);


16070        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));


16071


16072        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());


16073    }


16074


16075    /*!


16076    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name


16077    @return The calculated size for the BSON document entry for @a j with the given @a name.


16078    */


16079    static std::size_t calc_bson_element_size(const string_t& name,


16080            const BasicJsonType& j)


16081    {


16082        const auto header_size = calc_bson_entry_header_size(name, j);


16083        switch (j.type())


16084        {


16085            case value_t::object:


16086                return header_size + calc_bson_object_size(*j.m_value.object);


16087


16088            case value_t::array:


16089                return header_size + calc_bson_array_size(*j.m_value.array);


16090


16091            case value_t::binary:


16092                return header_size + calc_bson_binary_size(*j.m_value.binary);


16093


16094            case value_t::boolean:


16095                return header_size + 1ul;


16096


16097            case value_t::number_float:


16098                return header_size + 8ul;


16099


16100            case value_t::number_integer:


16101                return header_size + calc_bson_integer_size(j.m_value.number_integer);


16102


16103            case value_t::number_unsigned:


16104                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);


16105


16106            case value_t::string:


16107                return header_size + calc_bson_string_size(*j.m_value.string);


16108


16109            case value_t::null:


16110                return header_size + 0ul;


16111


16112            // LCOV_EXCL_START


16113            case value_t::discarded:


16114            default:


16115                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)


16116                return 0ul;


16117                // LCOV_EXCL_STOP


16118        }


16119    }


16120


16121    /*!


16122    @brief Serializes the JSON value @a j to BSON and associates it with the


16123           key @a name.


16124    @param name The name to associate with the JSON entity @a j within the


16125                current BSON document


16126    */


16127    void write_bson_element(const string_t& name,


16128                            const BasicJsonType& j)


16129    {


16130        switch (j.type())


16131        {


16132            case value_t::object:


16133                return write_bson_object_entry(name, *j.m_value.object);


16134


16135            case value_t::array:


16136                return write_bson_array(name, *j.m_value.array);


16137


16138            case value_t::binary:


16139                return write_bson_binary(name, *j.m_value.binary);


16140


16141            case value_t::boolean:


16142                return write_bson_boolean(name, j.m_value.boolean);


16143


16144            case value_t::number_float:


16145                return write_bson_double(name, j.m_value.number_float);


16146


16147            case value_t::number_integer:


16148                return write_bson_integer(name, j.m_value.number_integer);


16149


16150            case value_t::number_unsigned:


16151                return write_bson_unsigned(name, j);


16152


16153            case value_t::string:


16154                return write_bson_string(name, *j.m_value.string);


16155


16156            case value_t::null:


16157                return write_bson_null(name);


16158


16159            // LCOV_EXCL_START


16160            case value_t::discarded:


16161            default:


16162                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)


16163                return;


16164                // LCOV_EXCL_STOP


16165        }


16166    }


16167


16168    /*!


16169    @brief Calculates the size of the BSON serialization of the given


16170           JSON-object @a j.


16171    @param[in] value  JSON value to serialize


16172    @pre       value.type() == value_t::object


16173    */


16174    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)


16175    {


16176        std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),


16177                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)


16178        {


16179            return result += calc_bson_element_size(el.first, el.second);


16180        });


16181


16182        return sizeof(std::int32_t) + document_size + 1ul;


16183    }


16184


16185    /*!


16186    @param[in] value  JSON value to serialize


16187    @pre       value.type() == value_t::object


16188    */


16189    void write_bson_object(const typename BasicJsonType::object_t& value)


16190    {


16191        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);


16192


16193        for (const auto& el : value)


16194        {


16195            write_bson_element(el.first, el.second);


16196        }


16197


16198        oa->write_character(to_char_type(0x00));


16199    }


16200


16201    //////////


16202    // CBOR //


16203    //////////


16204


16205    static constexpr CharType get_cbor_float_prefix(float /*unused*/)


16206    {


16207        return to_char_type(0xFA);  // Single-Precision Float


16208    }


16209


16210    static constexpr CharType get_cbor_float_prefix(double /*unused*/)


16211    {


16212        return to_char_type(0xFB);  // Double-Precision Float


16213    }


16214


16215    /////////////


16216    // MsgPack //


16217    /////////////


16218


16219    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)


16220    {


16221        return to_char_type(0xCA);  // float 32


16222    }


16223


16224    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)


16225    {


16226        return to_char_type(0xCB);  // float 64


16227    }


16228


16229    ////////////


16230    // UBJSON //


16231    ////////////


16232


16233    // UBJSON: write number (floating point)


16234    template<typename NumberType, typename std::enable_if<


16235                 std::is_floating_point<NumberType>::value, int>::type = 0>


16236    void write_number_with_ubjson_prefix(const NumberType n,


16237                                         const bool add_prefix,


16238                                         const bool use_bjdata)


16239    {


16240        if (add_prefix)


16241        {


16242            oa->write_character(get_ubjson_float_prefix(n));


16243        }


16244        write_number(n, use_bjdata);


16245    }


16246


16247    // UBJSON: write number (unsigned integer)


16248    template<typename NumberType, typename std::enable_if<


16249                 std::is_unsigned<NumberType>::value, int>::type = 0>


16250    void write_number_with_ubjson_prefix(const NumberType n,


16251                                         const bool add_prefix,


16252                                         const bool use_bjdata)


16253    {


16254        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))


16255        {


16256            if (add_prefix)


16257            {


16258                oa->write_character(to_char_type('i'));  // int8


16259            }


16260            write_number(static_cast<std::uint8_t>(n), use_bjdata);


16261        }


16262        else if (n <= (std::numeric_limits<std::uint8_t>::max)())


16263        {


16264            if (add_prefix)


16265            {


16266                oa->write_character(to_char_type('U'));  // uint8


16267            }


16268            write_number(static_cast<std::uint8_t>(n), use_bjdata);


16269        }


16270        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))


16271        {


16272            if (add_prefix)


16273            {


16274                oa->write_character(to_char_type('I'));  // int16


16275            }


16276            write_number(static_cast<std::int16_t>(n), use_bjdata);


16277        }


16278        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))


16279        {


16280            if (add_prefix)


16281            {


16282                oa->write_character(to_char_type('u'));  // uint16 - bjdata only


16283            }


16284            write_number(static_cast<std::uint16_t>(n), use_bjdata);


16285        }


16286        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))


16287        {


16288            if (add_prefix)


16289            {


16290                oa->write_character(to_char_type('l'));  // int32


16291            }


16292            write_number(static_cast<std::int32_t>(n), use_bjdata);


16293        }


16294        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))


16295        {


16296            if (add_prefix)


16297            {


16298                oa->write_character(to_char_type('m'));  // uint32 - bjdata only


16299            }


16300            write_number(static_cast<std::uint32_t>(n), use_bjdata);


16301        }


16302        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))


16303        {


16304            if (add_prefix)


16305            {


16306                oa->write_character(to_char_type('L'));  // int64


16307            }


16308            write_number(static_cast<std::int64_t>(n), use_bjdata);


16309        }


16310        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())


16311        {


16312            if (add_prefix)


16313            {


16314                oa->write_character(to_char_type('M'));  // uint64 - bjdata only


16315            }


16316            write_number(static_cast<std::uint64_t>(n), use_bjdata);


16317        }


16318        else


16319        {


16320            if (add_prefix)


16321            {


16322                oa->write_character(to_char_type('H'));  // high-precision number


16323            }


16324


16325            const auto number = BasicJsonType(n).dump();


16326            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);


16327            for (std::size_t i = 0; i < number.size(); ++i)


16328            {


16329                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));


16330            }


16331        }


16332    }


16333


16334    // UBJSON: write number (signed integer)


16335    template < typename NumberType, typename std::enable_if <


16336                   std::is_signed<NumberType>::value&&


16337                   !std::is_floating_point<NumberType>::value, int >::type = 0 >


16338    void write_number_with_ubjson_prefix(const NumberType n,


16339                                         const bool add_prefix,


16340                                         const bool use_bjdata)


16341    {


16342        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())


16343        {


16344            if (add_prefix)


16345            {


16346                oa->write_character(to_char_type('i'));  // int8


16347            }


16348            write_number(static_cast<std::int8_t>(n), use_bjdata);


16349        }


16350        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)()))


16351        {


16352            if (add_prefix)


16353            {


16354                oa->write_character(to_char_type('U'));  // uint8


16355            }


16356            write_number(static_cast<std::uint8_t>(n), use_bjdata);


16357        }


16358        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())


16359        {


16360            if (add_prefix)


16361            {


16362                oa->write_character(to_char_type('I'));  // int16


16363            }


16364            write_number(static_cast<std::int16_t>(n), use_bjdata);


16365        }


16366        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)())))


16367        {


16368            if (add_prefix)


16369            {


16370                oa->write_character(to_char_type('u'));  // uint16 - bjdata only


16371            }


16372            write_number(static_cast<uint16_t>(n), use_bjdata);


16373        }


16374        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())


16375        {


16376            if (add_prefix)


16377            {


16378                oa->write_character(to_char_type('l'));  // int32


16379            }


16380            write_number(static_cast<std::int32_t>(n), use_bjdata);


16381        }


16382        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)())))


16383        {


16384            if (add_prefix)


16385            {


16386                oa->write_character(to_char_type('m'));  // uint32 - bjdata only


16387            }


16388            write_number(static_cast<uint32_t>(n), use_bjdata);


16389        }


16390        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())


16391        {


16392            if (add_prefix)


16393            {


16394                oa->write_character(to_char_type('L'));  // int64


16395            }


16396            write_number(static_cast<std::int64_t>(n), use_bjdata);


16397        }


16398        // LCOV_EXCL_START


16399        else


16400        {


16401            if (add_prefix)


16402            {


16403                oa->write_character(to_char_type('H'));  // high-precision number


16404            }


16405


16406            const auto number = BasicJsonType(n).dump();


16407            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);


16408            for (std::size_t i = 0; i < number.size(); ++i)


16409            {


16410                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));


16411            }


16412        }


16413        // LCOV_EXCL_STOP


16414    }


16415


16416    /*!


16417    @brief determine the type prefix of container values


16418    */


16419    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept


16420    {


16421        switch (j.type())


16422        {


16423            case value_t::null:


16424                return 'Z';


16425


16426            case value_t::boolean:


16427                return j.m_value.boolean ? 'T' : 'F';


16428


16429            case value_t::number_integer:


16430            {


16431                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())


16432                {


16433                    return 'i';


16434                }


16435                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())


16436                {


16437                    return 'U';


16438                }


16439                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())


16440                {


16441                    return 'I';


16442                }


16443                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))


16444                {


16445                    return 'u';


16446                }


16447                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())


16448                {


16449                    return 'l';


16450                }


16451                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))


16452                {


16453                    return 'm';


16454                }


16455                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())


16456                {


16457                    return 'L';


16458                }


16459                // anything else is treated as high-precision number


16460                return 'H'; // LCOV_EXCL_LINE


16461            }


16462


16463            case value_t::number_unsigned:


16464            {


16465                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))


16466                {


16467                    return 'i';


16468                }


16469                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))


16470                {


16471                    return 'U';


16472                }


16473                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))


16474                {


16475                    return 'I';


16476                }


16477                if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))


16478                {


16479                    return 'u';


16480                }


16481                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))


16482                {


16483                    return 'l';


16484                }


16485                if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))


16486                {


16487                    return 'm';


16488                }


16489                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))


16490                {


16491                    return 'L';


16492                }


16493                if (use_bjdata && j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())


16494                {


16495                    return 'M';


16496                }


16497                // anything else is treated as high-precision number


16498                return 'H'; // LCOV_EXCL_LINE


16499            }


16500


16501            case value_t::number_float:


16502                return get_ubjson_float_prefix(j.m_value.number_float);


16503


16504            case value_t::string:


16505                return 'S';


16506


16507            case value_t::array: // fallthrough


16508            case value_t::binary:


16509                return '[';


16510


16511            case value_t::object:


16512                return '{';


16513


16514            case value_t::discarded:


16515            default:  // discarded values


16516                return 'N';


16517        }


16518    }


16519


16520    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)


16521    {


16522        return 'd';  // float 32


16523    }


16524


16525    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)


16526    {


16527        return 'D';  // float 64


16528    }


16529


16530    /*!


16531    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid


16532    */


16533    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)


16534    {


16535        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},


16536            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}


16537        };


16538


16539        string_t key = "_ArrayType_";


16540        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));


16541        if (it == bjdtype.end())


16542        {


16543            return true;


16544        }


16545        CharType dtype = it->second;


16546


16547        key = "_ArraySize_";


16548        std::size_t len = (value.at(key).empty() ? 0 : 1);


16549        for (const auto& el : value.at(key))


16550        {


16551            len *= static_cast<std::size_t>(el.m_value.number_unsigned);


16552        }


16553


16554        key = "_ArrayData_";


16555        if (value.at(key).size() != len)


16556        {


16557            return true;


16558        }


16559


16560        oa->write_character('[');


16561        oa->write_character('$');


16562        oa->write_character(dtype);


16563        oa->write_character('#');


16564


16565        key = "_ArraySize_";


16566        write_ubjson(value.at(key), use_count, use_type, true,  true);


16567


16568        key = "_ArrayData_";


16569        if (dtype == 'U' || dtype == 'C')


16570        {


16571            for (const auto& el : value.at(key))


16572            {


16573                write_number(static_cast<std::uint8_t>(el.m_value.number_unsigned), true);


16574            }


16575        }


16576        else if (dtype == 'i')


16577        {


16578            for (const auto& el : value.at(key))


16579            {


16580                write_number(static_cast<std::int8_t>(el.m_value.number_integer), true);


16581            }


16582        }


16583        else if (dtype == 'u')


16584        {


16585            for (const auto& el : value.at(key))


16586            {


16587                write_number(static_cast<std::uint16_t>(el.m_value.number_unsigned), true);


16588            }


16589        }


16590        else if (dtype == 'I')


16591        {


16592            for (const auto& el : value.at(key))


16593            {


16594                write_number(static_cast<std::int16_t>(el.m_value.number_integer), true);


16595            }


16596        }


16597        else if (dtype == 'm')


16598        {


16599            for (const auto& el : value.at(key))


16600            {


16601                write_number(static_cast<std::uint32_t>(el.m_value.number_unsigned), true);


16602            }


16603        }


16604        else if (dtype == 'l')


16605        {


16606            for (const auto& el : value.at(key))


16607            {


16608                write_number(static_cast<std::int32_t>(el.m_value.number_integer), true);


16609            }


16610        }


16611        else if (dtype == 'M')


16612        {


16613            for (const auto& el : value.at(key))


16614            {


16615                write_number(static_cast<std::uint64_t>(el.m_value.number_unsigned), true);


16616            }


16617        }


16618        else if (dtype == 'L')


16619        {


16620            for (const auto& el : value.at(key))


16621            {


16622                write_number(static_cast<std::int64_t>(el.m_value.number_integer), true);


16623            }


16624        }


16625        else if (dtype == 'd')


16626        {


16627            for (const auto& el : value.at(key))


16628            {


16629                write_number(static_cast<float>(el.m_value.number_float), true);


16630            }


16631        }


16632        else if (dtype == 'D')


16633        {


16634            for (const auto& el : value.at(key))


16635            {


16636                write_number(static_cast<double>(el.m_value.number_float), true);


16637            }


16638        }


16639        return false;


16640    }


16641


16642    ///////////////////////


16643    // Utility functions //


16644    ///////////////////////


16645


16646    /*


16647    @brief write a number to output input


16648    @param[in] n number of type @a NumberType


16649    @param[in] OutputIsLittleEndian Set to true if output data is


16650                                 required to be little endian


16651    @tparam NumberType the type of the number


16652


16653    @note This function needs to respect the system's endianness, because bytes


16654          in CBOR, MessagePack, and UBJSON are stored in network order (big


16655          endian) and therefore need reordering on little endian systems.


16656          On the other hand, BSON and BJData use little endian and should reorder


16657          on big endian systems.


16658    */


16659    template<typename NumberType>


16660    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)


16661    {


16662        // step 1: write number to array of length NumberType


16663        std::array<CharType, sizeof(NumberType)> vec{};


16664        std::memcpy(vec.data(), &n, sizeof(NumberType));


16665


16666        // step 2: write array to output (with possible reordering)


16667        if (is_little_endian != OutputIsLittleEndian)


16668        {


16669            // reverse byte order prior to conversion if necessary


16670            std::reverse(vec.begin(), vec.end());


16671        }


16672


16673        oa->write_characters(vec.data(), sizeof(NumberType));


16674    }


16675


16676    void write_compact_float(const number_float_t n, detail::input_format_t format)


16677    {


16678#ifdef __GNUC__


16679#pragma GCC diagnostic push


16680#pragma GCC diagnostic ignored "-Wfloat-equal"


16681#endif


16682        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&


16683                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&


16684                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))


16685        {


16686            oa->write_character(format == detail::input_format_t::cbor


16687                                ? get_cbor_float_prefix(static_cast<float>(n))


16688                                : get_msgpack_float_prefix(static_cast<float>(n)));


16689            write_number(static_cast<float>(n));


16690        }


16691        else


16692        {


16693            oa->write_character(format == detail::input_format_t::cbor


16694                                ? get_cbor_float_prefix(n)


16695                                : get_msgpack_float_prefix(n));


16696            write_number(n);


16697        }


16698#ifdef __GNUC__


16699#pragma GCC diagnostic pop


16700#endif


16701    }


16702


16703  public:


16704    // The following to_char_type functions are implement the conversion


16705    // between uint8_t and CharType. In case CharType is not unsigned,


16706    // such a conversion is required to allow values greater than 128.


16707    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.


16708    template < typename C = CharType,


16709               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >


16710    static constexpr CharType to_char_type(std::uint8_t x) noexcept


16711    {


16712        return *reinterpret_cast<char*>(&x);


16713    }


16714


16715    template < typename C = CharType,


16716               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >


16717    static CharType to_char_type(std::uint8_t x) noexcept


16718    {


16719        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");


16720        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");


16721        CharType result;


16722        std::memcpy(&result, &x, sizeof(x));


16723        return result;


16724    }


16725


16726    template<typename C = CharType,


16727             enable_if_t<std::is_unsigned<C>::value>* = nullptr>


16728    static constexpr CharType to_char_type(std::uint8_t x) noexcept


16729    {


16730        return x;


16731    }


16732


16733    template < typename InputCharType, typename C = CharType,


16734               enable_if_t <


16735                   std::is_signed<C>::value &&


16736                   std::is_signed<char>::value &&


16737                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value


16738                   > * = nullptr >


16739    static constexpr CharType to_char_type(InputCharType x) noexcept


16740    {


16741        return x;


16742    }


16743


16744  private:


16745    /// whether we can assume little endianness


16746    const bool is_little_endian = little_endianness();


16747


16748    /// the output


16749    output_adapter_t<CharType> oa = nullptr;


16750};


16751


16752}  // namespace detail


16753NLOHMANN_JSON_NAMESPACE_END


16754


16755// #include <nlohmann/detail/output/output_adapters.hpp>


16756


16757// #include <nlohmann/detail/output/serializer.hpp>


16758//     __ _____ _____ _____


16759//  __|  |   __|     |   | |  JSON for Modern C++


16760// |  |  |__   |  |  | | | |  version 3.11.2


16761// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


16762//


16763// SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>


16764// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


16765// SPDX-License-Identifier: MIT


16766


16767


16768


16769#include <algorithm> // reverse, remove, fill, find, none_of


16770#include <array> // array


16771#include <clocale> // localeconv, lconv


16772#include <cmath> // labs, isfinite, isnan, signbit


16773#include <cstddef> // size_t, ptrdiff_t


16774#include <cstdint> // uint8_t


16775#include <cstdio> // snprintf


16776#include <limits> // numeric_limits


16777#include <string> // string, char_traits


16778#include <iomanip> // setfill, setw


16779#include <type_traits> // is_same


16780#include <utility> // move


16781


16782// #include <nlohmann/detail/conversions/to_chars.hpp>


16783//     __ _____ _____ _____


16784//  __|  |   __|     |   | |  JSON for Modern C++


16785// |  |  |__   |  |  | | | |  version 3.11.2


16786// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


16787//


16788// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>


16789// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


16790// SPDX-License-Identifier: MIT


16791


16792


16793


16794#include <array> // array


16795#include <cmath>   // signbit, isfinite


16796#include <cstdint> // intN_t, uintN_t


16797#include <cstring> // memcpy, memmove


16798#include <limits> // numeric_limits


16799#include <type_traits> // conditional


16800


16801// #include <nlohmann/detail/macro_scope.hpp>


16802


16803


16804NLOHMANN_JSON_NAMESPACE_BEGIN


16805namespace detail


16806{


16807


16808/*!


16809@brief implements the Grisu2 algorithm for binary to decimal floating-point


16810conversion.


16811


16812This implementation is a slightly modified version of the reference


16813implementation which may be obtained from


16814http://florian.loitsch.com/publications (bench.tar.gz).


16815


16816The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.


16817


16818For a detailed description of the algorithm see:


16819


16820[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with


16821    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming


16822    Language Design and Implementation, PLDI 2010


16823[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",


16824    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language


16825    Design and Implementation, PLDI 1996


16826*/


16827namespace dtoa_impl


16828{


16829


16830template<typename Target, typename Source>


16831Target reinterpret_bits(const Source source)


16832{


16833    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");


16834


16835    Target target;


16836    std::memcpy(&target, &source, sizeof(Source));


16837    return target;


16838}


16839


16840struct diyfp // f * 2^e


16841{


16842    static constexpr int kPrecision = 64; // = q


16843


16844    std::uint64_t f = 0;


16845    int e = 0;


16846


16847    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}


16848


16849    /*!


16850    @brief returns x - y


16851    @pre x.e == y.e and x.f >= y.f


16852    */


16853    static diyfp sub(const diyfp& x, const diyfp& y) noexcept


16854    {


16855        JSON_ASSERT(x.e == y.e);


16856        JSON_ASSERT(x.f >= y.f);


16857


16858        return {x.f - y.f, x.e};


16859    }


16860


16861    /*!


16862    @brief returns x * y


16863    @note The result is rounded. (Only the upper q bits are returned.)


16864    */


16865    static diyfp mul(const diyfp& x, const diyfp& y) noexcept


16866    {


16867        static_assert(kPrecision == 64, "internal error");


16868


16869        // Computes:


16870        //  f = round((x.f * y.f) / 2^q)


16871        //  e = x.e + y.e + q


16872


16873        // Emulate the 64-bit * 64-bit multiplication:


16874        //


16875        // p = u * v


16876        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)


16877        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )


16878        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )


16879        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )


16880        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)


16881        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )


16882        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )


16883        //


16884        // (Since Q might be larger than 2^32 - 1)


16885        //


16886        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)


16887        //


16888        // (Q_hi + H does not overflow a 64-bit int)


16889        //


16890        //   = p_lo + 2^64 p_hi


16891


16892        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;


16893        const std::uint64_t u_hi = x.f >> 32u;


16894        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;


16895        const std::uint64_t v_hi = y.f >> 32u;


16896


16897        const std::uint64_t p0 = u_lo * v_lo;


16898        const std::uint64_t p1 = u_lo * v_hi;


16899        const std::uint64_t p2 = u_hi * v_lo;


16900        const std::uint64_t p3 = u_hi * v_hi;


16901


16902        const std::uint64_t p0_hi = p0 >> 32u;


16903        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;


16904        const std::uint64_t p1_hi = p1 >> 32u;


16905        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;


16906        const std::uint64_t p2_hi = p2 >> 32u;


16907


16908        std::uint64_t Q = p0_hi + p1_lo + p2_lo;


16909


16910        // The full product might now be computed as


16911        //


16912        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)


16913        // p_lo = p0_lo + (Q << 32)


16914        //


16915        // But in this particular case here, the full p_lo is not required.


16916        // Effectively we only need to add the highest bit in p_lo to p_hi (and


16917        // Q_hi + 1 does not overflow).


16918


16919        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up


16920


16921        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);


16922


16923        return {h, x.e + y.e + 64};


16924    }


16925


16926    /*!


16927    @brief normalize x such that the significand is >= 2^(q-1)


16928    @pre x.f != 0


16929    */


16930    static diyfp normalize(diyfp x) noexcept


16931    {


16932        JSON_ASSERT(x.f != 0);


16933


16934        while ((x.f >> 63u) == 0)


16935        {


16936            x.f <<= 1u;


16937            x.e--;


16938        }


16939


16940        return x;


16941    }


16942


16943    /*!


16944    @brief normalize x such that the result has the exponent E


16945    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.


16946    */


16947    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept


16948    {


16949        const int delta = x.e - target_exponent;


16950


16951        JSON_ASSERT(delta >= 0);


16952        JSON_ASSERT(((x.f << delta) >> delta) == x.f);


16953


16954        return {x.f << delta, target_exponent};


16955    }


16956};


16957


16958struct boundaries


16959{


16960    diyfp w;


16961    diyfp minus;


16962    diyfp plus;


16963};


16964


16965/*!


16966Compute the (normalized) diyfp representing the input number 'value' and its


16967boundaries.


16968


16969@pre value must be finite and positive


16970*/


16971template<typename FloatType>


16972boundaries compute_boundaries(FloatType value)


16973{


16974    JSON_ASSERT(std::isfinite(value));


16975    JSON_ASSERT(value > 0);


16976


16977    // Convert the IEEE representation into a diyfp.


16978    //


16979    // If v is denormal:


16980    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))


16981    // If v is normalized:


16982    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))


16983


16984    static_assert(std::numeric_limits<FloatType>::is_iec559,


16985                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");


16986


16987    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)


16988    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);


16989    constexpr int      kMinExp    = 1 - kBias;


16990    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)


16991


16992    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;


16993


16994    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));


16995    const std::uint64_t E = bits >> (kPrecision - 1);


16996    const std::uint64_t F = bits & (kHiddenBit - 1);


16997


16998    const bool is_denormal = E == 0;


16999    const diyfp v = is_denormal


17000                    ? diyfp(F, kMinExp)


17001                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);


17002


17003    // Compute the boundaries m- and m+ of the floating-point value


17004    // v = f * 2^e.


17005    //


17006    // Determine v- and v+, the floating-point predecessor and successor if v,


17007    // respectively.


17008    //


17009    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)


17010    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)


17011    //


17012    //      v+ = v + 2^e


17013    //


17014    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_


17015    // between m- and m+ round to v, regardless of how the input rounding


17016    // algorithm breaks ties.


17017    //


17018    //      ---+-------------+-------------+-------------+-------------+---  (A)


17019    //         v-            m-            v             m+            v+


17020    //


17021    //      -----------------+------+------+-------------+-------------+---  (B)


17022    //                       v-     m-     v             m+            v+


17023


17024    const bool lower_boundary_is_closer = F == 0 && E > 1;


17025    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);


17026    const diyfp m_minus = lower_boundary_is_closer


17027                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)


17028                          : diyfp(2 * v.f - 1, v.e - 1); // (A)


17029


17030    // Determine the normalized w+ = m+.


17031    const diyfp w_plus = diyfp::normalize(m_plus);


17032


17033    // Determine w- = m- such that e_(w-) = e_(w+).


17034    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);


17035


17036    return {diyfp::normalize(v), w_minus, w_plus};


17037}


17038


17039// Given normalized diyfp w, Grisu needs to find a (normalized) cached


17040// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies


17041// within a certain range [alpha, gamma] (Definition 3.2 from [1])


17042//


17043//      alpha <= e = e_c + e_w + q <= gamma


17044//


17045// or


17046//


17047//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q


17048//                          <= f_c * f_w * 2^gamma


17049//


17050// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies


17051//


17052//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma


17053//


17054// or


17055//


17056//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)


17057//


17058// The choice of (alpha,gamma) determines the size of the table and the form of


17059// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well


17060// in practice:


17061//


17062// The idea is to cut the number c * w = f * 2^e into two parts, which can be


17063// processed independently: An integral part p1, and a fractional part p2:


17064//


17065//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e


17066//              = (f div 2^-e) + (f mod 2^-e) * 2^e


17067//              = p1 + p2 * 2^e


17068//


17069// The conversion of p1 into decimal form requires a series of divisions and


17070// modulos by (a power of) 10. These operations are faster for 32-bit than for


17071// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be


17072// achieved by choosing


17073//


17074//      -e >= 32   or   e <= -32 := gamma


17075//


17076// In order to convert the fractional part


17077//


17078//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...


17079//


17080// into decimal form, the fraction is repeatedly multiplied by 10 and the digits


17081// d[-i] are extracted in order:


17082//


17083//      (10 * p2) div 2^-e = d[-1]


17084//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...


17085//


17086// The multiplication by 10 must not overflow. It is sufficient to choose


17087//


17088//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.


17089//


17090// Since p2 = f mod 2^-e < 2^-e,


17091//


17092//      -e <= 60   or   e >= -60 := alpha


17093


17094constexpr int kAlpha = -60;


17095constexpr int kGamma = -32;


17096


17097struct cached_power // c = f * 2^e ~= 10^k


17098{


17099    std::uint64_t f;


17100    int e;


17101    int k;


17102};


17103


17104/*!


17105For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached


17106power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c


17107satisfies (Definition 3.2 from [1])


17108


17109     alpha <= e_c + e + q <= gamma.


17110*/


17111inline cached_power get_cached_power_for_binary_exponent(int e)


17112{


17113    // Now


17114    //


17115    //      alpha <= e_c + e + q <= gamma                                    (1)


17116    //      ==> f_c * 2^alpha <= c * 2^e * 2^q


17117    //


17118    // and since the c's are normalized, 2^(q-1) <= f_c,


17119    //


17120    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)


17121    //      ==> 2^(alpha - e - 1) <= c


17122    //


17123    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as


17124    //


17125    //      k = ceil( log_10( 2^(alpha - e - 1) ) )


17126    //        = ceil( (alpha - e - 1) * log_10(2) )


17127    //


17128    // From the paper:


17129    // "In theory the result of the procedure could be wrong since c is rounded,


17130    //  and the computation itself is approximated [...]. In practice, however,


17131    //  this simple function is sufficient."


17132    //


17133    // For IEEE double precision floating-point numbers converted into


17134    // normalized diyfp's w = f * 2^e, with q = 64,


17135    //


17136    //      e >= -1022      (min IEEE exponent)


17137    //           -52        (p - 1)


17138    //           -52        (p - 1, possibly normalize denormal IEEE numbers)


17139    //           -11        (normalize the diyfp)


17140    //         = -1137


17141    //


17142    // and


17143    //


17144    //      e <= +1023      (max IEEE exponent)


17145    //           -52        (p - 1)


17146    //           -11        (normalize the diyfp)


17147    //         = 960


17148    //


17149    // This binary exponent range [-1137,960] results in a decimal exponent


17150    // range [-307,324]. One does not need to store a cached power for each


17151    // k in this range. For each such k it suffices to find a cached power


17152    // such that the exponent of the product lies in [alpha,gamma].


17153    // This implies that the difference of the decimal exponents of adjacent


17154    // table entries must be less than or equal to


17155    //


17156    //      floor( (gamma - alpha) * log_10(2) ) = 8.


17157    //


17158    // (A smaller distance gamma-alpha would require a larger table.)


17159


17160    // NB:


17161    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.


17162


17163    constexpr int kCachedPowersMinDecExp = -300;


17164    constexpr int kCachedPowersDecStep = 8;


17165


17166    static constexpr std::array<cached_power, 79> kCachedPowers =


17167    {


17168        {


17169            { 0xAB70FE17C79AC6CA, -1060, -300 },


17170            { 0xFF77B1FCBEBCDC4F, -1034, -292 },


17171            { 0xBE5691EF416BD60C, -1007, -284 },


17172            { 0x8DD01FAD907FFC3C,  -980, -276 },


17173            { 0xD3515C2831559A83,  -954, -268 },


17174            { 0x9D71AC8FADA6C9B5,  -927, -260 },


17175            { 0xEA9C227723EE8BCB,  -901, -252 },


17176            { 0xAECC49914078536D,  -874, -244 },


17177            { 0x823C12795DB6CE57,  -847, -236 },


17178            { 0xC21094364DFB5637,  -821, -228 },


17179            { 0x9096EA6F3848984F,  -794, -220 },


17180            { 0xD77485CB25823AC7,  -768, -212 },


17181            { 0xA086CFCD97BF97F4,  -741, -204 },


17182            { 0xEF340A98172AACE5,  -715, -196 },


17183            { 0xB23867FB2A35B28E,  -688, -188 },


17184            { 0x84C8D4DFD2C63F3B,  -661, -180 },


17185            { 0xC5DD44271AD3CDBA,  -635, -172 },


17186            { 0x936B9FCEBB25C996,  -608, -164 },


17187            { 0xDBAC6C247D62A584,  -582, -156 },


17188            { 0xA3AB66580D5FDAF6,  -555, -148 },


17189            { 0xF3E2F893DEC3F126,  -529, -140 },


17190            { 0xB5B5ADA8AAFF80B8,  -502, -132 },


17191            { 0x87625F056C7C4A8B,  -475, -124 },


17192            { 0xC9BCFF6034C13053,  -449, -116 },


17193            { 0x964E858C91BA2655,  -422, -108 },


17194            { 0xDFF9772470297EBD,  -396, -100 },


17195            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },


17196            { 0xF8A95FCF88747D94,  -343,  -84 },


17197            { 0xB94470938FA89BCF,  -316,  -76 },


17198            { 0x8A08F0F8BF0F156B,  -289,  -68 },


17199            { 0xCDB02555653131B6,  -263,  -60 },


17200            { 0x993FE2C6D07B7FAC,  -236,  -52 },


17201            { 0xE45C10C42A2B3B06,  -210,  -44 },


17202            { 0xAA242499697392D3,  -183,  -36 },


17203            { 0xFD87B5F28300CA0E,  -157,  -28 },


17204            { 0xBCE5086492111AEB,  -130,  -20 },


17205            { 0x8CBCCC096F5088CC,  -103,  -12 },


17206            { 0xD1B71758E219652C,   -77,   -4 },


17207            { 0x9C40000000000000,   -50,    4 },


17208            { 0xE8D4A51000000000,   -24,   12 },


17209            { 0xAD78EBC5AC620000,     3,   20 },


17210            { 0x813F3978F8940984,    30,   28 },


17211            { 0xC097CE7BC90715B3,    56,   36 },


17212            { 0x8F7E32CE7BEA5C70,    83,   44 },


17213            { 0xD5D238A4ABE98068,   109,   52 },


17214            { 0x9F4F2726179A2245,   136,   60 },


17215            { 0xED63A231D4C4FB27,   162,   68 },


17216            { 0xB0DE65388CC8ADA8,   189,   76 },


17217            { 0x83C7088E1AAB65DB,   216,   84 },


17218            { 0xC45D1DF942711D9A,   242,   92 },


17219            { 0x924D692CA61BE758,   269,  100 },


17220            { 0xDA01EE641A708DEA,   295,  108 },


17221            { 0xA26DA3999AEF774A,   322,  116 },


17222            { 0xF209787BB47D6B85,   348,  124 },


17223            { 0xB454E4A179DD1877,   375,  132 },


17224            { 0x865B86925B9BC5C2,   402,  140 },


17225            { 0xC83553C5C8965D3D,   428,  148 },


17226            { 0x952AB45CFA97A0B3,   455,  156 },


17227            { 0xDE469FBD99A05FE3,   481,  164 },


17228            { 0xA59BC234DB398C25,   508,  172 },


17229            { 0xF6C69A72A3989F5C,   534,  180 },


17230            { 0xB7DCBF5354E9BECE,   561,  188 },


17231            { 0x88FCF317F22241E2,   588,  196 },


17232            { 0xCC20CE9BD35C78A5,   614,  204 },


17233            { 0x98165AF37B2153DF,   641,  212 },


17234            { 0xE2A0B5DC971F303A,   667,  220 },


17235            { 0xA8D9D1535CE3B396,   694,  228 },


17236            { 0xFB9B7CD9A4A7443C,   720,  236 },


17237            { 0xBB764C4CA7A44410,   747,  244 },


17238            { 0x8BAB8EEFB6409C1A,   774,  252 },


17239            { 0xD01FEF10A657842C,   800,  260 },


17240            { 0x9B10A4E5E9913129,   827,  268 },


17241            { 0xE7109BFBA19C0C9D,   853,  276 },


17242            { 0xAC2820D9623BF429,   880,  284 },


17243            { 0x80444B5E7AA7CF85,   907,  292 },


17244            { 0xBF21E44003ACDD2D,   933,  300 },


17245            { 0x8E679C2F5E44FF8F,   960,  308 },


17246            { 0xD433179D9C8CB841,   986,  316 },


17247            { 0x9E19DB92B4E31BA9,  1013,  324 },


17248        }


17249    };


17250


17251    // This computation gives exactly the same results for k as


17252    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)


17253    // for |e| <= 1500, but doesn't require floating-point operations.


17254    // NB: log_10(2) ~= 78913 / 2^18


17255    JSON_ASSERT(e >= -1500);


17256    JSON_ASSERT(e <=  1500);


17257    const int f = kAlpha - e - 1;


17258    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);


17259


17260    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;


17261    JSON_ASSERT(index >= 0);


17262    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());


17263


17264    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];


17265    JSON_ASSERT(kAlpha <= cached.e + e + 64);


17266    JSON_ASSERT(kGamma >= cached.e + e + 64);


17267


17268    return cached;


17269}


17270


17271/*!


17272For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.


17273For n == 0, returns 1 and sets pow10 := 1.


17274*/


17275inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)


17276{


17277    // LCOV_EXCL_START


17278    if (n >= 1000000000)


17279    {


17280        pow10 = 1000000000;


17281        return 10;


17282    }


17283    // LCOV_EXCL_STOP


17284    if (n >= 100000000)


17285    {


17286        pow10 = 100000000;


17287        return  9;


17288    }


17289    if (n >= 10000000)


17290    {


17291        pow10 = 10000000;


17292        return  8;


17293    }


17294    if (n >= 1000000)


17295    {


17296        pow10 = 1000000;


17297        return  7;


17298    }


17299    if (n >= 100000)


17300    {


17301        pow10 = 100000;


17302        return  6;


17303    }


17304    if (n >= 10000)


17305    {


17306        pow10 = 10000;


17307        return  5;


17308    }


17309    if (n >= 1000)


17310    {


17311        pow10 = 1000;


17312        return  4;


17313    }


17314    if (n >= 100)


17315    {


17316        pow10 = 100;


17317        return  3;


17318    }


17319    if (n >= 10)


17320    {


17321        pow10 = 10;


17322        return  2;


17323    }


17324


17325    pow10 = 1;


17326    return 1;


17327}


17328


17329inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,


17330                         std::uint64_t rest, std::uint64_t ten_k)


17331{


17332    JSON_ASSERT(len >= 1);


17333    JSON_ASSERT(dist <= delta);


17334    JSON_ASSERT(rest <= delta);


17335    JSON_ASSERT(ten_k > 0);


17336


17337    //               <--------------------------- delta ---->


17338    //                                  <---- dist --------->


17339    // --------------[------------------+-------------------]--------------


17340    //               M-                 w                   M+


17341    //


17342    //                                  ten_k


17343    //                                <------>


17344    //                                       <---- rest ---->


17345    // --------------[------------------+----+--------------]--------------


17346    //                                  w    V


17347    //                                       = buf * 10^k


17348    //


17349    // ten_k represents a unit-in-the-last-place in the decimal representation


17350    // stored in buf.


17351    // Decrement buf by ten_k while this takes buf closer to w.


17352


17353    // The tests are written in this order to avoid overflow in unsigned


17354    // integer arithmetic.


17355


17356    while (rest < dist


17357            && delta - rest >= ten_k


17358            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))


17359    {


17360        JSON_ASSERT(buf[len - 1] != '0');


17361        buf[len - 1]--;


17362        rest += ten_k;


17363    }


17364}


17365


17366/*!


17367Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.


17368M- and M+ must be normalized and share the same exponent -60 <= e <= -32.


17369*/


17370inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,


17371                             diyfp M_minus, diyfp w, diyfp M_plus)


17372{


17373    static_assert(kAlpha >= -60, "internal error");


17374    static_assert(kGamma <= -32, "internal error");


17375


17376    // Generates the digits (and the exponent) of a decimal floating-point


17377    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's


17378    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.


17379    //


17380    //               <--------------------------- delta ---->


17381    //                                  <---- dist --------->


17382    // --------------[------------------+-------------------]--------------


17383    //               M-                 w                   M+


17384    //


17385    // Grisu2 generates the digits of M+ from left to right and stops as soon as


17386    // V is in [M-,M+].


17387


17388    JSON_ASSERT(M_plus.e >= kAlpha);


17389    JSON_ASSERT(M_plus.e <= kGamma);


17390


17391    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)


17392    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)


17393


17394    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):


17395    //


17396    //      M+ = f * 2^e


17397    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e


17398    //         = ((p1        ) * 2^-e + (p2        )) * 2^e


17399    //         = p1 + p2 * 2^e


17400


17401    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);


17402


17403    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.)


17404    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e


17405


17406    // 1)


17407    //


17408    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]


17409


17410    JSON_ASSERT(p1 > 0);


17411


17412    std::uint32_t pow10{};


17413    const int k = find_largest_pow10(p1, pow10);


17414


17415    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)


17416    //


17417    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))


17418    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))


17419    //


17420    //      M+ = p1                                             + p2 * 2^e


17421    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e


17422    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e


17423    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e


17424    //


17425    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)


17426    //


17427    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]


17428    //


17429    // but stop as soon as


17430    //


17431    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e


17432


17433    int n = k;


17434    while (n > 0)


17435    {


17436        // Invariants:


17437        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)


17438        //      pow10 = 10^(n-1) <= p1 < 10^n


17439        //


17440        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)


17441        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)


17442        //


17443        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e


17444        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)


17445        //


17446        JSON_ASSERT(d <= 9);


17447        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d


17448        //


17449        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)


17450        //


17451        p1 = r;


17452        n--;


17453        //


17454        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)


17455        //      pow10 = 10^n


17456        //


17457


17458        // Now check if enough digits have been generated.


17459        // Compute


17460        //


17461        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e


17462        //


17463        // Note:


17464        // Since rest and delta share the same exponent e, it suffices to


17465        // compare the significands.


17466        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;


17467        if (rest <= delta)


17468        {


17469            // V = buffer * 10^n, with M- <= V <= M+.


17470


17471            decimal_exponent += n;


17472


17473            // We may now just stop. But instead look if the buffer could be


17474            // decremented to bring V closer to w.


17475            //


17476            // pow10 = 10^n is now 1 ulp in the decimal representation V.


17477            // The rounding procedure works with diyfp's with an implicit


17478            // exponent of e.


17479            //


17480            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e


17481            //


17482            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;


17483            grisu2_round(buffer, length, dist, delta, rest, ten_n);


17484


17485            return;


17486        }


17487


17488        pow10 /= 10;


17489        //


17490        //      pow10 = 10^(n-1) <= p1 < 10^n


17491        // Invariants restored.


17492    }


17493


17494    // 2)


17495    //


17496    // The digits of the integral part have been generated:


17497    //


17498    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e


17499    //         = buffer            + p2 * 2^e


17500    //


17501    // Now generate the digits of the fractional part p2 * 2^e.


17502    //


17503    // Note:


17504    // No decimal point is generated: the exponent is adjusted instead.


17505    //


17506    // p2 actually represents the fraction


17507    //


17508    //      p2 * 2^e


17509    //          = p2 / 2^-e


17510    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...


17511    //


17512    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)


17513    //


17514    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m


17515    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)


17516    //


17517    // using


17518    //


17519    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)


17520    //                = (                   d) * 2^-e + (                   r)


17521    //


17522    // or


17523    //      10^m * p2 * 2^e = d + r * 2^e


17524    //


17525    // i.e.


17526    //


17527    //      M+ = buffer + p2 * 2^e


17528    //         = buffer + 10^-m * (d + r * 2^e)


17529    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e


17530    //


17531    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e


17532


17533    JSON_ASSERT(p2 > delta);


17534


17535    int m = 0;


17536    for (;;)


17537    {


17538        // Invariant:


17539        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e


17540        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e


17541        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e


17542        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e


17543        //


17544        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);


17545        p2 *= 10;


17546        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e


17547        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e


17548        //


17549        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e


17550        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))


17551        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e


17552        //


17553        JSON_ASSERT(d <= 9);


17554        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d


17555        //


17556        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e


17557        //


17558        p2 = r;


17559        m++;


17560        //


17561        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e


17562        // Invariant restored.


17563


17564        // Check if enough digits have been generated.


17565        //


17566        //      10^-m * p2 * 2^e <= delta * 2^e


17567        //              p2 * 2^e <= 10^m * delta * 2^e


17568        //                    p2 <= 10^m * delta


17569        delta *= 10;


17570        dist  *= 10;


17571        if (p2 <= delta)


17572        {


17573            break;


17574        }


17575    }


17576


17577    // V = buffer * 10^-m, with M- <= V <= M+.


17578


17579    decimal_exponent -= m;


17580


17581    // 1 ulp in the decimal representation is now 10^-m.


17582    // Since delta and dist are now scaled by 10^m, we need to do the


17583    // same with ulp in order to keep the units in sync.


17584    //


17585    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e


17586    //


17587    const std::uint64_t ten_m = one.f;


17588    grisu2_round(buffer, length, dist, delta, p2, ten_m);


17589


17590    // By construction this algorithm generates the shortest possible decimal


17591    // number (Loitsch, Theorem 6.2) which rounds back to w.


17592    // For an input number of precision p, at least


17593    //


17594    //      N = 1 + ceil(p * log_10(2))


17595    //


17596    // decimal digits are sufficient to identify all binary floating-point


17597    // numbers (Matula, "In-and-Out conversions").


17598    // This implies that the algorithm does not produce more than N decimal


17599    // digits.


17600    //


17601    //      N = 17 for p = 53 (IEEE double precision)


17602    //      N = 9  for p = 24 (IEEE single precision)


17603}


17604


17605/*!


17606v = buf * 10^decimal_exponent


17607len is the length of the buffer (number of decimal digits)


17608The buffer must be large enough, i.e. >= max_digits10.


17609*/


17610JSON_HEDLEY_NON_NULL(1)


17611inline void grisu2(char* buf, int& len, int& decimal_exponent,


17612                   diyfp m_minus, diyfp v, diyfp m_plus)


17613{


17614    JSON_ASSERT(m_plus.e == m_minus.e);


17615    JSON_ASSERT(m_plus.e == v.e);


17616


17617    //  --------(-----------------------+-----------------------)--------    (A)


17618    //          m-                      v                       m+


17619    //


17620    //  --------------------(-----------+-----------------------)--------    (B)


17621    //                      m-          v                       m+


17622    //


17623    // First scale v (and m- and m+) such that the exponent is in the range


17624    // [alpha, gamma].


17625


17626    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);


17627


17628    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k


17629


17630    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]


17631    const diyfp w       = diyfp::mul(v,       c_minus_k);


17632    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);


17633    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);


17634


17635    //  ----(---+---)---------------(---+---)---------------(---+---)----


17636    //          w-                      w                       w+


17637    //          = c*m-                  = c*v                   = c*m+


17638    //


17639    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and


17640    // w+ are now off by a small amount.


17641    // In fact:


17642    //


17643    //      w - v * 10^k < 1 ulp


17644    //


17645    // To account for this inaccuracy, add resp. subtract 1 ulp.


17646    //


17647    //  --------+---[---------------(---+---)---------------]---+--------


17648    //          w-  M-                  w                   M+  w+


17649    //


17650    // Now any number in [M-, M+] (bounds included) will round to w when input,


17651    // regardless of how the input rounding algorithm breaks ties.


17652    //


17653    // And digit_gen generates the shortest possible such number in [M-, M+].


17654    // Note that this does not mean that Grisu2 always generates the shortest


17655    // possible number in the interval (m-, m+).


17656    const diyfp M_minus(w_minus.f + 1, w_minus.e);


17657    const diyfp M_plus (w_plus.f  - 1, w_plus.e );


17658


17659    decimal_exponent = -cached.k; // = -(-k) = k


17660


17661    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);


17662}


17663


17664/*!


17665v = buf * 10^decimal_exponent


17666len is the length of the buffer (number of decimal digits)


17667The buffer must be large enough, i.e. >= max_digits10.


17668*/


17669template<typename FloatType>


17670JSON_HEDLEY_NON_NULL(1)


17671void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)


17672{


17673    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,


17674                  "internal error: not enough precision");


17675


17676    JSON_ASSERT(std::isfinite(value));


17677    JSON_ASSERT(value > 0);


17678


17679    // If the neighbors (and boundaries) of 'value' are always computed for double-precision


17680    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting


17681    // decimal representations are not exactly "short".


17682    //


17683    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)


17684    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"


17685    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'


17686    // does.


17687    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the


17688    // representation using the corresponding std::from_chars function recovers value exactly". That


17689    // indicates that single precision floating-point numbers should be recovered using


17690    // 'std::strtof'.


17691    //


17692    // NB: If the neighbors are computed for single-precision numbers, there is a single float


17693    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision


17694    //     value is off by 1 ulp.


17695#if 0


17696    const boundaries w = compute_boundaries(static_cast<double>(value));


17697#else


17698    const boundaries w = compute_boundaries(value);


17699#endif


17700


17701    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);


17702}


17703


17704/*!


17705@brief appends a decimal representation of e to buf


17706@return a pointer to the element following the exponent.


17707@pre -1000 < e < 1000


17708*/


17709JSON_HEDLEY_NON_NULL(1)


17710JSON_HEDLEY_RETURNS_NON_NULL


17711inline char* append_exponent(char* buf, int e)


17712{


17713    JSON_ASSERT(e > -1000);


17714    JSON_ASSERT(e <  1000);


17715


17716    if (e < 0)


17717    {


17718        e = -e;


17719        *buf++ = '-';


17720    }


17721    else


17722    {


17723        *buf++ = '+';


17724    }


17725


17726    auto k = static_cast<std::uint32_t>(e);


17727    if (k < 10)


17728    {


17729        // Always print at least two digits in the exponent.


17730        // This is for compatibility with printf("%g").


17731        *buf++ = '0';


17732        *buf++ = static_cast<char>('0' + k);


17733    }


17734    else if (k < 100)


17735    {


17736        *buf++ = static_cast<char>('0' + k / 10);


17737        k %= 10;


17738        *buf++ = static_cast<char>('0' + k);


17739    }


17740    else


17741    {


17742        *buf++ = static_cast<char>('0' + k / 100);


17743        k %= 100;


17744        *buf++ = static_cast<char>('0' + k / 10);


17745        k %= 10;


17746        *buf++ = static_cast<char>('0' + k);


17747    }


17748


17749    return buf;


17750}


17751


17752/*!


17753@brief prettify v = buf * 10^decimal_exponent


17754


17755If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point


17756notation. Otherwise it will be printed in exponential notation.


17757


17758@pre min_exp < 0


17759@pre max_exp > 0


17760*/


17761JSON_HEDLEY_NON_NULL(1)


17762JSON_HEDLEY_RETURNS_NON_NULL


17763inline char* format_buffer(char* buf, int len, int decimal_exponent,


17764                           int min_exp, int max_exp)


17765{


17766    JSON_ASSERT(min_exp < 0);


17767    JSON_ASSERT(max_exp > 0);


17768


17769    const int k = len;


17770    const int n = len + decimal_exponent;


17771


17772    // v = buf * 10^(n-k)


17773    // k is the length of the buffer (number of decimal digits)


17774    // n is the position of the decimal point relative to the start of the buffer.


17775


17776    if (k <= n && n <= max_exp)


17777    {


17778        // digits[000]


17779        // len <= max_exp + 2


17780


17781        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));


17782        // Make it look like a floating-point number (#362, #378)


17783        buf[n + 0] = '.';


17784        buf[n + 1] = '0';


17785        return buf + (static_cast<size_t>(n) + 2);


17786    }


17787


17788    if (0 < n && n <= max_exp)


17789    {


17790        // dig.its


17791        // len <= max_digits10 + 1


17792


17793        JSON_ASSERT(k > n);


17794


17795        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));


17796        buf[n] = '.';


17797        return buf + (static_cast<size_t>(k) + 1U);


17798    }


17799


17800    if (min_exp < n && n <= 0)


17801    {


17802        // 0.[000]digits


17803        // len <= 2 + (-min_exp - 1) + max_digits10


17804


17805        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));


17806        buf[0] = '0';


17807        buf[1] = '.';


17808        std::memset(buf + 2, '0', static_cast<size_t>(-n));


17809        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));


17810    }


17811


17812    if (k == 1)


17813    {


17814        // dE+123


17815        // len <= 1 + 5


17816


17817        buf += 1;


17818    }


17819    else


17820    {


17821        // d.igitsE+123


17822        // len <= max_digits10 + 1 + 5


17823


17824        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);


17825        buf[1] = '.';


17826        buf += 1 + static_cast<size_t>(k);


17827    }


17828


17829    *buf++ = 'e';


17830    return append_exponent(buf, n - 1);


17831}


17832


17833}  // namespace dtoa_impl


17834


17835/*!


17836@brief generates a decimal representation of the floating-point number value in [first, last).


17837


17838The format of the resulting decimal representation is similar to printf's %g


17839format. Returns an iterator pointing past-the-end of the decimal representation.


17840


17841@note The input number must be finite, i.e. NaN's and Inf's are not supported.


17842@note The buffer must be large enough.


17843@note The result is NOT null-terminated.


17844*/


17845template<typename FloatType>


17846JSON_HEDLEY_NON_NULL(1, 2)


17847JSON_HEDLEY_RETURNS_NON_NULL


17848char* to_chars(char* first, const char* last, FloatType value)


17849{


17850    static_cast<void>(last); // maybe unused - fix warning


17851    JSON_ASSERT(std::isfinite(value));


17852


17853    // Use signbit(value) instead of (value < 0) since signbit works for -0.


17854    if (std::signbit(value))


17855    {


17856        value = -value;


17857        *first++ = '-';


17858    }


17859


17860#ifdef __GNUC__


17861#pragma GCC diagnostic push


17862#pragma GCC diagnostic ignored "-Wfloat-equal"


17863#endif


17864    if (value == 0) // +-0


17865    {


17866        *first++ = '0';


17867        // Make it look like a floating-point number (#362, #378)


17868        *first++ = '.';


17869        *first++ = '0';


17870        return first;


17871    }


17872#ifdef __GNUC__


17873#pragma GCC diagnostic pop


17874#endif


17875


17876    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);


17877


17878    // Compute v = buffer * 10^decimal_exponent.


17879    // The decimal digits are stored in the buffer, which needs to be interpreted


17880    // as an unsigned decimal integer.


17881    // len is the length of the buffer, i.e. the number of decimal digits.


17882    int len = 0;


17883    int decimal_exponent = 0;


17884    dtoa_impl::grisu2(first, len, decimal_exponent, value);


17885


17886    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);


17887


17888    // Format the buffer like printf("%.*g", prec, value)


17889    constexpr int kMinExp = -4;


17890    // Use digits10 here to increase compatibility with version 2.


17891    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;


17892


17893    JSON_ASSERT(last - first >= kMaxExp + 2);


17894    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);


17895    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);


17896


17897    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);


17898}


17899


17900}  // namespace detail


17901NLOHMANN_JSON_NAMESPACE_END


17902


17903// #include <nlohmann/detail/exceptions.hpp>


17904


17905// #include <nlohmann/detail/macro_scope.hpp>


17906


17907// #include <nlohmann/detail/meta/cpp_future.hpp>


17908


17909// #include <nlohmann/detail/output/binary_writer.hpp>


17910


17911// #include <nlohmann/detail/output/output_adapters.hpp>


17912


17913// #include <nlohmann/detail/string_concat.hpp>


17914


17915// #include <nlohmann/detail/value_t.hpp>


17916


17917


17918NLOHMANN_JSON_NAMESPACE_BEGIN


17919namespace detail


17920{


17921


17922///////////////////


17923// serialization //


17924///////////////////


17925


17926/// how to treat decoding errors


17927enum class error_handler_t


17928{


17929    strict,  ///< throw a type_error exception in case of invalid UTF-8


17930    replace, ///< replace invalid UTF-8 sequences with U+FFFD


17931    ignore   ///< ignore invalid UTF-8 sequences


17932};


17933


17934template<typename BasicJsonType>


17935class serializer


17936{


17937    using string_t = typename BasicJsonType::string_t;


17938    using number_float_t = typename BasicJsonType::number_float_t;


17939    using number_integer_t = typename BasicJsonType::number_integer_t;


17940    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;


17941    using binary_char_t = typename BasicJsonType::binary_t::value_type;


17942    static constexpr std::uint8_t UTF8_ACCEPT = 0;


17943    static constexpr std::uint8_t UTF8_REJECT = 1;


17944


17945  public:


17946    /*!


17947    @param[in] s  output stream to serialize to


17948    @param[in] ichar  indentation character to use


17949    @param[in] error_handler_  how to react on decoding errors


17950    */


17951    serializer(output_adapter_t<char> s, const char ichar,


17952               error_handler_t error_handler_ = error_handler_t::strict)


17953        : o(std::move(s))


17954        , loc(std::localeconv())


17955        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))


17956        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))


17957        , indent_char(ichar)


17958        , indent_string(512, indent_char)


17959        , error_handler(error_handler_)


17960    {}


17961


17962    // delete because of pointer members


17963    serializer(const serializer&) = delete;


17964    serializer& operator=(const serializer&) = delete;


17965    serializer(serializer&&) = delete;


17966    serializer& operator=(serializer&&) = delete;


17967    ~serializer() = default;


17968


17969    /*!


17970    @brief internal implementation of the serialization function


17971


17972    This function is called by the public member function dump and organizes


17973    the serialization internally. The indentation level is propagated as


17974    additional parameter. In case of arrays and objects, the function is


17975    called recursively.


17976


17977    - strings and object keys are escaped using `escape_string()`


17978    - integer numbers are converted implicitly via `operator<<`


17979    - floating-point numbers are converted to a string using `"%g"` format


17980    - binary values are serialized as objects containing the subtype and the


17981      byte array


17982


17983    @param[in] val               value to serialize


17984    @param[in] pretty_print      whether the output shall be pretty-printed


17985    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters


17986    in the output are escaped with `\uXXXX` sequences, and the result consists


17987    of ASCII characters only.


17988    @param[in] indent_step       the indent level


17989    @param[in] current_indent    the current indent level (only used internally)


17990    */


17991    void dump(const BasicJsonType& val,


17992              const bool pretty_print,


17993              const bool ensure_ascii,


17994              const unsigned int indent_step,


17995              const unsigned int current_indent = 0)


17996    {


17997        switch (val.m_type)


17998        {


17999            case value_t::object:


18000            {


18001                if (val.m_value.object->empty())


18002                {


18003                    o->write_characters("{}", 2);


18004                    return;


18005                }


18006


18007                if (pretty_print)


18008                {


18009                    o->write_characters("{\n", 2);


18010


18011                    // variable to hold indentation for recursive calls


18012                    const auto new_indent = current_indent + indent_step;


18013                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))


18014                    {


18015                        indent_string.resize(indent_string.size() * 2, ' ');


18016                    }


18017


18018                    // first n-1 elements


18019                    auto i = val.m_value.object->cbegin();


18020                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)


18021                    {


18022                        o->write_characters(indent_string.c_str(), new_indent);


18023                        o->write_character('\"');


18024                        dump_escaped(i->first, ensure_ascii);


18025                        o->write_characters("\": ", 3);


18026                        dump(i->second, true, ensure_ascii, indent_step, new_indent);


18027                        o->write_characters(",\n", 2);


18028                    }


18029


18030                    // last element


18031                    JSON_ASSERT(i != val.m_value.object->cend());


18032                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());


18033                    o->write_characters(indent_string.c_str(), new_indent);


18034                    o->write_character('\"');


18035                    dump_escaped(i->first, ensure_ascii);


18036                    o->write_characters("\": ", 3);


18037                    dump(i->second, true, ensure_ascii, indent_step, new_indent);


18038


18039                    o->write_character('\n');


18040                    o->write_characters(indent_string.c_str(), current_indent);


18041                    o->write_character('}');


18042                }


18043                else


18044                {


18045                    o->write_character('{');


18046


18047                    // first n-1 elements


18048                    auto i = val.m_value.object->cbegin();


18049                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)


18050                    {


18051                        o->write_character('\"');


18052                        dump_escaped(i->first, ensure_ascii);


18053                        o->write_characters("\":", 2);


18054                        dump(i->second, false, ensure_ascii, indent_step, current_indent);


18055                        o->write_character(',');


18056                    }


18057


18058                    // last element


18059                    JSON_ASSERT(i != val.m_value.object->cend());


18060                    JSON_ASSERT(std::next(i) == val.m_value.object->cend());


18061                    o->write_character('\"');


18062                    dump_escaped(i->first, ensure_ascii);


18063                    o->write_characters("\":", 2);


18064                    dump(i->second, false, ensure_ascii, indent_step, current_indent);


18065


18066                    o->write_character('}');


18067                }


18068


18069                return;


18070            }


18071


18072            case value_t::array:


18073            {


18074                if (val.m_value.array->empty())


18075                {


18076                    o->write_characters("[]", 2);


18077                    return;


18078                }


18079


18080                if (pretty_print)


18081                {


18082                    o->write_characters("[\n", 2);


18083


18084                    // variable to hold indentation for recursive calls


18085                    const auto new_indent = current_indent + indent_step;


18086                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))


18087                    {


18088                        indent_string.resize(indent_string.size() * 2, ' ');


18089                    }


18090


18091                    // first n-1 elements


18092                    for (auto i = val.m_value.array->cbegin();


18093                            i != val.m_value.array->cend() - 1; ++i)


18094                    {


18095                        o->write_characters(indent_string.c_str(), new_indent);


18096                        dump(*i, true, ensure_ascii, indent_step, new_indent);


18097                        o->write_characters(",\n", 2);


18098                    }


18099


18100                    // last element


18101                    JSON_ASSERT(!val.m_value.array->empty());


18102                    o->write_characters(indent_string.c_str(), new_indent);


18103                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);


18104


18105                    o->write_character('\n');


18106                    o->write_characters(indent_string.c_str(), current_indent);


18107                    o->write_character(']');


18108                }


18109                else


18110                {


18111                    o->write_character('[');


18112


18113                    // first n-1 elements


18114                    for (auto i = val.m_value.array->cbegin();


18115                            i != val.m_value.array->cend() - 1; ++i)


18116                    {


18117                        dump(*i, false, ensure_ascii, indent_step, current_indent);


18118                        o->write_character(',');


18119                    }


18120


18121                    // last element


18122                    JSON_ASSERT(!val.m_value.array->empty());


18123                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);


18124


18125                    o->write_character(']');


18126                }


18127


18128                return;


18129            }


18130


18131            case value_t::string:


18132            {


18133                o->write_character('\"');


18134                dump_escaped(*val.m_value.string, ensure_ascii);


18135                o->write_character('\"');


18136                return;


18137            }


18138


18139            case value_t::binary:


18140            {


18141                if (pretty_print)


18142                {


18143                    o->write_characters("{\n", 2);


18144


18145                    // variable to hold indentation for recursive calls


18146                    const auto new_indent = current_indent + indent_step;


18147                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))


18148                    {


18149                        indent_string.resize(indent_string.size() * 2, ' ');


18150                    }


18151


18152                    o->write_characters(indent_string.c_str(), new_indent);


18153


18154                    o->write_characters("\"bytes\": [", 10);


18155


18156                    if (!val.m_value.binary->empty())


18157                    {


18158                        for (auto i = val.m_value.binary->cbegin();


18159                                i != val.m_value.binary->cend() - 1; ++i)


18160                        {


18161                            dump_integer(*i);


18162                            o->write_characters(", ", 2);


18163                        }


18164                        dump_integer(val.m_value.binary->back());


18165                    }


18166


18167                    o->write_characters("],\n", 3);


18168                    o->write_characters(indent_string.c_str(), new_indent);


18169


18170                    o->write_characters("\"subtype\": ", 11);


18171                    if (val.m_value.binary->has_subtype())


18172                    {


18173                        dump_integer(val.m_value.binary->subtype());


18174                    }


18175                    else


18176                    {


18177                        o->write_characters("null", 4);


18178                    }


18179                    o->write_character('\n');


18180                    o->write_characters(indent_string.c_str(), current_indent);


18181                    o->write_character('}');


18182                }


18183                else


18184                {


18185                    o->write_characters("{\"bytes\":[", 10);


18186


18187                    if (!val.m_value.binary->empty())


18188                    {


18189                        for (auto i = val.m_value.binary->cbegin();


18190                                i != val.m_value.binary->cend() - 1; ++i)


18191                        {


18192                            dump_integer(*i);


18193                            o->write_character(',');


18194                        }


18195                        dump_integer(val.m_value.binary->back());


18196                    }


18197


18198                    o->write_characters("],\"subtype\":", 12);


18199                    if (val.m_value.binary->has_subtype())


18200                    {


18201                        dump_integer(val.m_value.binary->subtype());


18202                        o->write_character('}');


18203                    }


18204                    else


18205                    {


18206                        o->write_characters("null}", 5);


18207                    }


18208                }


18209                return;


18210            }


18211


18212            case value_t::boolean:


18213            {


18214                if (val.m_value.boolean)


18215                {


18216                    o->write_characters("true", 4);


18217                }


18218                else


18219                {


18220                    o->write_characters("false", 5);


18221                }


18222                return;


18223            }


18224


18225            case value_t::number_integer:


18226            {


18227                dump_integer(val.m_value.number_integer);


18228                return;


18229            }


18230


18231            case value_t::number_unsigned:


18232            {


18233                dump_integer(val.m_value.number_unsigned);


18234                return;


18235            }


18236


18237            case value_t::number_float:


18238            {


18239                dump_float(val.m_value.number_float);


18240                return;


18241            }


18242


18243            case value_t::discarded:


18244            {


18245                o->write_characters("<discarded>", 11);


18246                return;


18247            }


18248


18249            case value_t::null:


18250            {


18251                o->write_characters("null", 4);


18252                return;


18253            }


18254


18255            default:            // LCOV_EXCL_LINE


18256                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


18257        }


18258    }


18259


18260  JSON_PRIVATE_UNLESS_TESTED:


18261    /*!


18262    @brief dump escaped string


18263


18264    Escape a string by replacing certain special characters by a sequence of an


18265    escape character (backslash) and another character and other control


18266    characters by a sequence of "\u" followed by a four-digit hex


18267    representation. The escaped string is written to output stream @a o.


18268


18269    @param[in] s  the string to escape


18270    @param[in] ensure_ascii  whether to escape non-ASCII characters with


18271                             \uXXXX sequences


18272


18273    @complexity Linear in the length of string @a s.


18274    */


18275    void dump_escaped(const string_t& s, const bool ensure_ascii)


18276    {


18277        std::uint32_t codepoint{};


18278        std::uint8_t state = UTF8_ACCEPT;


18279        std::size_t bytes = 0;  // number of bytes written to string_buffer


18280


18281        // number of bytes written at the point of the last valid byte


18282        std::size_t bytes_after_last_accept = 0;


18283        std::size_t undumped_chars = 0;


18284


18285        for (std::size_t i = 0; i < s.size(); ++i)


18286        {


18287            const auto byte = static_cast<std::uint8_t>(s[i]);


18288


18289            switch (decode(state, codepoint, byte))


18290            {


18291                case UTF8_ACCEPT:  // decode found a new code point


18292                {


18293                    switch (codepoint)


18294                    {


18295                        case 0x08: // backspace


18296                        {


18297                            string_buffer[bytes++] = '\\';


18298                            string_buffer[bytes++] = 'b';


18299                            break;


18300                        }


18301


18302                        case 0x09: // horizontal tab


18303                        {


18304                            string_buffer[bytes++] = '\\';


18305                            string_buffer[bytes++] = 't';


18306                            break;


18307                        }


18308


18309                        case 0x0A: // newline


18310                        {


18311                            string_buffer[bytes++] = '\\';


18312                            string_buffer[bytes++] = 'n';


18313                            break;


18314                        }


18315


18316                        case 0x0C: // formfeed


18317                        {


18318                            string_buffer[bytes++] = '\\';


18319                            string_buffer[bytes++] = 'f';


18320                            break;


18321                        }


18322


18323                        case 0x0D: // carriage return


18324                        {


18325                            string_buffer[bytes++] = '\\';


18326                            string_buffer[bytes++] = 'r';


18327                            break;


18328                        }


18329


18330                        case 0x22: // quotation mark


18331                        {


18332                            string_buffer[bytes++] = '\\';


18333                            string_buffer[bytes++] = '\"';


18334                            break;


18335                        }


18336


18337                        case 0x5C: // reverse solidus


18338                        {


18339                            string_buffer[bytes++] = '\\';


18340                            string_buffer[bytes++] = '\\';


18341                            break;


18342                        }


18343


18344                        default:


18345                        {


18346                            // escape control characters (0x00..0x1F) or, if


18347                            // ensure_ascii parameter is used, non-ASCII characters


18348                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))


18349                            {


18350                                if (codepoint <= 0xFFFF)


18351                                {


18352                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


18353                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",


18354                                                                      static_cast<std::uint16_t>(codepoint)));


18355                                    bytes += 6;


18356                                }


18357                                else


18358                                {


18359                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


18360                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",


18361                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),


18362                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));


18363                                    bytes += 12;


18364                                }


18365                            }


18366                            else


18367                            {


18368                                // copy byte to buffer (all previous bytes


18369                                // been copied have in default case above)


18370                                string_buffer[bytes++] = s[i];


18371                            }


18372                            break;


18373                        }


18374                    }


18375


18376                    // write buffer and reset index; there must be 13 bytes


18377                    // left, as this is the maximal number of bytes to be


18378                    // written ("\uxxxx\uxxxx\0") for one code point


18379                    if (string_buffer.size() - bytes < 13)


18380                    {


18381                        o->write_characters(string_buffer.data(), bytes);


18382                        bytes = 0;


18383                    }


18384


18385                    // remember the byte position of this accept


18386                    bytes_after_last_accept = bytes;


18387                    undumped_chars = 0;


18388                    break;


18389                }


18390


18391                case UTF8_REJECT:  // decode found invalid UTF-8 byte


18392                {


18393                    switch (error_handler)


18394                    {


18395                        case error_handler_t::strict:


18396                        {


18397                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));


18398                        }


18399


18400                        case error_handler_t::ignore:


18401                        case error_handler_t::replace:


18402                        {


18403                            // in case we saw this character the first time, we


18404                            // would like to read it again, because the byte


18405                            // may be OK for itself, but just not OK for the


18406                            // previous sequence


18407                            if (undumped_chars > 0)


18408                            {


18409                                --i;


18410                            }


18411


18412                            // reset length buffer to the last accepted index;


18413                            // thus removing/ignoring the invalid characters


18414                            bytes = bytes_after_last_accept;


18415


18416                            if (error_handler == error_handler_t::replace)


18417                            {


18418                                // add a replacement character


18419                                if (ensure_ascii)


18420                                {


18421                                    string_buffer[bytes++] = '\\';


18422                                    string_buffer[bytes++] = 'u';


18423                                    string_buffer[bytes++] = 'f';


18424                                    string_buffer[bytes++] = 'f';


18425                                    string_buffer[bytes++] = 'f';


18426                                    string_buffer[bytes++] = 'd';


18427                                }


18428                                else


18429                                {


18430                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');


18431                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');


18432                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');


18433                                }


18434


18435                                // write buffer and reset index; there must be 13 bytes


18436                                // left, as this is the maximal number of bytes to be


18437                                // written ("\uxxxx\uxxxx\0") for one code point


18438                                if (string_buffer.size() - bytes < 13)


18439                                {


18440                                    o->write_characters(string_buffer.data(), bytes);


18441                                    bytes = 0;


18442                                }


18443


18444                                bytes_after_last_accept = bytes;


18445                            }


18446


18447                            undumped_chars = 0;


18448


18449                            // continue processing the string


18450                            state = UTF8_ACCEPT;


18451                            break;


18452                        }


18453


18454                        default:            // LCOV_EXCL_LINE


18455                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


18456                    }


18457                    break;


18458                }


18459


18460                default:  // decode found yet incomplete multi-byte code point


18461                {


18462                    if (!ensure_ascii)


18463                    {


18464                        // code point will not be escaped - copy byte to buffer


18465                        string_buffer[bytes++] = s[i];


18466                    }


18467                    ++undumped_chars;


18468                    break;


18469                }


18470            }


18471        }


18472


18473        // we finished processing the string


18474        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))


18475        {


18476            // write buffer


18477            if (bytes > 0)


18478            {


18479                o->write_characters(string_buffer.data(), bytes);


18480            }


18481        }


18482        else


18483        {


18484            // we finish reading, but do not accept: string was incomplete


18485            switch (error_handler)


18486            {


18487                case error_handler_t::strict:


18488                {


18489                    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));


18490                }


18491


18492                case error_handler_t::ignore:


18493                {


18494                    // write all accepted bytes


18495                    o->write_characters(string_buffer.data(), bytes_after_last_accept);


18496                    break;


18497                }


18498


18499                case error_handler_t::replace:


18500                {


18501                    // write all accepted bytes


18502                    o->write_characters(string_buffer.data(), bytes_after_last_accept);


18503                    // add a replacement character


18504                    if (ensure_ascii)


18505                    {


18506                        o->write_characters("\\ufffd", 6);


18507                    }


18508                    else


18509                    {


18510                        o->write_characters("\xEF\xBF\xBD", 3);


18511                    }


18512                    break;


18513                }


18514


18515                default:            // LCOV_EXCL_LINE


18516                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


18517            }


18518        }


18519    }


18520


18521  private:


18522    /*!


18523    @brief count digits


18524


18525    Count the number of decimal (base 10) digits for an input unsigned integer.


18526


18527    @param[in] x  unsigned integer number to count its digits


18528    @return    number of decimal digits


18529    */


18530    inline unsigned int count_digits(number_unsigned_t x) noexcept


18531    {


18532        unsigned int n_digits = 1;


18533        for (;;)


18534        {


18535            if (x < 10)


18536            {


18537                return n_digits;


18538            }


18539            if (x < 100)


18540            {


18541                return n_digits + 1;


18542            }


18543            if (x < 1000)


18544            {


18545                return n_digits + 2;


18546            }


18547            if (x < 10000)


18548            {


18549                return n_digits + 3;


18550            }


18551            x = x / 10000u;


18552            n_digits += 4;


18553        }


18554    }


18555


18556    /*!


18557     * @brief convert a byte to a uppercase hex representation


18558     * @param[in] byte byte to represent


18559     * @return representation ("00".."FF")


18560     */


18561    static std::string hex_bytes(std::uint8_t byte)


18562    {


18563        std::string result = "FF";


18564        constexpr const char* nibble_to_hex = "0123456789ABCDEF";


18565        result[0] = nibble_to_hex[byte / 16];


18566        result[1] = nibble_to_hex[byte % 16];


18567        return result;


18568    }


18569


18570    // templates to avoid warnings about useless casts


18571    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>


18572    bool is_negative_number(NumberType x)


18573    {


18574        return x < 0;


18575    }


18576


18577    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >


18578    bool is_negative_number(NumberType /*unused*/)


18579    {


18580        return false;


18581    }


18582


18583    /*!


18584    @brief dump an integer


18585


18586    Dump a given integer to output stream @a o. Works internally with


18587    @a number_buffer.


18588


18589    @param[in] x  integer number (signed or unsigned) to dump


18590    @tparam NumberType either @a number_integer_t or @a number_unsigned_t


18591    */


18592    template < typename NumberType, detail::enable_if_t <


18593                   std::is_integral<NumberType>::value ||


18594                   std::is_same<NumberType, number_unsigned_t>::value ||


18595                   std::is_same<NumberType, number_integer_t>::value ||


18596                   std::is_same<NumberType, binary_char_t>::value,


18597                   int > = 0 >


18598    void dump_integer(NumberType x)


18599    {


18600        static constexpr std::array<std::array<char, 2>, 100> digits_to_99


18601        {


18602            {


18603                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},


18604                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},


18605                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},


18606                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},


18607                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},


18608                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},


18609                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},


18610                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},


18611                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},


18612                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},


18613            }


18614        };


18615


18616        // special case for "0"


18617        if (x == 0)


18618        {


18619            o->write_character('0');


18620            return;


18621        }


18622


18623        // use a pointer to fill the buffer


18624        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)


18625


18626        number_unsigned_t abs_value;


18627


18628        unsigned int n_chars{};


18629


18630        if (is_negative_number(x))


18631        {


18632            *buffer_ptr = '-';


18633            abs_value = remove_sign(static_cast<number_integer_t>(x));


18634


18635            // account one more byte for the minus sign


18636            n_chars = 1 + count_digits(abs_value);


18637        }


18638        else


18639        {


18640            abs_value = static_cast<number_unsigned_t>(x);


18641            n_chars = count_digits(abs_value);


18642        }


18643


18644        // spare 1 byte for '\0'


18645        JSON_ASSERT(n_chars < number_buffer.size() - 1);


18646


18647        // jump to the end to generate the string from backward,


18648        // so we later avoid reversing the result


18649        buffer_ptr += n_chars;


18650


18651        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu


18652        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg


18653        while (abs_value >= 100)


18654        {


18655            const auto digits_index = static_cast<unsigned>((abs_value % 100));


18656            abs_value /= 100;


18657            *(--buffer_ptr) = digits_to_99[digits_index][1];


18658            *(--buffer_ptr) = digits_to_99[digits_index][0];


18659        }


18660


18661        if (abs_value >= 10)


18662        {


18663            const auto digits_index = static_cast<unsigned>(abs_value);


18664            *(--buffer_ptr) = digits_to_99[digits_index][1];


18665            *(--buffer_ptr) = digits_to_99[digits_index][0];


18666        }


18667        else


18668        {


18669            *(--buffer_ptr) = static_cast<char>('0' + abs_value);


18670        }


18671


18672        o->write_characters(number_buffer.data(), n_chars);


18673    }


18674


18675    /*!


18676    @brief dump a floating-point number


18677


18678    Dump a given floating-point number to output stream @a o. Works internally


18679    with @a number_buffer.


18680


18681    @param[in] x  floating-point number to dump


18682    */


18683    void dump_float(number_float_t x)


18684    {


18685        // NaN / inf


18686        if (!std::isfinite(x))


18687        {


18688            o->write_characters("null", 4);


18689            return;


18690        }


18691


18692        // If number_float_t is an IEEE-754 single or double precision number,


18693        // use the Grisu2 algorithm to produce short numbers which are


18694        // guaranteed to round-trip, using strtof and strtod, resp.


18695        //


18696        // NB: The test below works if <long double> == <double>.


18697        static constexpr bool is_ieee_single_or_double


18698            = (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) ||


18699              (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);


18700


18701        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());


18702    }


18703


18704    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)


18705    {


18706        auto* begin = number_buffer.data();


18707        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);


18708


18709        o->write_characters(begin, static_cast<size_t>(end - begin));


18710    }


18711


18712    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)


18713    {


18714        // get number of digits for a float -> text -> float round-trip


18715        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;


18716


18717        // the actual conversion


18718        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)


18719        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);


18720


18721        // negative value indicates an error


18722        JSON_ASSERT(len > 0);


18723        // check if buffer was large enough


18724        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());


18725


18726        // erase thousands separator


18727        if (thousands_sep != '\0')


18728        {


18729            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081


18730            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);


18731            std::fill(end, number_buffer.end(), '\0');


18732            JSON_ASSERT((end - number_buffer.begin()) <= len);


18733            len = (end - number_buffer.begin());


18734        }


18735


18736        // convert decimal point to '.'


18737        if (decimal_point != '\0' && decimal_point != '.')


18738        {


18739            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081


18740            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);


18741            if (dec_pos != number_buffer.end())


18742            {


18743                *dec_pos = '.';


18744            }


18745        }


18746


18747        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));


18748


18749        // determine if we need to append ".0"


18750        const bool value_is_int_like =


18751            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,


18752                         [](char c)


18753        {


18754            return c == '.' || c == 'e';


18755        });


18756


18757        if (value_is_int_like)


18758        {


18759            o->write_characters(".0", 2);


18760        }


18761    }


18762


18763    /*!


18764    @brief check whether a string is UTF-8 encoded


18765


18766    The function checks each byte of a string whether it is UTF-8 encoded. The


18767    result of the check is stored in the @a state parameter. The function must


18768    be called initially with state 0 (accept). State 1 means the string must


18769    be rejected, because the current byte is not allowed. If the string is


18770    completely processed, but the state is non-zero, the string ended


18771    prematurely; that is, the last byte indicated more bytes should have


18772    followed.


18773


18774    @param[in,out] state  the state of the decoding


18775    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)


18776    @param[in] byte       next byte to decode


18777    @return               new state


18778


18779    @note The function has been edited: a std::array is used.


18780


18781    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>


18782    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/


18783    */


18784    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept


18785    {


18786        static const std::array<std::uint8_t, 400> utf8d =


18787        {


18788            {


18789                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


18790                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


18791                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


18792                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


18793                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


18794                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


18795                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


18796                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF


18797                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF


18798                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0


18799                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


18800                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


18801                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


18802                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


18803            }


18804        };


18805


18806        JSON_ASSERT(byte < utf8d.size());


18807        const std::uint8_t type = utf8d[byte];


18808


18809        codep = (state != UTF8_ACCEPT)


18810                ? (byte & 0x3fu) | (codep << 6u)


18811                : (0xFFu >> type) & (byte);


18812


18813        std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);


18814        JSON_ASSERT(index < 400);


18815        state = utf8d[index];


18816        return state;


18817    }


18818


18819    /*


18820     * Overload to make the compiler happy while it is instantiating


18821     * dump_integer for number_unsigned_t.


18822     * Must never be called.


18823     */


18824    number_unsigned_t remove_sign(number_unsigned_t x)


18825    {


18826        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


18827        return x; // LCOV_EXCL_LINE


18828    }


18829


18830    /*


18831     * Helper function for dump_integer


18832     *


18833     * This function takes a negative signed integer and returns its absolute


18834     * value as unsigned integer. The plus/minus shuffling is necessary as we can


18835     * not directly remove the sign of an arbitrary signed integer as the


18836     * absolute values of INT_MIN and INT_MAX are usually not the same. See


18837     * #1708 for details.


18838     */


18839    inline number_unsigned_t remove_sign(number_integer_t x) noexcept


18840    {


18841        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)


18842        return static_cast<number_unsigned_t>(-(x + 1)) + 1;


18843    }


18844


18845  private:


18846    /// the output of the serializer


18847    output_adapter_t<char> o = nullptr;


18848


18849    /// a (hopefully) large enough character buffer


18850    std::array<char, 64> number_buffer{{}};


18851


18852    /// the locale


18853    const std::lconv* loc = nullptr;


18854    /// the locale's thousand separator character


18855    const char thousands_sep = '\0';


18856    /// the locale's decimal point character


18857    const char decimal_point = '\0';


18858


18859    /// string buffer


18860    std::array<char, 512> string_buffer{{}};


18861


18862    /// the indentation character


18863    const char indent_char;


18864    /// the indentation string


18865    string_t indent_string;


18866


18867    /// error_handler how to react on decoding errors


18868    const error_handler_t error_handler;


18869};


18870


18871}  // namespace detail


18872NLOHMANN_JSON_NAMESPACE_END


18873


18874// #include <nlohmann/detail/value_t.hpp>


18875


18876// #include <nlohmann/json_fwd.hpp>


18877


18878// #include <nlohmann/ordered_map.hpp>


18879//     __ _____ _____ _____


18880//  __|  |   __|     |   | |  JSON for Modern C++


18881// |  |  |__   |  |  | | | |  version 3.11.2


18882// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


18883//


18884// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


18885// SPDX-License-Identifier: MIT


18886


18887


18888


18889#include <functional> // equal_to, less


18890#include <initializer_list> // initializer_list


18891#include <iterator> // input_iterator_tag, iterator_traits


18892#include <memory> // allocator


18893#include <stdexcept> // for out_of_range


18894#include <type_traits> // enable_if, is_convertible


18895#include <utility> // pair


18896#include <vector> // vector


18897


18898// #include <nlohmann/detail/macro_scope.hpp>


18899


18900// #include <nlohmann/detail/meta/type_traits.hpp>


18901


18902


18903NLOHMANN_JSON_NAMESPACE_BEGIN


18904


18905/// ordered_map: a minimal map-like container that preserves insertion order


18906/// for use within nlohmann::basic_json<ordered_map>


18907template <class Key, class T, class IgnoredLess = std::less<Key>,


18908          class Allocator = std::allocator<std::pair<const Key, T>>>


18909                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>


18910{


18911    using key_type = Key;


18912    using mapped_type = T;


18913    using Container = std::vector<std::pair<const Key, T>, Allocator>;


18914    using iterator = typename Container::iterator;


18915    using const_iterator = typename Container::const_iterator;


18916    using size_type = typename Container::size_type;


18917    using value_type = typename Container::value_type;


18918#ifdef JSON_HAS_CPP_14


18919    using key_compare = std::equal_to<>;


18920#else


18921    using key_compare = std::equal_to<Key>;


18922#endif


18923


18924    // Explicit constructors instead of `using Container::Container`


18925    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)


18926    ordered_map() noexcept(noexcept(Container())) : Container{} {}


18927    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}


18928    template <class It>


18929    ordered_map(It first, It last, const Allocator& alloc = Allocator())


18930        : Container{first, last, alloc} {}


18931    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )


18932        : Container{init, alloc} {}


18933


18934    std::pair<iterator, bool> emplace(const key_type& key, T&& t)


18935    {


18936        for (auto it = this->begin(); it != this->end(); ++it)


18937        {


18938            if (m_compare(it->first, key))


18939            {


18940                return {it, false};


18941            }


18942        }


18943        Container::emplace_back(key, std::forward<T>(t));


18944        return {std::prev(this->end()), true};


18945    }


18946


18947    template<class KeyType, detail::enable_if_t<


18948                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


18949    std::pair<iterator, bool> emplace(KeyType && key, T && t)


18950    {


18951        for (auto it = this->begin(); it != this->end(); ++it)


18952        {


18953            if (m_compare(it->first, key))


18954            {


18955                return {it, false};


18956            }


18957        }


18958        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));


18959        return {std::prev(this->end()), true};


18960    }


18961


18962    T& operator[](const key_type& key)


18963    {


18964        return emplace(key, T{}).first->second;


18965    }


18966


18967    template<class KeyType, detail::enable_if_t<


18968                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


18969    T & operator[](KeyType && key)


18970    {


18971        return emplace(std::forward<KeyType>(key), T{}).first->second;


18972    }


18973


18974    const T& operator[](const key_type& key) const


18975    {


18976        return at(key);


18977    }


18978


18979    template<class KeyType, detail::enable_if_t<


18980                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


18981    const T & operator[](KeyType && key) const


18982    {


18983        return at(std::forward<KeyType>(key));


18984    }


18985


18986    T& at(const key_type& key)


18987    {


18988        for (auto it = this->begin(); it != this->end(); ++it)


18989        {


18990            if (m_compare(it->first, key))


18991            {


18992                return it->second;


18993            }


18994        }


18995


18996        JSON_THROW(std::out_of_range("key not found"));


18997    }


18998


18999    template<class KeyType, detail::enable_if_t<


19000                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


19001    T & at(KeyType && key)


19002    {


19003        for (auto it = this->begin(); it != this->end(); ++it)


19004        {


19005            if (m_compare(it->first, key))


19006            {


19007                return it->second;


19008            }


19009        }


19010


19011        JSON_THROW(std::out_of_range("key not found"));


19012    }


19013


19014    const T& at(const key_type& key) const


19015    {


19016        for (auto it = this->begin(); it != this->end(); ++it)


19017        {


19018            if (m_compare(it->first, key))


19019            {


19020                return it->second;


19021            }


19022        }


19023


19024        JSON_THROW(std::out_of_range("key not found"));


19025    }


19026


19027    template<class KeyType, detail::enable_if_t<


19028                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


19029    const T & at(KeyType && key) const


19030    {


19031        for (auto it = this->begin(); it != this->end(); ++it)


19032        {


19033            if (m_compare(it->first, key))


19034            {


19035                return it->second;


19036            }


19037        }


19038


19039        JSON_THROW(std::out_of_range("key not found"));


19040    }


19041


19042    size_type erase(const key_type& key)


19043    {


19044        for (auto it = this->begin(); it != this->end(); ++it)


19045        {


19046            if (m_compare(it->first, key))


19047            {


19048                // Since we cannot move const Keys, re-construct them in place


19049                for (auto next = it; ++next != this->end(); ++it)


19050                {


19051                    it->~value_type(); // Destroy but keep allocation


19052                    new (&*it) value_type{std::move(*next)};


19053                }


19054                Container::pop_back();


19055                return 1;


19056            }


19057        }


19058        return 0;


19059    }


19060


19061    template<class KeyType, detail::enable_if_t<


19062                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


19063    size_type erase(KeyType && key)


19064    {


19065        for (auto it = this->begin(); it != this->end(); ++it)


19066        {


19067            if (m_compare(it->first, key))


19068            {


19069                // Since we cannot move const Keys, re-construct them in place


19070                for (auto next = it; ++next != this->end(); ++it)


19071                {


19072                    it->~value_type(); // Destroy but keep allocation


19073                    new (&*it) value_type{std::move(*next)};


19074                }


19075                Container::pop_back();


19076                return 1;


19077            }


19078        }


19079        return 0;


19080    }


19081


19082    iterator erase(iterator pos)


19083    {


19084        return erase(pos, std::next(pos));


19085    }


19086


19087    iterator erase(iterator first, iterator last)


19088    {


19089        if (first == last)


19090        {


19091            return first;


19092        }


19093


19094        const auto elements_affected = std::distance(first, last);


19095        const auto offset = std::distance(Container::begin(), first);


19096


19097        // This is the start situation. We need to delete elements_affected


19098        // elements (3 in this example: e, f, g), and need to return an


19099        // iterator past the last deleted element (h in this example).


19100        // Note that offset is the distance from the start of the vector


19101        // to first. We will need this later.


19102


19103        // [ a, b, c, d, e, f, g, h, i, j ]


19104        //               ^        ^


19105        //             first    last


19106


19107        // Since we cannot move const Keys, we re-construct them in place.


19108        // We start at first and re-construct (viz. copy) the elements from


19109        // the back of the vector. Example for first iteration:


19110


19111        //               ,--------.


19112        //               v        |   destroy e and re-construct with h


19113        // [ a, b, c, d, e, f, g, h, i, j ]


19114        //               ^        ^


19115        //               it       it + elements_affected


19116


19117        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)


19118        {


19119            it->~value_type(); // destroy but keep allocation


19120            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it


19121        }


19122


19123        // [ a, b, c, d, h, i, j, h, i, j ]


19124        //               ^        ^


19125        //             first    last


19126


19127        // remove the unneeded elements at the end of the vector


19128        Container::resize(this->size() - static_cast<size_type>(elements_affected));


19129


19130        // [ a, b, c, d, h, i, j ]


19131        //               ^        ^


19132        //             first    last


19133


19134        // first is now pointing past the last deleted element, but we cannot


19135        // use this iterator, because it may have been invalidated by the


19136        // resize call. Instead, we can return begin() + offset.


19137        return Container::begin() + offset;


19138    }


19139


19140    size_type count(const key_type& key) const


19141    {


19142        for (auto it = this->begin(); it != this->end(); ++it)


19143        {


19144            if (m_compare(it->first, key))


19145            {


19146                return 1;


19147            }


19148        }


19149        return 0;


19150    }


19151


19152    template<class KeyType, detail::enable_if_t<


19153                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


19154    size_type count(KeyType && key) const


19155    {


19156        for (auto it = this->begin(); it != this->end(); ++it)


19157        {


19158            if (m_compare(it->first, key))


19159            {


19160                return 1;


19161            }


19162        }


19163        return 0;


19164    }


19165


19166    iterator find(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                return it;


19173            }


19174        }


19175        return Container::end();


19176    }


19177


19178    template<class KeyType, detail::enable_if_t<


19179                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>


19180    iterator find(KeyType && key)


19181    {


19182        for (auto it = this->begin(); it != this->end(); ++it)


19183        {


19184            if (m_compare(it->first, key))


19185            {


19186                return it;


19187            }


19188        }


19189        return Container::end();


19190    }


19191


19192    const_iterator find(const key_type& key) const


19193    {


19194        for (auto it = this->begin(); it != this->end(); ++it)


19195        {


19196            if (m_compare(it->first, key))


19197            {


19198                return it;


19199            }


19200        }


19201        return Container::end();


19202    }


19203


19204    std::pair<iterator, bool> insert( value_type&& value )


19205    {


19206        return emplace(value.first, std::move(value.second));


19207    }


19208


19209    std::pair<iterator, bool> insert( const value_type& value )


19210    {


19211        for (auto it = this->begin(); it != this->end(); ++it)


19212        {


19213            if (m_compare(it->first, value.first))


19214            {


19215                return {it, false};


19216            }


19217        }


19218        Container::push_back(value);


19219        return {--this->end(), true};


19220    }


19221


19222    template<typename InputIt>


19223    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,


19224            std::input_iterator_tag>::value>::type;


19225


19226    template<typename InputIt, typename = require_input_iter<InputIt>>


19227    void insert(InputIt first, InputIt last)


19228    {


19229        for (auto it = first; it != last; ++it)


19230        {


19231            insert(*it);


19232        }


19233    }


19234


19235private:


19236    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();


19237};


19238


19239NLOHMANN_JSON_NAMESPACE_END


19240


19241


19242#if defined(JSON_HAS_CPP_17)


19243    #include <any>


19244    #include <string_view>


19245#endif


19246


19247/*!


19248@brief namespace for Niels Lohmann


19249@see https://github.com/nlohmann


19250@since version 1.0.0


19251*/


19252NLOHMANN_JSON_NAMESPACE_BEGIN


19253


19254/*!


19255@brief a class to store JSON values


19256


19257@internal


19258@invariant The member variables @a m_value and @a m_type have the following


19259relationship:


19260- If `m_type == value_t::object`, then `m_value.object != nullptr`.


19261- If `m_type == value_t::array`, then `m_value.array != nullptr`.


19262- If `m_type == value_t::string`, then `m_value.string != nullptr`.


19263The invariants are checked by member function assert_invariant().


19264


19265@note ObjectType trick from https://stackoverflow.com/a/9860911


19266@endinternal


19267


19268@since version 1.0.0


19269


19270@nosubgrouping


19271*/


19272NLOHMANN_BASIC_JSON_TPL_DECLARATION


19273class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)


19274{


19275  private:


19276    template<detail::value_t> friend struct detail::external_constructor;


19277


19278    template<typename>


19279    friend class ::nlohmann::json_pointer;


19280    // can be restored when json_pointer backwards compatibility is removed


19281    // friend ::nlohmann::json_pointer<StringType>;


19282


19283    template<typename BasicJsonType, typename InputType>


19284    friend class ::nlohmann::detail::parser;


19285    friend ::nlohmann::detail::serializer<basic_json>;


19286    template<typename BasicJsonType>


19287    friend class ::nlohmann::detail::iter_impl;


19288    template<typename BasicJsonType, typename CharType>


19289    friend class ::nlohmann::detail::binary_writer;


19290    template<typename BasicJsonType, typename InputType, typename SAX>


19291    friend class ::nlohmann::detail::binary_reader;


19292    template<typename BasicJsonType>


19293    friend class ::nlohmann::detail::json_sax_dom_parser;


19294    template<typename BasicJsonType>


19295    friend class ::nlohmann::detail::json_sax_dom_callback_parser;


19296    friend class ::nlohmann::detail::exception;


19297


19298    /// workaround type for MSVC


19299    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;


19300


19301  JSON_PRIVATE_UNLESS_TESTED:


19302    // convenience aliases for types residing in namespace detail;


19303    using lexer = ::nlohmann::detail::lexer_base<basic_json>;


19304


19305    template<typename InputAdapterType>


19306    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(


19307        InputAdapterType adapter,


19308        detail::parser_callback_t<basic_json>cb = nullptr,


19309        const bool allow_exceptions = true,


19310        const bool ignore_comments = false


19311                                 )


19312    {


19313        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),


19314                std::move(cb), allow_exceptions, ignore_comments);


19315    }


19316


19317  private:


19318    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;


19319    template<typename BasicJsonType>


19320    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;


19321    template<typename BasicJsonType>


19322    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;


19323    template<typename Iterator>


19324    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;


19325    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;


19326


19327    template<typename CharType>


19328    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;


19329


19330    template<typename InputType>


19331    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;


19332    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;


19333


19334  JSON_PRIVATE_UNLESS_TESTED:


19335    using serializer = ::nlohmann::detail::serializer<basic_json>;


19336


19337  public:


19338    using value_t = detail::value_t;


19339    /// JSON Pointer, see @ref nlohmann::json_pointer


19340    using json_pointer = ::nlohmann::json_pointer<StringType>;


19341    template<typename T, typename SFINAE>


19342    using json_serializer = JSONSerializer<T, SFINAE>;


19343    /// how to treat decoding errors


19344    using error_handler_t = detail::error_handler_t;


19345    /// how to treat CBOR tags


19346    using cbor_tag_handler_t = detail::cbor_tag_handler_t;


19347    /// helper type for initializer lists of basic_json values


19348    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;


19349


19350    using input_format_t = detail::input_format_t;


19351    /// SAX interface type, see @ref nlohmann::json_sax


19352    using json_sax_t = json_sax<basic_json>;


19353


19354    ////////////////


19355    // exceptions //


19356    ////////////////


19357


19358    /// @name exceptions


19359    /// Classes to implement user-defined exceptions.


19360    /// @{


19361


19362    using exception = detail::exception;


19363    using parse_error = detail::parse_error;


19364    using invalid_iterator = detail::invalid_iterator;


19365    using type_error = detail::type_error;


19366    using out_of_range = detail::out_of_range;


19367    using other_error = detail::other_error;


19368


19369    /// @}


19370


19371


19372    /////////////////////


19373    // container types //


19374    /////////////////////


19375


19376    /// @name container types


19377    /// The canonic container types to use @ref basic_json like any other STL


19378    /// container.


19379    /// @{


19380


19381    /// the type of elements in a basic_json container


19382    using value_type = basic_json;


19383


19384    /// the type of an element reference


19385    using reference = value_type&;


19386    /// the type of an element const reference


19387    using const_reference = const value_type&;


19388


19389    /// a type to represent differences between iterators


19390    using difference_type = std::ptrdiff_t;


19391    /// a type to represent container sizes


19392    using size_type = std::size_t;


19393


19394    /// the allocator type


19395    using allocator_type = AllocatorType<basic_json>;


19396


19397    /// the type of an element pointer


19398    using pointer = typename std::allocator_traits<allocator_type>::pointer;


19399    /// the type of an element const pointer


19400    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;


19401


19402    /// an iterator for a basic_json container


19403    using iterator = iter_impl<basic_json>;


19404    /// a const iterator for a basic_json container


19405    using const_iterator = iter_impl<const basic_json>;


19406    /// a reverse iterator for a basic_json container


19407    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;


19408    /// a const reverse iterator for a basic_json container


19409    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;


19410


19411    /// @}


19412


19413


19414    /// @brief returns the allocator associated with the container


19415    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/


19416    static allocator_type get_allocator()


19417    {


19418        return allocator_type();


19419    }


19420


19421    /// @brief returns version information on the library


19422    /// @sa https://json.nlohmann.me/api/basic_json/meta/


19423    JSON_HEDLEY_WARN_UNUSED_RESULT


19424    static basic_json meta()


19425    {


19426        basic_json result;


19427


19428        result["copyright"] = "(C) 2013-2022 Niels Lohmann";


19429        result["name"] = "JSON for Modern C++";


19430        result["url"] = "https://github.com/nlohmann/json";


19431        result["version"]["string"] =


19432            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',


19433                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',


19434                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));


19435        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;


19436        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;


19437        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;


19438


19439#ifdef _WIN32


19440        result["platform"] = "win32";


19441#elif defined __linux__


19442        result["platform"] = "linux";


19443#elif defined __APPLE__


19444        result["platform"] = "apple";


19445#elif defined __unix__


19446        result["platform"] = "unix";


19447#else


19448        result["platform"] = "unknown";


19449#endif


19450


19451#if defined(__ICC) || defined(__INTEL_COMPILER)


19452        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};


19453#elif defined(__clang__)


19454        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};


19455#elif defined(__GNUC__) || defined(__GNUG__)


19456        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(


19457                    std::to_string(__GNUC__), '.',


19458                    std::to_string(__GNUC_MINOR__), '.',


19459                    std::to_string(__GNUC_PATCHLEVEL__))


19460            }


19461        };


19462#elif defined(__HP_cc) || defined(__HP_aCC)


19463        result["compiler"] = "hp"


19464#elif defined(__IBMCPP__)


19465        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};


19466#elif defined(_MSC_VER)


19467        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};


19468#elif defined(__PGI)


19469        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};


19470#elif defined(__SUNPRO_CC)


19471        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};


19472#else


19473        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};


19474#endif


19475


19476


19477#if defined(_MSVC_LANG)


19478        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);


19479#elif defined(__cplusplus)


19480        result["compiler"]["c++"] = std::to_string(__cplusplus);


19481#else


19482        result["compiler"]["c++"] = "unknown";


19483#endif


19484        return result;


19485    }


19486


19487


19488    ///////////////////////////


19489    // JSON value data types //


19490    ///////////////////////////


19491


19492    /// @name JSON value data types


19493    /// The data types to store a JSON value. These types are derived from


19494    /// the template arguments passed to class @ref basic_json.


19495    /// @{


19496


19497    /// @brief default object key comparator type


19498    /// The actual object key comparator type (@ref object_comparator_t) may be


19499    /// different.


19500    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/


19501#if defined(JSON_HAS_CPP_14)


19502    // use of transparent comparator avoids unnecessary repeated construction of temporaries


19503    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)


19504    using default_object_comparator_t = std::less<>;


19505#else


19506    using default_object_comparator_t = std::less<StringType>;


19507#endif


19508


19509    /// @brief a type for an object


19510    /// @sa https://json.nlohmann.me/api/basic_json/object_t/


19511    using object_t = ObjectType<StringType,


19512          basic_json,


19513          default_object_comparator_t,


19514          AllocatorType<std::pair<const StringType,


19515          basic_json>>>;


19516


19517    /// @brief a type for an array


19518    /// @sa https://json.nlohmann.me/api/basic_json/array_t/


19519    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;


19520


19521    /// @brief a type for a string


19522    /// @sa https://json.nlohmann.me/api/basic_json/string_t/


19523    using string_t = StringType;


19524


19525    /// @brief a type for a boolean


19526    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/


19527    using boolean_t = BooleanType;


19528


19529    /// @brief a type for a number (integer)


19530    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/


19531    using number_integer_t = NumberIntegerType;


19532


19533    /// @brief a type for a number (unsigned)


19534    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/


19535    using number_unsigned_t = NumberUnsignedType;


19536


19537    /// @brief a type for a number (floating-point)


19538    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/


19539    using number_float_t = NumberFloatType;


19540


19541    /// @brief a type for a packed binary type


19542    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/


19543    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;


19544


19545    /// @brief object key comparator type


19546    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/


19547    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;


19548


19549    /// @}


19550


19551  private:


19552


19553    /// helper for exception-safe object creation


19554    template<typename T, typename... Args>


19555    JSON_HEDLEY_RETURNS_NON_NULL


19556    static T* create(Args&& ... args)


19557    {


19558        AllocatorType<T> alloc;


19559        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;


19560


19561        auto deleter = [&](T * obj)


19562        {


19563            AllocatorTraits::deallocate(alloc, obj, 1);


19564        };


19565        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);


19566        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);


19567        JSON_ASSERT(obj != nullptr);


19568        return obj.release();


19569    }


19570


19571    ////////////////////////


19572    // JSON value storage //


19573    ////////////////////////


19574


19575  JSON_PRIVATE_UNLESS_TESTED:


19576    /*!


19577    @brief a JSON value


19578


19579    The actual storage for a JSON value of the @ref basic_json class. This


19580    union combines the different storage types for the JSON value types


19581    defined in @ref value_t.


19582


19583    JSON type | value_t type    | used type


19584    --------- | --------------- | ------------------------


19585    object    | object          | pointer to @ref object_t


19586    array     | array           | pointer to @ref array_t


19587    string    | string          | pointer to @ref string_t


19588    boolean   | boolean         | @ref boolean_t


19589    number    | number_integer  | @ref number_integer_t


19590    number    | number_unsigned | @ref number_unsigned_t


19591    number    | number_float    | @ref number_float_t


19592    binary    | binary          | pointer to @ref binary_t


19593    null      | null            | *no value is stored*


19594


19595    @note Variable-length types (objects, arrays, and strings) are stored as


19596    pointers. The size of the union should not exceed 64 bits if the default


19597    value types are used.


19598


19599    @since version 1.0.0


19600    */


19601    union json_value


19602    {


19603        /// object (stored with pointer to save storage)


19604        object_t* object;


19605        /// array (stored with pointer to save storage)


19606        array_t* array;


19607        /// string (stored with pointer to save storage)


19608        string_t* string;


19609        /// binary (stored with pointer to save storage)


19610        binary_t* binary;


19611        /// boolean


19612        boolean_t boolean;


19613        /// number (integer)


19614        number_integer_t number_integer;


19615        /// number (unsigned integer)


19616        number_unsigned_t number_unsigned;


19617        /// number (floating-point)


19618        number_float_t number_float;


19619


19620        /// default constructor (for null values)


19621        json_value() = default;


19622        /// constructor for booleans


19623        json_value(boolean_t v) noexcept : boolean(v) {}


19624        /// constructor for numbers (integer)


19625        json_value(number_integer_t v) noexcept : number_integer(v) {}


19626        /// constructor for numbers (unsigned)


19627        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}


19628        /// constructor for numbers (floating-point)


19629        json_value(number_float_t v) noexcept : number_float(v) {}


19630        /// constructor for empty values of a given type


19631        json_value(value_t t)


19632        {


19633            switch (t)


19634            {


19635                case value_t::object:


19636                {


19637                    object = create<object_t>();


19638                    break;


19639                }


19640


19641                case value_t::array:


19642                {


19643                    array = create<array_t>();


19644                    break;


19645                }


19646


19647                case value_t::string:


19648                {


19649                    string = create<string_t>("");


19650                    break;


19651                }


19652


19653                case value_t::binary:


19654                {


19655                    binary = create<binary_t>();


19656                    break;


19657                }


19658


19659                case value_t::boolean:


19660                {


19661                    boolean = static_cast<boolean_t>(false);


19662                    break;


19663                }


19664


19665                case value_t::number_integer:


19666                {


19667                    number_integer = static_cast<number_integer_t>(0);


19668                    break;


19669                }


19670


19671                case value_t::number_unsigned:


19672                {


19673                    number_unsigned = static_cast<number_unsigned_t>(0);


19674                    break;


19675                }


19676


19677                case value_t::number_float:


19678                {


19679                    number_float = static_cast<number_float_t>(0.0);


19680                    break;


19681                }


19682


19683                case value_t::null:


19684                {


19685                    object = nullptr;  // silence warning, see #821


19686                    break;


19687                }


19688


19689                case value_t::discarded:


19690                default:


19691                {


19692                    object = nullptr;  // silence warning, see #821


19693                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))


19694                    {


19695                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.2", nullptr)); // LCOV_EXCL_LINE


19696                    }


19697                    break;


19698                }


19699            }


19700        }


19701


19702        /// constructor for strings


19703        json_value(const string_t& value) : string(create<string_t>(value)) {}


19704


19705        /// constructor for rvalue strings


19706        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}


19707


19708        /// constructor for objects


19709        json_value(const object_t& value) : object(create<object_t>(value)) {}


19710


19711        /// constructor for rvalue objects


19712        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}


19713


19714        /// constructor for arrays


19715        json_value(const array_t& value) : array(create<array_t>(value)) {}


19716


19717        /// constructor for rvalue arrays


19718        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}


19719


19720        /// constructor for binary arrays


19721        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}


19722


19723        /// constructor for rvalue binary arrays


19724        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}


19725


19726        /// constructor for binary arrays (internal type)


19727        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}


19728


19729        /// constructor for rvalue binary arrays (internal type)


19730        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}


19731


19732        void destroy(value_t t)


19733        {


19734            if (t == value_t::array || t == value_t::object)


19735            {


19736                // flatten the current json_value to a heap-allocated stack


19737                std::vector<basic_json> stack;


19738


19739                // move the top-level items to stack


19740                if (t == value_t::array)


19741                {


19742                    stack.reserve(array->size());


19743                    std::move(array->begin(), array->end(), std::back_inserter(stack));


19744                }


19745                else


19746                {


19747                    stack.reserve(object->size());


19748                    for (auto&& it : *object)


19749                    {


19750                        stack.push_back(std::move(it.second));


19751                    }


19752                }


19753


19754                while (!stack.empty())


19755                {


19756                    // move the last item to local variable to be processed


19757                    basic_json current_item(std::move(stack.back()));


19758                    stack.pop_back();


19759


19760                    // if current_item is array/object, move


19761                    // its children to the stack to be processed later


19762                    if (current_item.is_array())


19763                    {


19764                        std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));


19765


19766                        current_item.m_value.array->clear();


19767                    }


19768                    else if (current_item.is_object())


19769                    {


19770                        for (auto&& it : *current_item.m_value.object)


19771                        {


19772                            stack.push_back(std::move(it.second));


19773                        }


19774


19775                        current_item.m_value.object->clear();


19776                    }


19777


19778                    // it's now safe that current_item get destructed


19779                    // since it doesn't have any children


19780                }


19781            }


19782


19783            switch (t)


19784            {


19785                case value_t::object:


19786                {


19787                    AllocatorType<object_t> alloc;


19788                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);


19789                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);


19790                    break;


19791                }


19792


19793                case value_t::array:


19794                {


19795                    AllocatorType<array_t> alloc;


19796                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);


19797                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);


19798                    break;


19799                }


19800


19801                case value_t::string:


19802                {


19803                    AllocatorType<string_t> alloc;


19804                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);


19805                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);


19806                    break;


19807                }


19808


19809                case value_t::binary:


19810                {


19811                    AllocatorType<binary_t> alloc;


19812                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);


19813                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);


19814                    break;


19815                }


19816


19817                case value_t::null:


19818                case value_t::boolean:


19819                case value_t::number_integer:


19820                case value_t::number_unsigned:


19821                case value_t::number_float:


19822                case value_t::discarded:


19823                default:


19824                {


19825                    break;


19826                }


19827            }


19828        }


19829    };


19830


19831  private:


19832    /*!


19833    @brief checks the class invariants


19834


19835    This function asserts the class invariants. It needs to be called at the


19836    end of every constructor to make sure that created objects respect the


19837    invariant. Furthermore, it has to be called each time the type of a JSON


19838    value is changed, because the invariant expresses a relationship between


19839    @a m_type and @a m_value.


19840


19841    Furthermore, the parent relation is checked for arrays and objects: If


19842    @a check_parents true and the value is an array or object, then the


19843    container's elements must have the current value as parent.


19844


19845    @param[in] check_parents  whether the parent relation should be checked.


19846               The value is true by default and should only be set to false


19847               during destruction of objects when the invariant does not


19848               need to hold.


19849    */


19850    void assert_invariant(bool check_parents = true) const noexcept


19851    {


19852        JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);


19853        JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);


19854        JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);


19855        JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);


19856


19857#if JSON_DIAGNOSTICS


19858        JSON_TRY


19859        {


19860            // cppcheck-suppress assertWithSideEffect


19861            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)


19862            {


19863                return j.m_parent == this;


19864            }));


19865        }


19866        JSON_CATCH(...) {} // LCOV_EXCL_LINE


19867#endif


19868        static_cast<void>(check_parents);


19869    }


19870


19871    void set_parents()


19872    {


19873#if JSON_DIAGNOSTICS


19874        switch (m_type)


19875        {


19876            case value_t::array:


19877            {


19878                for (auto& element : *m_value.array)


19879                {


19880                    element.m_parent = this;


19881                }


19882                break;


19883            }


19884


19885            case value_t::object:


19886            {


19887                for (auto& element : *m_value.object)


19888                {


19889                    element.second.m_parent = this;


19890                }


19891                break;


19892            }


19893


19894            case value_t::null:


19895            case value_t::string:


19896            case value_t::boolean:


19897            case value_t::number_integer:


19898            case value_t::number_unsigned:


19899            case value_t::number_float:


19900            case value_t::binary:


19901            case value_t::discarded:


19902            default:


19903                break;


19904        }


19905#endif


19906    }


19907


19908    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)


19909    {


19910#if JSON_DIAGNOSTICS


19911        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)


19912        {


19913            (it + i)->m_parent = this;


19914        }


19915#else


19916        static_cast<void>(count_set_parents);


19917#endif


19918        return it;


19919    }


19920


19921    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))


19922    {


19923#if JSON_DIAGNOSTICS


19924        if (old_capacity != static_cast<std::size_t>(-1))


19925        {


19926            // see https://github.com/nlohmann/json/issues/2838


19927            JSON_ASSERT(type() == value_t::array);


19928            if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))


19929            {


19930                // capacity has changed: update all parents


19931                set_parents();


19932                return j;


19933            }


19934        }


19935


19936        // ordered_json uses a vector internally, so pointers could have


19937        // been invalidated; see https://github.com/nlohmann/json/issues/2962


19938#ifdef JSON_HEDLEY_MSVC_VERSION


19939#pragma warning(push )


19940#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr


19941#endif


19942        if (detail::is_ordered_map<object_t>::value)


19943        {


19944            set_parents();


19945            return j;


19946        }


19947#ifdef JSON_HEDLEY_MSVC_VERSION


19948#pragma warning( pop )


19949#endif


19950


19951        j.m_parent = this;


19952#else


19953        static_cast<void>(j);


19954        static_cast<void>(old_capacity);


19955#endif


19956        return j;


19957    }


19958


19959  public:


19960    //////////////////////////


19961    // JSON parser callback //


19962    //////////////////////////


19963


19964    /// @brief parser event types


19965    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/


19966    using parse_event_t = detail::parse_event_t;


19967


19968    /// @brief per-element parser callback type


19969    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/


19970    using parser_callback_t = detail::parser_callback_t<basic_json>;


19971


19972    //////////////////


19973    // constructors //


19974    //////////////////


19975


19976    /// @name constructors and destructors


19977    /// Constructors of class @ref basic_json, copy/move constructor, copy


19978    /// assignment, static functions creating objects, and the destructor.


19979    /// @{


19980


19981    /// @brief create an empty value with a given type


19982    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


19983    basic_json(const value_t v)


19984        : m_type(v), m_value(v)


19985    {


19986        assert_invariant();


19987    }


19988


19989    /// @brief create a null object


19990    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


19991    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)


19992        : basic_json(value_t::null)


19993    {


19994        assert_invariant();


19995    }


19996


19997    /// @brief create a JSON value from compatible types


19998    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


19999    template < typename CompatibleType,


20000               typename U = detail::uncvref_t<CompatibleType>,


20001               detail::enable_if_t <


20002                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >


20003    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)


20004                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),


20005                                           std::forward<CompatibleType>(val))))


20006    {


20007        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));


20008        set_parents();


20009        assert_invariant();


20010    }


20011


20012    /// @brief create a JSON value from an existing one


20013    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


20014    template < typename BasicJsonType,


20015               detail::enable_if_t <


20016                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >


20017    basic_json(const BasicJsonType& val)


20018    {


20019        using other_boolean_t = typename BasicJsonType::boolean_t;


20020        using other_number_float_t = typename BasicJsonType::number_float_t;


20021        using other_number_integer_t = typename BasicJsonType::number_integer_t;


20022        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;


20023        using other_string_t = typename BasicJsonType::string_t;


20024        using other_object_t = typename BasicJsonType::object_t;


20025        using other_array_t = typename BasicJsonType::array_t;


20026        using other_binary_t = typename BasicJsonType::binary_t;


20027


20028        switch (val.type())


20029        {


20030            case value_t::boolean:


20031                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());


20032                break;


20033            case value_t::number_float:


20034                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());


20035                break;


20036            case value_t::number_integer:


20037                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());


20038                break;


20039            case value_t::number_unsigned:


20040                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());


20041                break;


20042            case value_t::string:


20043                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());


20044                break;


20045            case value_t::object:


20046                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());


20047                break;


20048            case value_t::array:


20049                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());


20050                break;


20051            case value_t::binary:


20052                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());


20053                break;


20054            case value_t::null:


20055                *this = nullptr;


20056                break;


20057            case value_t::discarded:


20058                m_type = value_t::discarded;


20059                break;


20060            default:            // LCOV_EXCL_LINE


20061                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


20062        }


20063        JSON_ASSERT(m_type == val.type());


20064        set_parents();


20065        assert_invariant();


20066    }


20067


20068    /// @brief create a container (array or object) from an initializer list


20069    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


20070    basic_json(initializer_list_t init,


20071               bool type_deduction = true,


20072               value_t manual_type = value_t::array)


20073    {


20074        // check if each element is an array with two elements whose first


20075        // element is a string


20076        bool is_an_object = std::all_of(init.begin(), init.end(),


20077                                        [](const detail::json_ref<basic_json>& element_ref)


20078        {


20079            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();


20080        });


20081


20082        // adjust type if type deduction is not wanted


20083        if (!type_deduction)


20084        {


20085            // if array is wanted, do not create an object though possible


20086            if (manual_type == value_t::array)


20087            {


20088                is_an_object = false;


20089            }


20090


20091            // if object is wanted but impossible, throw an exception


20092            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))


20093            {


20094                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));


20095            }


20096        }


20097


20098        if (is_an_object)


20099        {


20100            // the initializer list is a list of pairs -> create object


20101            m_type = value_t::object;


20102            m_value = value_t::object;


20103


20104            for (auto& element_ref : init)


20105            {


20106                auto element = element_ref.moved_or_copied();


20107                m_value.object->emplace(


20108                    std::move(*((*element.m_value.array)[0].m_value.string)),


20109                    std::move((*element.m_value.array)[1]));


20110            }


20111        }


20112        else


20113        {


20114            // the initializer list describes an array -> create array


20115            m_type = value_t::array;


20116            m_value.array = create<array_t>(init.begin(), init.end());


20117        }


20118


20119        set_parents();


20120        assert_invariant();


20121    }


20122


20123    /// @brief explicitly create a binary array (without subtype)


20124    /// @sa https://json.nlohmann.me/api/basic_json/binary/


20125    JSON_HEDLEY_WARN_UNUSED_RESULT


20126    static basic_json binary(const typename binary_t::container_type& init)


20127    {


20128        auto res = basic_json();


20129        res.m_type = value_t::binary;


20130        res.m_value = init;


20131        return res;


20132    }


20133


20134    /// @brief explicitly create a binary array (with subtype)


20135    /// @sa https://json.nlohmann.me/api/basic_json/binary/


20136    JSON_HEDLEY_WARN_UNUSED_RESULT


20137    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)


20138    {


20139        auto res = basic_json();


20140        res.m_type = value_t::binary;


20141        res.m_value = binary_t(init, subtype);


20142        return res;


20143    }


20144


20145    /// @brief explicitly create a binary array


20146    /// @sa https://json.nlohmann.me/api/basic_json/binary/


20147    JSON_HEDLEY_WARN_UNUSED_RESULT


20148    static basic_json binary(typename binary_t::container_type&& init)


20149    {


20150        auto res = basic_json();


20151        res.m_type = value_t::binary;


20152        res.m_value = std::move(init);


20153        return res;


20154    }


20155


20156    /// @brief explicitly create a binary array (with subtype)


20157    /// @sa https://json.nlohmann.me/api/basic_json/binary/


20158    JSON_HEDLEY_WARN_UNUSED_RESULT


20159    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)


20160    {


20161        auto res = basic_json();


20162        res.m_type = value_t::binary;


20163        res.m_value = binary_t(std::move(init), subtype);


20164        return res;


20165    }


20166


20167    /// @brief explicitly create an array from an initializer list


20168    /// @sa https://json.nlohmann.me/api/basic_json/array/


20169    JSON_HEDLEY_WARN_UNUSED_RESULT


20170    static basic_json array(initializer_list_t init = {})


20171    {


20172        return basic_json(init, false, value_t::array);


20173    }


20174


20175    /// @brief explicitly create an object from an initializer list


20176    /// @sa https://json.nlohmann.me/api/basic_json/object/


20177    JSON_HEDLEY_WARN_UNUSED_RESULT


20178    static basic_json object(initializer_list_t init = {})


20179    {


20180        return basic_json(init, false, value_t::object);


20181    }


20182


20183    /// @brief construct an array with count copies of given value


20184    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


20185    basic_json(size_type cnt, const basic_json& val)


20186        : m_type(value_t::array)


20187    {


20188        m_value.array = create<array_t>(cnt, val);


20189        set_parents();


20190        assert_invariant();


20191    }


20192


20193    /// @brief construct a JSON container given an iterator range


20194    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


20195    template < class InputIT, typename std::enable_if <


20196                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||


20197                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >


20198    basic_json(InputIT first, InputIT last)


20199    {


20200        JSON_ASSERT(first.m_object != nullptr);


20201        JSON_ASSERT(last.m_object != nullptr);


20202


20203        // make sure iterator fits the current value


20204        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))


20205        {


20206            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));


20207        }


20208


20209        // copy type from first iterator


20210        m_type = first.m_object->m_type;


20211


20212        // check if iterator range is complete for primitive values


20213        switch (m_type)


20214        {


20215            case value_t::boolean:


20216            case value_t::number_float:


20217            case value_t::number_integer:


20218            case value_t::number_unsigned:


20219            case value_t::string:


20220            {


20221                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()


20222                                         || !last.m_it.primitive_iterator.is_end()))


20223                {


20224                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));


20225                }


20226                break;


20227            }


20228


20229            case value_t::null:


20230            case value_t::object:


20231            case value_t::array:


20232            case value_t::binary:


20233            case value_t::discarded:


20234            default:


20235                break;


20236        }


20237


20238        switch (m_type)


20239        {


20240            case value_t::number_integer:


20241            {


20242                m_value.number_integer = first.m_object->m_value.number_integer;


20243                break;


20244            }


20245


20246            case value_t::number_unsigned:


20247            {


20248                m_value.number_unsigned = first.m_object->m_value.number_unsigned;


20249                break;


20250            }


20251


20252            case value_t::number_float:


20253            {


20254                m_value.number_float = first.m_object->m_value.number_float;


20255                break;


20256            }


20257


20258            case value_t::boolean:


20259            {


20260                m_value.boolean = first.m_object->m_value.boolean;


20261                break;


20262            }


20263


20264            case value_t::string:


20265            {


20266                m_value = *first.m_object->m_value.string;


20267                break;


20268            }


20269


20270            case value_t::object:


20271            {


20272                m_value.object = create<object_t>(first.m_it.object_iterator,


20273                                                  last.m_it.object_iterator);


20274                break;


20275            }


20276


20277            case value_t::array:


20278            {


20279                m_value.array = create<array_t>(first.m_it.array_iterator,


20280                                                last.m_it.array_iterator);


20281                break;


20282            }


20283


20284            case value_t::binary:


20285            {


20286                m_value = *first.m_object->m_value.binary;


20287                break;


20288            }


20289


20290            case value_t::null:


20291            case value_t::discarded:


20292            default:


20293                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));


20294        }


20295


20296        set_parents();


20297        assert_invariant();


20298    }


20299


20300


20301    ///////////////////////////////////////


20302    // other constructors and destructor //


20303    ///////////////////////////////////////


20304


20305    template<typename JsonRef,


20306             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,


20307                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >


20308    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}


20309


20310    /// @brief copy constructor


20311    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


20312    basic_json(const basic_json& other)


20313        : m_type(other.m_type)


20314    {


20315        // check of passed value is valid


20316        other.assert_invariant();


20317


20318        switch (m_type)


20319        {


20320            case value_t::object:


20321            {


20322                m_value = *other.m_value.object;


20323                break;


20324            }


20325


20326            case value_t::array:


20327            {


20328                m_value = *other.m_value.array;


20329                break;


20330            }


20331


20332            case value_t::string:


20333            {


20334                m_value = *other.m_value.string;


20335                break;


20336            }


20337


20338            case value_t::boolean:


20339            {


20340                m_value = other.m_value.boolean;


20341                break;


20342            }


20343


20344            case value_t::number_integer:


20345            {


20346                m_value = other.m_value.number_integer;


20347                break;


20348            }


20349


20350            case value_t::number_unsigned:


20351            {


20352                m_value = other.m_value.number_unsigned;


20353                break;


20354            }


20355


20356            case value_t::number_float:


20357            {


20358                m_value = other.m_value.number_float;


20359                break;


20360            }


20361


20362            case value_t::binary:


20363            {


20364                m_value = *other.m_value.binary;


20365                break;


20366            }


20367


20368            case value_t::null:


20369            case value_t::discarded:


20370            default:


20371                break;


20372        }


20373


20374        set_parents();


20375        assert_invariant();


20376    }


20377


20378    /// @brief move constructor


20379    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/


20380    basic_json(basic_json&& other) noexcept


20381        : m_type(std::move(other.m_type)),


20382          m_value(std::move(other.m_value))


20383    {


20384        // check that passed value is valid


20385        other.assert_invariant(false);


20386


20387        // invalidate payload


20388        other.m_type = value_t::null;


20389        other.m_value = {};


20390


20391        set_parents();


20392        assert_invariant();


20393    }


20394


20395    /// @brief copy assignment


20396    /// @sa https://json.nlohmann.me/api/basic_json/operator=/


20397    basic_json& operator=(basic_json other) noexcept (


20398        std::is_nothrow_move_constructible<value_t>::value&&


20399        std::is_nothrow_move_assignable<value_t>::value&&


20400        std::is_nothrow_move_constructible<json_value>::value&&


20401        std::is_nothrow_move_assignable<json_value>::value


20402    )


20403    {


20404        // check that passed value is valid


20405        other.assert_invariant();


20406


20407        using std::swap;


20408        swap(m_type, other.m_type);


20409        swap(m_value, other.m_value);


20410


20411        set_parents();


20412        assert_invariant();


20413        return *this;


20414    }


20415


20416    /// @brief destructor


20417    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/


20418    ~basic_json() noexcept


20419    {


20420        assert_invariant(false);


20421        m_value.destroy(m_type);


20422    }


20423


20424    /// @}


20425


20426  public:


20427    ///////////////////////


20428    // object inspection //


20429    ///////////////////////


20430


20431    /// @name object inspection


20432    /// Functions to inspect the type of a JSON value.


20433    /// @{


20434


20435    /// @brief serialization


20436    /// @sa https://json.nlohmann.me/api/basic_json/dump/


20437    string_t dump(const int indent = -1,


20438                  const char indent_char = ' ',


20439                  const bool ensure_ascii = false,


20440                  const error_handler_t error_handler = error_handler_t::strict) const


20441    {


20442        string_t result;


20443        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);


20444


20445        if (indent >= 0)


20446        {


20447            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));


20448        }


20449        else


20450        {


20451            s.dump(*this, false, ensure_ascii, 0);


20452        }


20453


20454        return result;


20455    }


20456


20457    /// @brief return the type of the JSON value (explicit)


20458    /// @sa https://json.nlohmann.me/api/basic_json/type/


20459    constexpr value_t type() const noexcept


20460    {


20461        return m_type;


20462    }


20463


20464    /// @brief return whether type is primitive


20465    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/


20466    constexpr bool is_primitive() const noexcept


20467    {


20468        return is_null() || is_string() || is_boolean() || is_number() || is_binary();


20469    }


20470


20471    /// @brief return whether type is structured


20472    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/


20473    constexpr bool is_structured() const noexcept


20474    {


20475        return is_array() || is_object();


20476    }


20477


20478    /// @brief return whether value is null


20479    /// @sa https://json.nlohmann.me/api/basic_json/is_null/


20480    constexpr bool is_null() const noexcept


20481    {


20482        return m_type == value_t::null;


20483    }


20484


20485    /// @brief return whether value is a boolean


20486    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/


20487    constexpr bool is_boolean() const noexcept


20488    {


20489        return m_type == value_t::boolean;


20490    }


20491


20492    /// @brief return whether value is a number


20493    /// @sa https://json.nlohmann.me/api/basic_json/is_number/


20494    constexpr bool is_number() const noexcept


20495    {


20496        return is_number_integer() || is_number_float();


20497    }


20498


20499    /// @brief return whether value is an integer number


20500    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/


20501    constexpr bool is_number_integer() const noexcept


20502    {


20503        return m_type == value_t::number_integer || m_type == value_t::number_unsigned;


20504    }


20505


20506    /// @brief return whether value is an unsigned integer number


20507    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/


20508    constexpr bool is_number_unsigned() const noexcept


20509    {


20510        return m_type == value_t::number_unsigned;


20511    }


20512


20513    /// @brief return whether value is a floating-point number


20514    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/


20515    constexpr bool is_number_float() const noexcept


20516    {


20517        return m_type == value_t::number_float;


20518    }


20519


20520    /// @brief return whether value is an object


20521    /// @sa https://json.nlohmann.me/api/basic_json/is_object/


20522    constexpr bool is_object() const noexcept


20523    {


20524        return m_type == value_t::object;


20525    }


20526


20527    /// @brief return whether value is an array


20528    /// @sa https://json.nlohmann.me/api/basic_json/is_array/


20529    constexpr bool is_array() const noexcept


20530    {


20531        return m_type == value_t::array;


20532    }


20533


20534    /// @brief return whether value is a string


20535    /// @sa https://json.nlohmann.me/api/basic_json/is_string/


20536    constexpr bool is_string() const noexcept


20537    {


20538        return m_type == value_t::string;


20539    }


20540


20541    /// @brief return whether value is a binary array


20542    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/


20543    constexpr bool is_binary() const noexcept


20544    {


20545        return m_type == value_t::binary;


20546    }


20547


20548    /// @brief return whether value is discarded


20549    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/


20550    constexpr bool is_discarded() const noexcept


20551    {


20552        return m_type == value_t::discarded;


20553    }


20554


20555    /// @brief return the type of the JSON value (implicit)


20556    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/


20557    constexpr operator value_t() const noexcept


20558    {


20559        return m_type;


20560    }


20561


20562    /// @}


20563


20564  private:


20565    //////////////////


20566    // value access //


20567    //////////////////


20568


20569    /// get a boolean (explicit)


20570    boolean_t get_impl(boolean_t* /*unused*/) const


20571    {


20572        if (JSON_HEDLEY_LIKELY(is_boolean()))


20573        {


20574            return m_value.boolean;


20575        }


20576


20577        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));


20578    }


20579


20580    /// get a pointer to the value (object)


20581    object_t* get_impl_ptr(object_t* /*unused*/) noexcept


20582    {


20583        return is_object() ? m_value.object : nullptr;


20584    }


20585


20586    /// get a pointer to the value (object)


20587    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept


20588    {


20589        return is_object() ? m_value.object : nullptr;


20590    }


20591


20592    /// get a pointer to the value (array)


20593    array_t* get_impl_ptr(array_t* /*unused*/) noexcept


20594    {


20595        return is_array() ? m_value.array : nullptr;


20596    }


20597


20598    /// get a pointer to the value (array)


20599    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept


20600    {


20601        return is_array() ? m_value.array : nullptr;


20602    }


20603


20604    /// get a pointer to the value (string)


20605    string_t* get_impl_ptr(string_t* /*unused*/) noexcept


20606    {


20607        return is_string() ? m_value.string : nullptr;


20608    }


20609


20610    /// get a pointer to the value (string)


20611    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept


20612    {


20613        return is_string() ? m_value.string : nullptr;


20614    }


20615


20616    /// get a pointer to the value (boolean)


20617    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept


20618    {


20619        return is_boolean() ? &m_value.boolean : nullptr;


20620    }


20621


20622    /// get a pointer to the value (boolean)


20623    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept


20624    {


20625        return is_boolean() ? &m_value.boolean : nullptr;


20626    }


20627


20628    /// get a pointer to the value (integer number)


20629    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept


20630    {


20631        return is_number_integer() ? &m_value.number_integer : nullptr;


20632    }


20633


20634    /// get a pointer to the value (integer number)


20635    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept


20636    {


20637        return is_number_integer() ? &m_value.number_integer : nullptr;


20638    }


20639


20640    /// get a pointer to the value (unsigned number)


20641    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept


20642    {


20643        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;


20644    }


20645


20646    /// get a pointer to the value (unsigned number)


20647    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept


20648    {


20649        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;


20650    }


20651


20652    /// get a pointer to the value (floating-point number)


20653    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept


20654    {


20655        return is_number_float() ? &m_value.number_float : nullptr;


20656    }


20657


20658    /// get a pointer to the value (floating-point number)


20659    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept


20660    {


20661        return is_number_float() ? &m_value.number_float : nullptr;


20662    }


20663


20664    /// get a pointer to the value (binary)


20665    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept


20666    {


20667        return is_binary() ? m_value.binary : nullptr;


20668    }


20669


20670    /// get a pointer to the value (binary)


20671    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept


20672    {


20673        return is_binary() ? m_value.binary : nullptr;


20674    }


20675


20676    /*!


20677    @brief helper function to implement get_ref()


20678


20679    This function helps to implement get_ref() without code duplication for


20680    const and non-const overloads


20681


20682    @tparam ThisType will be deduced as `basic_json` or `const basic_json`


20683


20684    @throw type_error.303 if ReferenceType does not match underlying value


20685    type of the current JSON


20686    */


20687    template<typename ReferenceType, typename ThisType>


20688    static ReferenceType get_ref_impl(ThisType& obj)


20689    {


20690        // delegate the call to get_ptr<>()


20691        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();


20692


20693        if (JSON_HEDLEY_LIKELY(ptr != nullptr))


20694        {


20695            return *ptr;


20696        }


20697


20698        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));


20699    }


20700


20701  public:


20702    /// @name value access


20703    /// Direct access to the stored value of a JSON value.


20704    /// @{


20705


20706    /// @brief get a pointer value (implicit)


20707    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/


20708    template<typename PointerType, typename std::enable_if<


20709                 std::is_pointer<PointerType>::value, int>::type = 0>


20710    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))


20711    {


20712        // delegate the call to get_impl_ptr<>()


20713        return get_impl_ptr(static_cast<PointerType>(nullptr));


20714    }


20715


20716    /// @brief get a pointer value (implicit)


20717    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/


20718    template < typename PointerType, typename std::enable_if <


20719                   std::is_pointer<PointerType>::value&&


20720                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >


20721    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))


20722    {


20723        // delegate the call to get_impl_ptr<>() const


20724        return get_impl_ptr(static_cast<PointerType>(nullptr));


20725    }


20726


20727  private:


20728    /*!


20729    @brief get a value (explicit)


20730


20731    Explicit type conversion between the JSON value and a compatible value


20732    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)


20733    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).


20734    The value is converted by calling the @ref json_serializer<ValueType>


20735    `from_json()` method.


20736


20737    The function is equivalent to executing


20738    @code {.cpp}


20739    ValueType ret;


20740    JSONSerializer<ValueType>::from_json(*this, ret);


20741    return ret;


20742    @endcode


20743


20744    This overloads is chosen if:


20745    - @a ValueType is not @ref basic_json,


20746    - @ref json_serializer<ValueType> has a `from_json()` method of the form


20747      `void from_json(const basic_json&, ValueType&)`, and


20748    - @ref json_serializer<ValueType> does not have a `from_json()` method of


20749      the form `ValueType from_json(const basic_json&)`


20750


20751    @tparam ValueType the returned value type


20752


20753    @return copy of the JSON value, converted to @a ValueType


20754


20755    @throw what @ref json_serializer<ValueType> `from_json()` method throws


20756


20757    @liveexample{The example below shows several conversions from JSON values


20758    to other types. There a few things to note: (1) Floating-point numbers can


20759    be converted to integers\, (2) A JSON array can be converted to a standard


20760    `std::vector<short>`\, (3) A JSON object can be converted to C++


20761    associative containers such as `std::unordered_map<std::string\,


20762    json>`.,get__ValueType_const}


20763


20764    @since version 2.1.0


20765    */


20766    template < typename ValueType,


20767               detail::enable_if_t <


20768                   detail::is_default_constructible<ValueType>::value&&


20769                   detail::has_from_json<basic_json_t, ValueType>::value,


20770                   int > = 0 >


20771    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(


20772                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))


20773    {


20774        auto ret = ValueType();


20775        JSONSerializer<ValueType>::from_json(*this, ret);


20776        return ret;


20777    }


20778


20779    /*!


20780    @brief get a value (explicit); special case


20781


20782    Explicit type conversion between the JSON value and a compatible value


20783    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)


20784    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).


20785    The value is converted by calling the @ref json_serializer<ValueType>


20786    `from_json()` method.


20787


20788    The function is equivalent to executing


20789    @code {.cpp}


20790    return JSONSerializer<ValueType>::from_json(*this);


20791    @endcode


20792


20793    This overloads is chosen if:


20794    - @a ValueType is not @ref basic_json and


20795    - @ref json_serializer<ValueType> has a `from_json()` method of the form


20796      `ValueType from_json(const basic_json&)`


20797


20798    @note If @ref json_serializer<ValueType> has both overloads of


20799    `from_json()`, this one is chosen.


20800


20801    @tparam ValueType the returned value type


20802


20803    @return copy of the JSON value, converted to @a ValueType


20804


20805    @throw what @ref json_serializer<ValueType> `from_json()` method throws


20806


20807    @since version 2.1.0


20808    */


20809    template < typename ValueType,


20810               detail::enable_if_t <


20811                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,


20812                   int > = 0 >


20813    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(


20814                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))


20815    {


20816        return JSONSerializer<ValueType>::from_json(*this);


20817    }


20818


20819    /*!


20820    @brief get special-case overload


20821


20822    This overloads converts the current @ref basic_json in a different


20823    @ref basic_json type


20824


20825    @tparam BasicJsonType == @ref basic_json


20826


20827    @return a copy of *this, converted into @a BasicJsonType


20828


20829    @complexity Depending on the implementation of the called `from_json()`


20830                method.


20831


20832    @since version 3.2.0


20833    */


20834    template < typename BasicJsonType,


20835               detail::enable_if_t <


20836                   detail::is_basic_json<BasicJsonType>::value,


20837                   int > = 0 >


20838    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const


20839    {


20840        return *this;


20841    }


20842


20843    /*!


20844    @brief get special-case overload


20845


20846    This overloads avoids a lot of template boilerplate, it can be seen as the


20847    identity method


20848


20849    @tparam BasicJsonType == @ref basic_json


20850


20851    @return a copy of *this


20852


20853    @complexity Constant.


20854


20855    @since version 2.1.0


20856    */


20857    template<typename BasicJsonType,


20858             detail::enable_if_t<


20859                 std::is_same<BasicJsonType, basic_json_t>::value,


20860                 int> = 0>


20861    basic_json get_impl(detail::priority_tag<3> /*unused*/) const


20862    {


20863        return *this;


20864    }


20865


20866    /*!


20867    @brief get a pointer value (explicit)


20868    @copydoc get()


20869    */


20870    template<typename PointerType,


20871             detail::enable_if_t<


20872                 std::is_pointer<PointerType>::value,


20873                 int> = 0>


20874    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept


20875    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())


20876    {


20877        // delegate the call to get_ptr


20878        return get_ptr<PointerType>();


20879    }


20880


20881  public:


20882    /*!


20883    @brief get a (pointer) value (explicit)


20884


20885    Performs explicit type conversion between the JSON value and a compatible value if required.


20886


20887    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.


20888    No copies are made.


20889


20890    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible


20891    from the current @ref basic_json.


20892


20893    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`


20894    method.


20895


20896    @tparam ValueTypeCV the provided value type


20897    @tparam ValueType the returned value type


20898


20899    @return copy of the JSON value, converted to @tparam ValueType if necessary


20900


20901    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required


20902


20903    @since version 2.1.0


20904    */


20905    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>


20906#if defined(JSON_HAS_CPP_14)


20907    constexpr


20908#endif


20909    auto get() const noexcept(


20910    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))


20911    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))


20912    {


20913        // we cannot static_assert on ValueTypeCV being non-const, because


20914        // there is support for get<const basic_json_t>(), which is why we


20915        // still need the uncvref


20916        static_assert(!std::is_reference<ValueTypeCV>::value,


20917                      "get() cannot be used with reference types, you might want to use get_ref()");


20918        return get_impl<ValueType>(detail::priority_tag<4> {});


20919    }


20920


20921    /*!


20922    @brief get a pointer value (explicit)


20923


20924    Explicit pointer access to the internally stored JSON value. No copies are


20925    made.


20926


20927    @warning The pointer becomes invalid if the underlying JSON object


20928    changes.


20929


20930    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref


20931    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,


20932    @ref number_unsigned_t, or @ref number_float_t.


20933


20934    @return pointer to the internally stored JSON value if the requested


20935    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise


20936


20937    @complexity Constant.


20938


20939    @liveexample{The example below shows how pointers to internal values of a


20940    JSON value can be requested. Note that no type conversions are made and a


20941    `nullptr` is returned if the value and the requested pointer type does not


20942    match.,get__PointerType}


20943


20944    @sa see @ref get_ptr() for explicit pointer-member access


20945


20946    @since version 1.0.0


20947    */


20948    template<typename PointerType, typename std::enable_if<


20949                 std::is_pointer<PointerType>::value, int>::type = 0>


20950    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())


20951    {


20952        // delegate the call to get_ptr


20953        return get_ptr<PointerType>();


20954    }


20955


20956    /// @brief get a value (explicit)


20957    /// @sa https://json.nlohmann.me/api/basic_json/get_to/


20958    template < typename ValueType,


20959               detail::enable_if_t <


20960                   !detail::is_basic_json<ValueType>::value&&


20961                   detail::has_from_json<basic_json_t, ValueType>::value,


20962                   int > = 0 >


20963    ValueType & get_to(ValueType& v) const noexcept(noexcept(


20964                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))


20965    {


20966        JSONSerializer<ValueType>::from_json(*this, v);


20967        return v;


20968    }


20969


20970    // specialization to allow calling get_to with a basic_json value


20971    // see https://github.com/nlohmann/json/issues/2175


20972    template<typename ValueType,


20973             detail::enable_if_t <


20974                 detail::is_basic_json<ValueType>::value,


20975                 int> = 0>


20976    ValueType & get_to(ValueType& v) const


20977    {


20978        v = *this;


20979        return v;


20980    }


20981


20982    template <


20983        typename T, std::size_t N,


20984        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


20985        detail::enable_if_t <


20986            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >


20987    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)


20988    noexcept(noexcept(JSONSerializer<Array>::from_json(


20989                          std::declval<const basic_json_t&>(), v)))


20990    {


20991        JSONSerializer<Array>::from_json(*this, v);


20992        return v;


20993    }


20994


20995    /// @brief get a reference value (implicit)


20996    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/


20997    template<typename ReferenceType, typename std::enable_if<


20998                 std::is_reference<ReferenceType>::value, int>::type = 0>


20999    ReferenceType get_ref()


21000    {


21001        // delegate call to get_ref_impl


21002        return get_ref_impl<ReferenceType>(*this);


21003    }


21004


21005    /// @brief get a reference value (implicit)


21006    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/


21007    template < typename ReferenceType, typename std::enable_if <


21008                   std::is_reference<ReferenceType>::value&&


21009                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >


21010    ReferenceType get_ref() const


21011    {


21012        // delegate call to get_ref_impl


21013        return get_ref_impl<ReferenceType>(*this);


21014    }


21015


21016    /*!


21017    @brief get a value (implicit)


21018


21019    Implicit type conversion between the JSON value and a compatible value.


21020    The call is realized by calling @ref get() const.


21021


21022    @tparam ValueType non-pointer type compatible to the JSON value, for


21023    instance `int` for JSON integer numbers, `bool` for JSON booleans, or


21024    `std::vector` types for JSON arrays. The character type of @ref string_t


21025    as well as an initializer list of this type is excluded to avoid


21026    ambiguities as these types implicitly convert to `std::string`.


21027


21028    @return copy of the JSON value, converted to type @a ValueType


21029


21030    @throw type_error.302 in case passed type @a ValueType is incompatible


21031    to the JSON value type (e.g., the JSON value is of type boolean, but a


21032    string is requested); see example below


21033


21034    @complexity Linear in the size of the JSON value.


21035


21036    @liveexample{The example below shows several conversions from JSON values


21037    to other types. There a few things to note: (1) Floating-point numbers can


21038    be converted to integers\, (2) A JSON array can be converted to a standard


21039    `std::vector<short>`\, (3) A JSON object can be converted to C++


21040    associative containers such as `std::unordered_map<std::string\,


21041    json>`.,operator__ValueType}


21042


21043    @since version 1.0.0


21044    */


21045    template < typename ValueType, typename std::enable_if <


21046                   detail::conjunction <


21047                       detail::negation<std::is_pointer<ValueType>>,


21048                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,


21049                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,


21050                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,


21051                                        detail::negation<detail::is_basic_json<ValueType>>,


21052                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,


21053#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))


21054                                                detail::negation<std::is_same<ValueType, std::string_view>>,


21055#endif


21056#if defined(JSON_HAS_CPP_17)


21057                                                detail::negation<std::is_same<ValueType, std::any>>,


21058#endif


21059                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>


21060                                                >::value, int >::type = 0 >


21061                                        JSON_EXPLICIT operator ValueType() const


21062    {


21063        // delegate the call to get<>() const


21064        return get<ValueType>();


21065    }


21066


21067    /// @brief get a binary value


21068    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/


21069    binary_t& get_binary()


21070    {


21071        if (!is_binary())


21072        {


21073            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));


21074        }


21075


21076        return *get_ptr<binary_t*>();


21077    }


21078


21079    /// @brief get a binary value


21080    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/


21081    const binary_t& get_binary() const


21082    {


21083        if (!is_binary())


21084        {


21085            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));


21086        }


21087


21088        return *get_ptr<const binary_t*>();


21089    }


21090


21091    /// @}


21092


21093


21094    ////////////////////


21095    // element access //


21096    ////////////////////


21097


21098    /// @name element access


21099    /// Access to the JSON value.


21100    /// @{


21101


21102    /// @brief access specified array element with bounds checking


21103    /// @sa https://json.nlohmann.me/api/basic_json/at/


21104    reference at(size_type idx)


21105    {


21106        // at only works for arrays


21107        if (JSON_HEDLEY_LIKELY(is_array()))


21108        {


21109            JSON_TRY


21110            {


21111                return set_parent(m_value.array->at(idx));


21112            }


21113            JSON_CATCH (std::out_of_range&)


21114            {


21115                // create better exception explanation


21116                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));


21117            }


21118        }


21119        else


21120        {


21121            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));


21122        }


21123    }


21124


21125    /// @brief access specified array element with bounds checking


21126    /// @sa https://json.nlohmann.me/api/basic_json/at/


21127    const_reference at(size_type idx) const


21128    {


21129        // at only works for arrays


21130        if (JSON_HEDLEY_LIKELY(is_array()))


21131        {


21132            JSON_TRY


21133            {


21134                return m_value.array->at(idx);


21135            }


21136            JSON_CATCH (std::out_of_range&)


21137            {


21138                // create better exception explanation


21139                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));


21140            }


21141        }


21142        else


21143        {


21144            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));


21145        }


21146    }


21147


21148    /// @brief access specified object element with bounds checking


21149    /// @sa https://json.nlohmann.me/api/basic_json/at/


21150    reference at(const typename object_t::key_type& key)


21151    {


21152        // at only works for objects


21153        if (JSON_HEDLEY_UNLIKELY(!is_object()))


21154        {


21155            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));


21156        }


21157


21158        auto it = m_value.object->find(key);


21159        if (it == m_value.object->end())


21160        {


21161            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));


21162        }


21163        return set_parent(it->second);


21164    }


21165


21166    /// @brief access specified object element with bounds checking


21167    /// @sa https://json.nlohmann.me/api/basic_json/at/


21168    template<class KeyType, detail::enable_if_t<


21169                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21170    reference at(KeyType && key)


21171    {


21172        // at only works for objects


21173        if (JSON_HEDLEY_UNLIKELY(!is_object()))


21174        {


21175            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));


21176        }


21177


21178        auto it = m_value.object->find(std::forward<KeyType>(key));


21179        if (it == m_value.object->end())


21180        {


21181            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));


21182        }


21183        return set_parent(it->second);


21184    }


21185


21186    /// @brief access specified object element with bounds checking


21187    /// @sa https://json.nlohmann.me/api/basic_json/at/


21188    const_reference at(const typename object_t::key_type& key) const


21189    {


21190        // at only works for objects


21191        if (JSON_HEDLEY_UNLIKELY(!is_object()))


21192        {


21193            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));


21194        }


21195


21196        auto it = m_value.object->find(key);


21197        if (it == m_value.object->end())


21198        {


21199            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));


21200        }


21201        return it->second;


21202    }


21203


21204    /// @brief access specified object element with bounds checking


21205    /// @sa https://json.nlohmann.me/api/basic_json/at/


21206    template<class KeyType, detail::enable_if_t<


21207                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21208    const_reference at(KeyType && key) const


21209    {


21210        // at only works for objects


21211        if (JSON_HEDLEY_UNLIKELY(!is_object()))


21212        {


21213            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));


21214        }


21215


21216        auto it = m_value.object->find(std::forward<KeyType>(key));


21217        if (it == m_value.object->end())


21218        {


21219            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));


21220        }


21221        return it->second;


21222    }


21223


21224    /// @brief access specified array element


21225    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


21226    reference operator[](size_type idx)


21227    {


21228        // implicitly convert null value to an empty array


21229        if (is_null())


21230        {


21231            m_type = value_t::array;


21232            m_value.array = create<array_t>();


21233            assert_invariant();


21234        }


21235


21236        // operator[] only works for arrays


21237        if (JSON_HEDLEY_LIKELY(is_array()))


21238        {


21239            // fill up array with null values if given idx is outside range


21240            if (idx >= m_value.array->size())


21241            {


21242#if JSON_DIAGNOSTICS


21243                // remember array size & capacity before resizing


21244                const auto old_size = m_value.array->size();


21245                const auto old_capacity = m_value.array->capacity();


21246#endif


21247                m_value.array->resize(idx + 1);


21248


21249#if JSON_DIAGNOSTICS


21250                if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))


21251                {


21252                    // capacity has changed: update all parents


21253                    set_parents();


21254                }


21255                else


21256                {


21257                    // set parent for values added above


21258                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));


21259                }


21260#endif


21261                assert_invariant();


21262            }


21263


21264            return m_value.array->operator[](idx);


21265        }


21266


21267        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));


21268    }


21269


21270    /// @brief access specified array element


21271    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


21272    const_reference operator[](size_type idx) const


21273    {


21274        // const operator[] only works for arrays


21275        if (JSON_HEDLEY_LIKELY(is_array()))


21276        {


21277            return m_value.array->operator[](idx);


21278        }


21279


21280        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));


21281    }


21282


21283    /// @brief access specified object element


21284    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


21285    reference operator[](typename object_t::key_type key)


21286    {


21287        // implicitly convert null value to an empty object


21288        if (is_null())


21289        {


21290            m_type = value_t::object;


21291            m_value.object = create<object_t>();


21292            assert_invariant();


21293        }


21294


21295        // operator[] only works for objects


21296        if (JSON_HEDLEY_LIKELY(is_object()))


21297        {


21298            auto result = m_value.object->emplace(std::move(key), nullptr);


21299            return set_parent(result.first->second);


21300        }


21301


21302        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));


21303    }


21304


21305    /// @brief access specified object element


21306    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


21307    const_reference operator[](const typename object_t::key_type& key) const


21308    {


21309        // const operator[] only works for objects


21310        if (JSON_HEDLEY_LIKELY(is_object()))


21311        {


21312            auto it = m_value.object->find(key);


21313            JSON_ASSERT(it != m_value.object->end());


21314            return it->second;


21315        }


21316


21317        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));


21318    }


21319


21320    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC


21321    // (they seemingly cannot be constrained to resolve the ambiguity)


21322    template<typename T>


21323    reference operator[](T* key)


21324    {


21325        return operator[](typename object_t::key_type(key));


21326    }


21327


21328    template<typename T>


21329    const_reference operator[](T* key) const


21330    {


21331        return operator[](typename object_t::key_type(key));


21332    }


21333


21334    /// @brief access specified object element


21335    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


21336    template<class KeyType, detail::enable_if_t<


21337                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >


21338    reference operator[](KeyType && key)


21339    {


21340        // implicitly convert null value to an empty object


21341        if (is_null())


21342        {


21343            m_type = value_t::object;


21344            m_value.object = create<object_t>();


21345            assert_invariant();


21346        }


21347


21348        // operator[] only works for objects


21349        if (JSON_HEDLEY_LIKELY(is_object()))


21350        {


21351            auto result = m_value.object->emplace(std::forward<KeyType>(key), nullptr);


21352            return set_parent(result.first->second);


21353        }


21354


21355        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));


21356    }


21357


21358    /// @brief access specified object element


21359    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


21360    template<class KeyType, detail::enable_if_t<


21361                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >


21362    const_reference operator[](KeyType && key) const


21363    {


21364        // const operator[] only works for objects


21365        if (JSON_HEDLEY_LIKELY(is_object()))


21366        {


21367            auto it = m_value.object->find(std::forward<KeyType>(key));


21368            JSON_ASSERT(it != m_value.object->end());


21369            return it->second;


21370        }


21371


21372        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));


21373    }


21374


21375  private:


21376    template<typename KeyType>


21377    using is_comparable_with_object_key = detail::is_comparable <


21378        object_comparator_t, const typename object_t::key_type&, KeyType >;


21379


21380    template<typename ValueType>


21381    using value_return_type = std::conditional <


21382        detail::is_c_string_uncvref<ValueType>::value,


21383        string_t, typename std::decay<ValueType>::type >;


21384


21385  public:


21386    /// @brief access specified object element with default value


21387    /// @sa https://json.nlohmann.me/api/basic_json/value/


21388    template < class ValueType, detail::enable_if_t <


21389                   !detail::is_transparent<object_comparator_t>::value


21390                   && detail::is_getable<basic_json_t, ValueType>::value


21391                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21392    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const


21393    {


21394        // value only works for objects


21395        if (JSON_HEDLEY_LIKELY(is_object()))


21396        {


21397            // if key is found, return value and given default value otherwise


21398            const auto it = find(key);


21399            if (it != end())


21400            {


21401                return it->template get<ValueType>();


21402            }


21403


21404            return default_value;


21405        }


21406


21407        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));


21408    }


21409


21410    /// @brief access specified object element with default value


21411    /// @sa https://json.nlohmann.me/api/basic_json/value/


21412    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,


21413               detail::enable_if_t <


21414                   !detail::is_transparent<object_comparator_t>::value


21415                   && detail::is_getable<basic_json_t, ReturnType>::value


21416                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21417    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const


21418    {


21419        // value only works for objects


21420        if (JSON_HEDLEY_LIKELY(is_object()))


21421        {


21422            // if key is found, return value and given default value otherwise


21423            const auto it = find(key);


21424            if (it != end())


21425            {


21426                return it->template get<ReturnType>();


21427            }


21428


21429            return std::forward<ValueType>(default_value);


21430        }


21431


21432        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));


21433    }


21434


21435    /// @brief access specified object element with default value


21436    /// @sa https://json.nlohmann.me/api/basic_json/value/


21437    template < class ValueType, class KeyType, detail::enable_if_t <


21438                   detail::is_transparent<object_comparator_t>::value


21439                   && !detail::is_json_pointer<KeyType>::value


21440                   && is_comparable_with_object_key<KeyType>::value


21441                   && detail::is_getable<basic_json_t, ValueType>::value


21442                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21443    ValueType value(KeyType && key, const ValueType& default_value) const


21444    {


21445        // value only works for objects


21446        if (JSON_HEDLEY_LIKELY(is_object()))


21447        {


21448            // if key is found, return value and given default value otherwise


21449            const auto it = find(std::forward<KeyType>(key));


21450            if (it != end())


21451            {


21452                return it->template get<ValueType>();


21453            }


21454


21455            return default_value;


21456        }


21457


21458        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));


21459    }


21460


21461    /// @brief access specified object element via JSON Pointer with default value


21462    /// @sa https://json.nlohmann.me/api/basic_json/value/


21463    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,


21464               detail::enable_if_t <


21465                   detail::is_transparent<object_comparator_t>::value


21466                   && !detail::is_json_pointer<KeyType>::value


21467                   && is_comparable_with_object_key<KeyType>::value


21468                   && detail::is_getable<basic_json_t, ReturnType>::value


21469                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21470    ReturnType value(KeyType && key, ValueType && default_value) const


21471    {


21472        // value only works for objects


21473        if (JSON_HEDLEY_LIKELY(is_object()))


21474        {


21475            // if key is found, return value and given default value otherwise


21476            const auto it = find(std::forward<KeyType>(key));


21477            if (it != end())


21478            {


21479                return it->template get<ReturnType>();


21480            }


21481


21482            return std::forward<ValueType>(default_value);


21483        }


21484


21485        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));


21486    }


21487


21488    /// @brief access specified object element via JSON Pointer with default value


21489    /// @sa https://json.nlohmann.me/api/basic_json/value/


21490    template < class ValueType, detail::enable_if_t <


21491                   detail::is_getable<basic_json_t, ValueType>::value


21492                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21493    ValueType value(const json_pointer& ptr, const ValueType& default_value) const


21494    {


21495        // value only works for objects


21496        if (JSON_HEDLEY_LIKELY(is_object()))


21497        {


21498            // if pointer resolves a value, return it or use default value


21499            JSON_TRY


21500            {


21501                return ptr.get_checked(this).template get<ValueType>();


21502            }


21503            JSON_INTERNAL_CATCH (out_of_range&)


21504            {


21505                return default_value;


21506            }


21507        }


21508


21509        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));


21510    }


21511


21512    /// @brief access specified object element via JSON Pointer with default value


21513    /// @sa https://json.nlohmann.me/api/basic_json/value/


21514    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,


21515               detail::enable_if_t <


21516                   detail::is_getable<basic_json_t, ReturnType>::value


21517                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21518    ReturnType value(const json_pointer& ptr, ValueType && default_value) const


21519    {


21520        // value only works for objects


21521        if (JSON_HEDLEY_LIKELY(is_object()))


21522        {


21523            // if pointer resolves a value, return it or use default value


21524            JSON_TRY


21525            {


21526                return ptr.get_checked(this).template get<ReturnType>();


21527            }


21528            JSON_INTERNAL_CATCH (out_of_range&)


21529            {


21530                return std::forward<ValueType>(default_value);


21531            }


21532        }


21533


21534        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));


21535    }


21536


21537    template < class ValueType, class BasicJsonType, detail::enable_if_t <


21538                   detail::is_basic_json<BasicJsonType>::value


21539                   && detail::is_getable<basic_json_t, ValueType>::value


21540                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21541    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


21542    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const


21543    {


21544        return value(ptr.convert(), default_value);


21545    }


21546


21547    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,


21548               detail::enable_if_t <


21549                   detail::is_basic_json<BasicJsonType>::value


21550                   && detail::is_getable<basic_json_t, ReturnType>::value


21551                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >


21552    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


21553    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const


21554    {


21555        return value(ptr.convert(), std::forward<ValueType>(default_value));


21556    }


21557


21558    /// @brief access the first element


21559    /// @sa https://json.nlohmann.me/api/basic_json/front/


21560    reference front()


21561    {


21562        return *begin();


21563    }


21564


21565    /// @brief access the first element


21566    /// @sa https://json.nlohmann.me/api/basic_json/front/


21567    const_reference front() const


21568    {


21569        return *cbegin();


21570    }


21571


21572    /// @brief access the last element


21573    /// @sa https://json.nlohmann.me/api/basic_json/back/


21574    reference back()


21575    {


21576        auto tmp = end();


21577        --tmp;


21578        return *tmp;


21579    }


21580


21581    /// @brief access the last element


21582    /// @sa https://json.nlohmann.me/api/basic_json/back/


21583    const_reference back() const


21584    {


21585        auto tmp = cend();


21586        --tmp;


21587        return *tmp;


21588    }


21589


21590    /// @brief remove element given an iterator


21591    /// @sa https://json.nlohmann.me/api/basic_json/erase/


21592    template < class IteratorType, detail::enable_if_t <


21593                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||


21594                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >


21595    IteratorType erase(IteratorType pos)


21596    {


21597        // make sure iterator fits the current value


21598        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))


21599        {


21600            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));


21601        }


21602


21603        IteratorType result = end();


21604


21605        switch (m_type)


21606        {


21607            case value_t::boolean:


21608            case value_t::number_float:


21609            case value_t::number_integer:


21610            case value_t::number_unsigned:


21611            case value_t::string:


21612            case value_t::binary:


21613            {


21614                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))


21615                {


21616                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));


21617                }


21618


21619                if (is_string())


21620                {


21621                    AllocatorType<string_t> alloc;


21622                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);


21623                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);


21624                    m_value.string = nullptr;


21625                }


21626                else if (is_binary())


21627                {


21628                    AllocatorType<binary_t> alloc;


21629                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);


21630                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);


21631                    m_value.binary = nullptr;


21632                }


21633


21634                m_type = value_t::null;


21635                assert_invariant();


21636                break;


21637            }


21638


21639            case value_t::object:


21640            {


21641                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);


21642                break;


21643            }


21644


21645            case value_t::array:


21646            {


21647                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);


21648                break;


21649            }


21650


21651            case value_t::null:


21652            case value_t::discarded:


21653            default:


21654                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));


21655        }


21656


21657        return result;


21658    }


21659


21660    /// @brief remove elements given an iterator range


21661    /// @sa https://json.nlohmann.me/api/basic_json/erase/


21662    template < class IteratorType, detail::enable_if_t <


21663                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||


21664                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >


21665    IteratorType erase(IteratorType first, IteratorType last)


21666    {


21667        // make sure iterator fits the current value


21668        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))


21669        {


21670            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));


21671        }


21672


21673        IteratorType result = end();


21674


21675        switch (m_type)


21676        {


21677            case value_t::boolean:


21678            case value_t::number_float:


21679            case value_t::number_integer:


21680            case value_t::number_unsigned:


21681            case value_t::string:


21682            case value_t::binary:


21683            {


21684                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()


21685                                       || !last.m_it.primitive_iterator.is_end()))


21686                {


21687                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));


21688                }


21689


21690                if (is_string())


21691                {


21692                    AllocatorType<string_t> alloc;


21693                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);


21694                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);


21695                    m_value.string = nullptr;


21696                }


21697                else if (is_binary())


21698                {


21699                    AllocatorType<binary_t> alloc;


21700                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);


21701                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);


21702                    m_value.binary = nullptr;


21703                }


21704


21705                m_type = value_t::null;


21706                assert_invariant();


21707                break;


21708            }


21709


21710            case value_t::object:


21711            {


21712                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,


21713                                              last.m_it.object_iterator);


21714                break;


21715            }


21716


21717            case value_t::array:


21718            {


21719                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,


21720                                             last.m_it.array_iterator);


21721                break;


21722            }


21723


21724            case value_t::null:


21725            case value_t::discarded:


21726            default:


21727                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));


21728        }


21729


21730        return result;


21731    }


21732


21733  private:


21734    template < typename KeyType, detail::enable_if_t <


21735                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >


21736    size_type erase_internal(KeyType && key)


21737    {


21738        // this erase only works for objects


21739        if (JSON_HEDLEY_UNLIKELY(!is_object()))


21740        {


21741            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));


21742        }


21743


21744        return m_value.object->erase(std::forward<KeyType>(key));


21745    }


21746


21747    template < typename KeyType, detail::enable_if_t <


21748                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >


21749    size_type erase_internal(KeyType && key)


21750    {


21751        // this erase only works for objects


21752        if (JSON_HEDLEY_UNLIKELY(!is_object()))


21753        {


21754            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));


21755        }


21756


21757        const auto it = m_value.object->find(std::forward<KeyType>(key));


21758        if (it != m_value.object->end())


21759        {


21760            m_value.object->erase(it);


21761            return 1;


21762        }


21763        return 0;


21764    }


21765


21766  public:


21767


21768    /// @brief remove element from a JSON object given a key


21769    /// @sa https://json.nlohmann.me/api/basic_json/erase/


21770    size_type erase(const typename object_t::key_type& key)


21771    {


21772        // the indirection via erase_internal() is added to avoid making this


21773        // function a template and thus de-rank it during overload resolution


21774        return erase_internal(key);


21775    }


21776


21777    /// @brief remove element from a JSON object given a key


21778    /// @sa https://json.nlohmann.me/api/basic_json/erase/


21779    template<class KeyType, detail::enable_if_t<


21780                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21781    size_type erase(KeyType && key)


21782    {


21783        return erase_internal(std::forward<KeyType>(key));


21784    }


21785


21786    /// @brief remove element from a JSON array given an index


21787    /// @sa https://json.nlohmann.me/api/basic_json/erase/


21788    void erase(const size_type idx)


21789    {


21790        // this erase only works for arrays


21791        if (JSON_HEDLEY_LIKELY(is_array()))


21792        {


21793            if (JSON_HEDLEY_UNLIKELY(idx >= size()))


21794            {


21795                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));


21796            }


21797


21798            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));


21799        }


21800        else


21801        {


21802            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));


21803        }


21804    }


21805


21806    /// @}


21807


21808


21809    ////////////


21810    // lookup //


21811    ////////////


21812


21813    /// @name lookup


21814    /// @{


21815


21816    /// @brief find an element in a JSON object


21817    /// @sa https://json.nlohmann.me/api/basic_json/find/


21818    iterator find(const typename object_t::key_type& key)


21819    {


21820        auto result = end();


21821


21822        if (is_object())


21823        {


21824            result.m_it.object_iterator = m_value.object->find(key);


21825        }


21826


21827        return result;


21828    }


21829


21830    /// @brief find an element in a JSON object


21831    /// @sa https://json.nlohmann.me/api/basic_json/find/


21832    const_iterator find(const typename object_t::key_type& key) const


21833    {


21834        auto result = cend();


21835


21836        if (is_object())


21837        {


21838            result.m_it.object_iterator = m_value.object->find(key);


21839        }


21840


21841        return result;


21842    }


21843


21844    /// @brief find an element in a JSON object


21845    /// @sa https://json.nlohmann.me/api/basic_json/find/


21846    template<class KeyType, detail::enable_if_t<


21847                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21848    iterator find(KeyType && key)


21849    {


21850        auto result = end();


21851


21852        if (is_object())


21853        {


21854            result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));


21855        }


21856


21857        return result;


21858    }


21859


21860    /// @brief find an element in a JSON object


21861    /// @sa https://json.nlohmann.me/api/basic_json/find/


21862    template<class KeyType, detail::enable_if_t<


21863                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21864    const_iterator find(KeyType && key) const


21865    {


21866        auto result = cend();


21867


21868        if (is_object())


21869        {


21870            result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));


21871        }


21872


21873        return result;


21874    }


21875


21876    /// @brief returns the number of occurrences of a key in a JSON object


21877    /// @sa https://json.nlohmann.me/api/basic_json/count/


21878    size_type count(const typename object_t::key_type& key) const


21879    {


21880        // return 0 for all nonobject types


21881        return is_object() ? m_value.object->count(key) : 0;


21882    }


21883


21884    /// @brief returns the number of occurrences of a key in a JSON object


21885    /// @sa https://json.nlohmann.me/api/basic_json/count/


21886    template<class KeyType, detail::enable_if_t<


21887                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21888    size_type count(KeyType && key) const


21889    {


21890        // return 0 for all nonobject types


21891        return is_object() ? m_value.object->count(std::forward<KeyType>(key)) : 0;


21892    }


21893


21894    /// @brief check the existence of an element in a JSON object


21895    /// @sa https://json.nlohmann.me/api/basic_json/contains/


21896    bool contains(const typename object_t::key_type& key) const


21897    {


21898        return is_object() && m_value.object->find(key) != m_value.object->end();


21899    }


21900


21901    /// @brief check the existence of an element in a JSON object


21902    /// @sa https://json.nlohmann.me/api/basic_json/contains/


21903    template<class KeyType, detail::enable_if_t<


21904                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>


21905    bool contains(KeyType && key) const


21906    {


21907        return is_object() && m_value.object->find(std::forward<KeyType>(key)) != m_value.object->end();


21908    }


21909


21910    /// @brief check the existence of an element in a JSON object given a JSON pointer


21911    /// @sa https://json.nlohmann.me/api/basic_json/contains/


21912    bool contains(const json_pointer& ptr) const


21913    {


21914        return ptr.contains(this);


21915    }


21916


21917    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>


21918    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


21919    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const


21920    {


21921        return ptr.contains(this);


21922    }


21923


21924    /// @}


21925


21926


21927    ///////////////


21928    // iterators //


21929    ///////////////


21930


21931    /// @name iterators


21932    /// @{


21933


21934    /// @brief returns an iterator to the first element


21935    /// @sa https://json.nlohmann.me/api/basic_json/begin/


21936    iterator begin() noexcept


21937    {


21938        iterator result(this);


21939        result.set_begin();


21940        return result;


21941    }


21942


21943    /// @brief returns an iterator to the first element


21944    /// @sa https://json.nlohmann.me/api/basic_json/begin/


21945    const_iterator begin() const noexcept


21946    {


21947        return cbegin();


21948    }


21949


21950    /// @brief returns a const iterator to the first element


21951    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/


21952    const_iterator cbegin() const noexcept


21953    {


21954        const_iterator result(this);


21955        result.set_begin();


21956        return result;


21957    }


21958


21959    /// @brief returns an iterator to one past the last element


21960    /// @sa https://json.nlohmann.me/api/basic_json/end/


21961    iterator end() noexcept


21962    {


21963        iterator result(this);


21964        result.set_end();


21965        return result;


21966    }


21967


21968    /// @brief returns an iterator to one past the last element


21969    /// @sa https://json.nlohmann.me/api/basic_json/end/


21970    const_iterator end() const noexcept


21971    {


21972        return cend();


21973    }


21974


21975    /// @brief returns an iterator to one past the last element


21976    /// @sa https://json.nlohmann.me/api/basic_json/cend/


21977    const_iterator cend() const noexcept


21978    {


21979        const_iterator result(this);


21980        result.set_end();


21981        return result;


21982    }


21983


21984    /// @brief returns an iterator to the reverse-beginning


21985    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/


21986    reverse_iterator rbegin() noexcept


21987    {


21988        return reverse_iterator(end());


21989    }


21990


21991    /// @brief returns an iterator to the reverse-beginning


21992    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/


21993    const_reverse_iterator rbegin() const noexcept


21994    {


21995        return crbegin();


21996    }


21997


21998    /// @brief returns an iterator to the reverse-end


21999    /// @sa https://json.nlohmann.me/api/basic_json/rend/


22000    reverse_iterator rend() noexcept


22001    {


22002        return reverse_iterator(begin());


22003    }


22004


22005    /// @brief returns an iterator to the reverse-end


22006    /// @sa https://json.nlohmann.me/api/basic_json/rend/


22007    const_reverse_iterator rend() const noexcept


22008    {


22009        return crend();


22010    }


22011


22012    /// @brief returns a const reverse iterator to the last element


22013    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/


22014    const_reverse_iterator crbegin() const noexcept


22015    {


22016        return const_reverse_iterator(cend());


22017    }


22018


22019    /// @brief returns a const reverse iterator to one before the first


22020    /// @sa https://json.nlohmann.me/api/basic_json/crend/


22021    const_reverse_iterator crend() const noexcept


22022    {


22023        return const_reverse_iterator(cbegin());


22024    }


22025


22026  public:


22027    /// @brief wrapper to access iterator member functions in range-based for


22028    /// @sa https://json.nlohmann.me/api/basic_json/items/


22029    /// @deprecated This function is deprecated since 3.1.0 and will be removed in


22030    ///             version 4.0.0 of the library. Please use @ref items() instead;


22031    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.


22032    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())


22033    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept


22034    {


22035        return ref.items();


22036    }


22037


22038    /// @brief wrapper to access iterator member functions in range-based for


22039    /// @sa https://json.nlohmann.me/api/basic_json/items/


22040    /// @deprecated This function is deprecated since 3.1.0 and will be removed in


22041    ///         version 4.0.0 of the library. Please use @ref items() instead;


22042    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.


22043    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())


22044    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept


22045    {


22046        return ref.items();


22047    }


22048


22049    /// @brief helper to access iterator member functions in range-based for


22050    /// @sa https://json.nlohmann.me/api/basic_json/items/


22051    iteration_proxy<iterator> items() noexcept


22052    {


22053        return iteration_proxy<iterator>(*this);


22054    }


22055


22056    /// @brief helper to access iterator member functions in range-based for


22057    /// @sa https://json.nlohmann.me/api/basic_json/items/


22058    iteration_proxy<const_iterator> items() const noexcept


22059    {


22060        return iteration_proxy<const_iterator>(*this);


22061    }


22062


22063    /// @}


22064


22065


22066    //////////////


22067    // capacity //


22068    //////////////


22069


22070    /// @name capacity


22071    /// @{


22072


22073    /// @brief checks whether the container is empty.


22074    /// @sa https://json.nlohmann.me/api/basic_json/empty/


22075    bool empty() const noexcept


22076    {


22077        switch (m_type)


22078        {


22079            case value_t::null:


22080            {


22081                // null values are empty


22082                return true;


22083            }


22084


22085            case value_t::array:


22086            {


22087                // delegate call to array_t::empty()


22088                return m_value.array->empty();


22089            }


22090


22091            case value_t::object:


22092            {


22093                // delegate call to object_t::empty()


22094                return m_value.object->empty();


22095            }


22096


22097            case value_t::string:


22098            case value_t::boolean:


22099            case value_t::number_integer:


22100            case value_t::number_unsigned:


22101            case value_t::number_float:


22102            case value_t::binary:


22103            case value_t::discarded:


22104            default:


22105            {


22106                // all other types are nonempty


22107                return false;


22108            }


22109        }


22110    }


22111


22112    /// @brief returns the number of elements


22113    /// @sa https://json.nlohmann.me/api/basic_json/size/


22114    size_type size() const noexcept


22115    {


22116        switch (m_type)


22117        {


22118            case value_t::null:


22119            {


22120                // null values are empty


22121                return 0;


22122            }


22123


22124            case value_t::array:


22125            {


22126                // delegate call to array_t::size()


22127                return m_value.array->size();


22128            }


22129


22130            case value_t::object:


22131            {


22132                // delegate call to object_t::size()


22133                return m_value.object->size();


22134            }


22135


22136            case value_t::string:


22137            case value_t::boolean:


22138            case value_t::number_integer:


22139            case value_t::number_unsigned:


22140            case value_t::number_float:


22141            case value_t::binary:


22142            case value_t::discarded:


22143            default:


22144            {


22145                // all other types have size 1


22146                return 1;


22147            }


22148        }


22149    }


22150


22151    /// @brief returns the maximum possible number of elements


22152    /// @sa https://json.nlohmann.me/api/basic_json/max_size/


22153    size_type max_size() const noexcept


22154    {


22155        switch (m_type)


22156        {


22157            case value_t::array:


22158            {


22159                // delegate call to array_t::max_size()


22160                return m_value.array->max_size();


22161            }


22162


22163            case value_t::object:


22164            {


22165                // delegate call to object_t::max_size()


22166                return m_value.object->max_size();


22167            }


22168


22169            case value_t::null:


22170            case value_t::string:


22171            case value_t::boolean:


22172            case value_t::number_integer:


22173            case value_t::number_unsigned:


22174            case value_t::number_float:


22175            case value_t::binary:


22176            case value_t::discarded:


22177            default:


22178            {


22179                // all other types have max_size() == size()


22180                return size();


22181            }


22182        }


22183    }


22184


22185    /// @}


22186


22187


22188    ///////////////


22189    // modifiers //


22190    ///////////////


22191


22192    /// @name modifiers


22193    /// @{


22194


22195    /// @brief clears the contents


22196    /// @sa https://json.nlohmann.me/api/basic_json/clear/


22197    void clear() noexcept


22198    {


22199        switch (m_type)


22200        {


22201            case value_t::number_integer:


22202            {


22203                m_value.number_integer = 0;


22204                break;


22205            }


22206


22207            case value_t::number_unsigned:


22208            {


22209                m_value.number_unsigned = 0;


22210                break;


22211            }


22212


22213            case value_t::number_float:


22214            {


22215                m_value.number_float = 0.0;


22216                break;


22217            }


22218


22219            case value_t::boolean:


22220            {


22221                m_value.boolean = false;


22222                break;


22223            }


22224


22225            case value_t::string:


22226            {


22227                m_value.string->clear();


22228                break;


22229            }


22230


22231            case value_t::binary:


22232            {


22233                m_value.binary->clear();


22234                break;


22235            }


22236


22237            case value_t::array:


22238            {


22239                m_value.array->clear();


22240                break;


22241            }


22242


22243            case value_t::object:


22244            {


22245                m_value.object->clear();


22246                break;


22247            }


22248


22249            case value_t::null:


22250            case value_t::discarded:


22251            default:


22252                break;


22253        }


22254    }


22255


22256    /// @brief add an object to an array


22257    /// @sa https://json.nlohmann.me/api/basic_json/push_back/


22258    void push_back(basic_json&& val)


22259    {


22260        // push_back only works for null objects or arrays


22261        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))


22262        {


22263            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));


22264        }


22265


22266        // transform null object into an array


22267        if (is_null())


22268        {


22269            m_type = value_t::array;


22270            m_value = value_t::array;


22271            assert_invariant();


22272        }


22273


22274        // add element to array (move semantics)


22275        const auto old_capacity = m_value.array->capacity();


22276        m_value.array->push_back(std::move(val));


22277        set_parent(m_value.array->back(), old_capacity);


22278        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor


22279    }


22280


22281    /// @brief add an object to an array


22282    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/


22283    reference operator+=(basic_json&& val)


22284    {


22285        push_back(std::move(val));


22286        return *this;


22287    }


22288


22289    /// @brief add an object to an array


22290    /// @sa https://json.nlohmann.me/api/basic_json/push_back/


22291    void push_back(const basic_json& val)


22292    {


22293        // push_back only works for null objects or arrays


22294        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))


22295        {


22296            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));


22297        }


22298


22299        // transform null object into an array


22300        if (is_null())


22301        {


22302            m_type = value_t::array;


22303            m_value = value_t::array;


22304            assert_invariant();


22305        }


22306


22307        // add element to array


22308        const auto old_capacity = m_value.array->capacity();


22309        m_value.array->push_back(val);


22310        set_parent(m_value.array->back(), old_capacity);


22311    }


22312


22313    /// @brief add an object to an array


22314    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/


22315    reference operator+=(const basic_json& val)


22316    {


22317        push_back(val);


22318        return *this;


22319    }


22320


22321    /// @brief add an object to an object


22322    /// @sa https://json.nlohmann.me/api/basic_json/push_back/


22323    void push_back(const typename object_t::value_type& val)


22324    {


22325        // push_back only works for null objects or objects


22326        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))


22327        {


22328            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));


22329        }


22330


22331        // transform null object into an object


22332        if (is_null())


22333        {


22334            m_type = value_t::object;


22335            m_value = value_t::object;


22336            assert_invariant();


22337        }


22338


22339        // add element to object


22340        auto res = m_value.object->insert(val);


22341        set_parent(res.first->second);


22342    }


22343


22344    /// @brief add an object to an object


22345    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/


22346    reference operator+=(const typename object_t::value_type& val)


22347    {


22348        push_back(val);


22349        return *this;


22350    }


22351


22352    /// @brief add an object to an object


22353    /// @sa https://json.nlohmann.me/api/basic_json/push_back/


22354    void push_back(initializer_list_t init)


22355    {


22356        if (is_object() && init.size() == 2 && (*init.begin())->is_string())


22357        {


22358            basic_json&& key = init.begin()->moved_or_copied();


22359            push_back(typename object_t::value_type(


22360                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));


22361        }


22362        else


22363        {


22364            push_back(basic_json(init));


22365        }


22366    }


22367


22368    /// @brief add an object to an object


22369    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/


22370    reference operator+=(initializer_list_t init)


22371    {


22372        push_back(init);


22373        return *this;


22374    }


22375


22376    /// @brief add an object to an array


22377    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/


22378    template<class... Args>


22379    reference emplace_back(Args&& ... args)


22380    {


22381        // emplace_back only works for null objects or arrays


22382        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))


22383        {


22384            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));


22385        }


22386


22387        // transform null object into an array


22388        if (is_null())


22389        {


22390            m_type = value_t::array;


22391            m_value = value_t::array;


22392            assert_invariant();


22393        }


22394


22395        // add element to array (perfect forwarding)


22396        const auto old_capacity = m_value.array->capacity();


22397        m_value.array->emplace_back(std::forward<Args>(args)...);


22398        return set_parent(m_value.array->back(), old_capacity);


22399    }


22400


22401    /// @brief add an object to an object if key does not exist


22402    /// @sa https://json.nlohmann.me/api/basic_json/emplace/


22403    template<class... Args>


22404    std::pair<iterator, bool> emplace(Args&& ... args)


22405    {


22406        // emplace only works for null objects or arrays


22407        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))


22408        {


22409            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));


22410        }


22411


22412        // transform null object into an object


22413        if (is_null())


22414        {


22415            m_type = value_t::object;


22416            m_value = value_t::object;


22417            assert_invariant();


22418        }


22419


22420        // add element to array (perfect forwarding)


22421        auto res = m_value.object->emplace(std::forward<Args>(args)...);


22422        set_parent(res.first->second);


22423


22424        // create result iterator and set iterator to the result of emplace


22425        auto it = begin();


22426        it.m_it.object_iterator = res.first;


22427


22428        // return pair of iterator and boolean


22429        return {it, res.second};


22430    }


22431


22432    /// Helper for insertion of an iterator


22433    /// @note: This uses std::distance to support GCC 4.8,


22434    ///        see https://github.com/nlohmann/json/pull/1257


22435    template<typename... Args>


22436    iterator insert_iterator(const_iterator pos, Args&& ... args)


22437    {


22438        iterator result(this);


22439        JSON_ASSERT(m_value.array != nullptr);


22440


22441        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);


22442        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);


22443        result.m_it.array_iterator = m_value.array->begin() + insert_pos;


22444


22445        // This could have been written as:


22446        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);


22447        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.


22448


22449        set_parents();


22450        return result;


22451    }


22452


22453    /// @brief inserts element into array


22454    /// @sa https://json.nlohmann.me/api/basic_json/insert/


22455    iterator insert(const_iterator pos, const basic_json& val)


22456    {


22457        // insert only works for arrays


22458        if (JSON_HEDLEY_LIKELY(is_array()))


22459        {


22460            // check if iterator pos fits to this JSON value


22461            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))


22462            {


22463                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));


22464            }


22465


22466            // insert to array and return iterator


22467            return insert_iterator(pos, val);


22468        }


22469


22470        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));


22471    }


22472


22473    /// @brief inserts element into array


22474    /// @sa https://json.nlohmann.me/api/basic_json/insert/


22475    iterator insert(const_iterator pos, basic_json&& val)


22476    {


22477        return insert(pos, val);


22478    }


22479


22480    /// @brief inserts copies of element into array


22481    /// @sa https://json.nlohmann.me/api/basic_json/insert/


22482    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)


22483    {


22484        // insert only works for arrays


22485        if (JSON_HEDLEY_LIKELY(is_array()))


22486        {


22487            // check if iterator pos fits to this JSON value


22488            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))


22489            {


22490                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));


22491            }


22492


22493            // insert to array and return iterator


22494            return insert_iterator(pos, cnt, val);


22495        }


22496


22497        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));


22498    }


22499


22500    /// @brief inserts range of elements into array


22501    /// @sa https://json.nlohmann.me/api/basic_json/insert/


22502    iterator insert(const_iterator pos, const_iterator first, const_iterator last)


22503    {


22504        // insert only works for arrays


22505        if (JSON_HEDLEY_UNLIKELY(!is_array()))


22506        {


22507            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));


22508        }


22509


22510        // check if iterator pos fits to this JSON value


22511        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))


22512        {


22513            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));


22514        }


22515


22516        // check if range iterators belong to the same JSON object


22517        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))


22518        {


22519            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));


22520        }


22521


22522        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))


22523        {


22524            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));


22525        }


22526


22527        // insert to array and return iterator


22528        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);


22529    }


22530


22531    /// @brief inserts elements from initializer list into array


22532    /// @sa https://json.nlohmann.me/api/basic_json/insert/


22533    iterator insert(const_iterator pos, initializer_list_t ilist)


22534    {


22535        // insert only works for arrays


22536        if (JSON_HEDLEY_UNLIKELY(!is_array()))


22537        {


22538            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));


22539        }


22540


22541        // check if iterator pos fits to this JSON value


22542        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))


22543        {


22544            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));


22545        }


22546


22547        // insert to array and return iterator


22548        return insert_iterator(pos, ilist.begin(), ilist.end());


22549    }


22550


22551    /// @brief inserts range of elements into object


22552    /// @sa https://json.nlohmann.me/api/basic_json/insert/


22553    void insert(const_iterator first, const_iterator last)


22554    {


22555        // insert only works for objects


22556        if (JSON_HEDLEY_UNLIKELY(!is_object()))


22557        {


22558            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));


22559        }


22560


22561        // check if range iterators belong to the same JSON object


22562        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))


22563        {


22564            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));


22565        }


22566


22567        // passed iterators must belong to objects


22568        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))


22569        {


22570            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));


22571        }


22572


22573        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);


22574    }


22575


22576    /// @brief updates a JSON object from another object, overwriting existing keys


22577    /// @sa https://json.nlohmann.me/api/basic_json/update/


22578    void update(const_reference j, bool merge_objects = false)


22579    {


22580        update(j.begin(), j.end(), merge_objects);


22581    }


22582


22583    /// @brief updates a JSON object from another object, overwriting existing keys


22584    /// @sa https://json.nlohmann.me/api/basic_json/update/


22585    void update(const_iterator first, const_iterator last, bool merge_objects = false)


22586    {


22587        // implicitly convert null value to an empty object


22588        if (is_null())


22589        {


22590            m_type = value_t::object;


22591            m_value.object = create<object_t>();


22592            assert_invariant();


22593        }


22594


22595        if (JSON_HEDLEY_UNLIKELY(!is_object()))


22596        {


22597            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));


22598        }


22599


22600        // check if range iterators belong to the same JSON object


22601        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))


22602        {


22603            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));


22604        }


22605


22606        // passed iterators must belong to objects


22607        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))


22608        {


22609            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));


22610        }


22611


22612        for (auto it = first; it != last; ++it)


22613        {


22614            if (merge_objects && it.value().is_object())


22615            {


22616                auto it2 = m_value.object->find(it.key());


22617                if (it2 != m_value.object->end())


22618                {


22619                    it2->second.update(it.value(), true);


22620                    continue;


22621                }


22622            }


22623            m_value.object->operator[](it.key()) = it.value();


22624#if JSON_DIAGNOSTICS


22625            m_value.object->operator[](it.key()).m_parent = this;


22626#endif


22627        }


22628    }


22629


22630    /// @brief exchanges the values


22631    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22632    void swap(reference other) noexcept (


22633        std::is_nothrow_move_constructible<value_t>::value&&


22634        std::is_nothrow_move_assignable<value_t>::value&&


22635        std::is_nothrow_move_constructible<json_value>::value&&


22636        std::is_nothrow_move_assignable<json_value>::value


22637    )


22638    {


22639        std::swap(m_type, other.m_type);


22640        std::swap(m_value, other.m_value);


22641


22642        set_parents();


22643        other.set_parents();


22644        assert_invariant();


22645    }


22646


22647    /// @brief exchanges the values


22648    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22649    friend void swap(reference left, reference right) noexcept (


22650        std::is_nothrow_move_constructible<value_t>::value&&


22651        std::is_nothrow_move_assignable<value_t>::value&&


22652        std::is_nothrow_move_constructible<json_value>::value&&


22653        std::is_nothrow_move_assignable<json_value>::value


22654    )


22655    {


22656        left.swap(right);


22657    }


22658


22659    /// @brief exchanges the values


22660    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22661    void swap(array_t& other) // NOLINT(bugprone-exception-escape)


22662    {


22663        // swap only works for arrays


22664        if (JSON_HEDLEY_LIKELY(is_array()))


22665        {


22666            using std::swap;


22667            swap(*(m_value.array), other);


22668        }


22669        else


22670        {


22671            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));


22672        }


22673    }


22674


22675    /// @brief exchanges the values


22676    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22677    void swap(object_t& other) // NOLINT(bugprone-exception-escape)


22678    {


22679        // swap only works for objects


22680        if (JSON_HEDLEY_LIKELY(is_object()))


22681        {


22682            using std::swap;


22683            swap(*(m_value.object), other);


22684        }


22685        else


22686        {


22687            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));


22688        }


22689    }


22690


22691    /// @brief exchanges the values


22692    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22693    void swap(string_t& other) // NOLINT(bugprone-exception-escape)


22694    {


22695        // swap only works for strings


22696        if (JSON_HEDLEY_LIKELY(is_string()))


22697        {


22698            using std::swap;


22699            swap(*(m_value.string), other);


22700        }


22701        else


22702        {


22703            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));


22704        }


22705    }


22706


22707    /// @brief exchanges the values


22708    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22709    void swap(binary_t& other) // NOLINT(bugprone-exception-escape)


22710    {


22711        // swap only works for strings


22712        if (JSON_HEDLEY_LIKELY(is_binary()))


22713        {


22714            using std::swap;


22715            swap(*(m_value.binary), other);


22716        }


22717        else


22718        {


22719            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));


22720        }


22721    }


22722


22723    /// @brief exchanges the values


22724    /// @sa https://json.nlohmann.me/api/basic_json/swap/


22725    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)


22726    {


22727        // swap only works for strings


22728        if (JSON_HEDLEY_LIKELY(is_binary()))


22729        {


22730            using std::swap;


22731            swap(*(m_value.binary), other);


22732        }


22733        else


22734        {


22735            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));


22736        }


22737    }


22738


22739    /// @}


22740


22741    //////////////////////////////////////////


22742    // lexicographical comparison operators //


22743    //////////////////////////////////////////


22744


22745    /// @name lexicographical comparison operators


22746    /// @{


22747


22748    // note parentheses around operands are necessary; see


22749    // https://github.com/nlohmann/json/issues/1530


22750#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \


22751    const auto lhs_type = lhs.type();                                                                    \


22752    const auto rhs_type = rhs.type();                                                                    \


22753    \


22754    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \


22755    {                                                                                                    \


22756        switch (lhs_type)                                                                                \


22757        {                                                                                                \


22758            case value_t::array:                                                                         \


22759                return (*lhs.m_value.array) op (*rhs.m_value.array);                                     \


22760                \


22761            case value_t::object:                                                                        \


22762                return (*lhs.m_value.object) op (*rhs.m_value.object);                                   \


22763                \


22764            case value_t::null:                                                                          \


22765                return (null_result);                                                                    \


22766                \


22767            case value_t::string:                                                                        \


22768                return (*lhs.m_value.string) op (*rhs.m_value.string);                                   \


22769                \


22770            case value_t::boolean:                                                                       \


22771                return (lhs.m_value.boolean) op (rhs.m_value.boolean);                                   \


22772                \


22773            case value_t::number_integer:                                                                \


22774                return (lhs.m_value.number_integer) op (rhs.m_value.number_integer);                     \


22775                \


22776            case value_t::number_unsigned:                                                               \


22777                return (lhs.m_value.number_unsigned) op (rhs.m_value.number_unsigned);                   \


22778                \


22779            case value_t::number_float:                                                                  \


22780                return (lhs.m_value.number_float) op (rhs.m_value.number_float);                         \


22781                \


22782            case value_t::binary:                                                                        \


22783                return (*lhs.m_value.binary) op (*rhs.m_value.binary);                                   \


22784                \


22785            case value_t::discarded:                                                                     \


22786            default:                                                                                     \


22787                return (unordered_result);                                                               \


22788        }                                                                                                \


22789    }                                                                                                    \


22790    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \


22791    {                                                                                                    \


22792        return static_cast<number_float_t>(lhs.m_value.number_integer) op rhs.m_value.number_float;      \


22793    }                                                                                                    \


22794    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \


22795    {                                                                                                    \


22796        return lhs.m_value.number_float op static_cast<number_float_t>(rhs.m_value.number_integer);      \


22797    }                                                                                                    \


22798    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \


22799    {                                                                                                    \


22800        return static_cast<number_float_t>(lhs.m_value.number_unsigned) op rhs.m_value.number_float;     \


22801    }                                                                                                    \


22802    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \


22803    {                                                                                                    \


22804        return lhs.m_value.number_float op static_cast<number_float_t>(rhs.m_value.number_unsigned);     \


22805    }                                                                                                    \


22806    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \


22807    {                                                                                                    \


22808        return static_cast<number_integer_t>(lhs.m_value.number_unsigned) op rhs.m_value.number_integer; \


22809    }                                                                                                    \


22810    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \


22811    {                                                                                                    \


22812        return lhs.m_value.number_integer op static_cast<number_integer_t>(rhs.m_value.number_unsigned); \


22813    }                                                                                                    \


22814    else if(compares_unordered(lhs, rhs))\


22815    {\


22816        return (unordered_result);\


22817    }\


22818    \


22819    return (default_result);


22820


22821  JSON_PRIVATE_UNLESS_TESTED:


22822    // returns true if:


22823    // - any operand is NaN and the other operand is of number type


22824    // - any operand is discarded


22825    // in legacy mode, discarded values are considered ordered if


22826    // an operation is computed as an odd number of inverses of others


22827    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept


22828    {


22829        if ((lhs.is_number_float() && std::isnan(lhs.m_value.number_float) && rhs.is_number())


22830                || (rhs.is_number_float() && std::isnan(rhs.m_value.number_float) && lhs.is_number()))


22831        {


22832            return true;


22833        }


22834#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON


22835        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;


22836#else


22837        static_cast<void>(inverse);


22838        return lhs.is_discarded() || rhs.is_discarded();


22839#endif


22840    }


22841


22842  private:


22843    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept


22844    {


22845        return compares_unordered(*this, rhs, inverse);


22846    }


22847


22848  public:


22849#if JSON_HAS_THREE_WAY_COMPARISON


22850    /// @brief comparison: equal


22851    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/


22852    bool operator==(const_reference rhs) const noexcept


22853    {


22854#ifdef __GNUC__


22855#pragma GCC diagnostic push


22856#pragma GCC diagnostic ignored "-Wfloat-equal"


22857#endif


22858        const_reference lhs = *this;


22859        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)


22860#ifdef __GNUC__


22861#pragma GCC diagnostic pop


22862#endif


22863    }


22864


22865    /// @brief comparison: equal


22866    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/


22867    template<typename ScalarType>


22868    requires std::is_scalar_v<ScalarType>


22869    bool operator==(ScalarType rhs) const noexcept


22870    {


22871        return *this == basic_json(rhs);


22872    }


22873


22874    /// @brief comparison: not equal


22875    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/


22876    bool operator!=(const_reference rhs) const noexcept


22877    {


22878        if (compares_unordered(rhs, true))


22879        {


22880            return false;


22881        }


22882        return !operator==(rhs);


22883    }


22884


22885    /// @brief comparison: 3-way


22886    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/


22887    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*


22888    {


22889        const_reference lhs = *this;


22890        // default_result is used if we cannot compare values. In that case,


22891        // we compare types.


22892        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*


22893                                std::partial_ordering::equivalent,


22894                                std::partial_ordering::unordered,


22895                                lhs_type <=> rhs_type) // *NOPAD*


22896    }


22897


22898    /// @brief comparison: 3-way


22899    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/


22900    template<typename ScalarType>


22901    requires std::is_scalar_v<ScalarType>


22902    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*


22903    {


22904        return *this <=> basic_json(rhs); // *NOPAD*


22905    }


22906


22907#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON


22908    // all operators that are computed as an odd number of inverses of others


22909    // need to be overloaded to emulate the legacy comparison behavior


22910


22911    /// @brief comparison: less than or equal


22912    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/


22913    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)


22914    bool operator<=(const_reference rhs) const noexcept


22915    {


22916        if (compares_unordered(rhs, true))


22917        {


22918            return false;


22919        }


22920        return !(rhs < *this);


22921    }


22922


22923    /// @brief comparison: less than or equal


22924    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/


22925    template<typename ScalarType>


22926    requires std::is_scalar_v<ScalarType>


22927    bool operator<=(ScalarType rhs) const noexcept


22928    {


22929        return *this <= basic_json(rhs);


22930    }


22931


22932    /// @brief comparison: greater than or equal


22933    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/


22934    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)


22935    bool operator>=(const_reference rhs) const noexcept


22936    {


22937        if (compares_unordered(rhs, true))


22938        {


22939            return false;


22940        }


22941        return !(*this < rhs);


22942    }


22943


22944    /// @brief comparison: greater than or equal


22945    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/


22946    template<typename ScalarType>


22947    requires std::is_scalar_v<ScalarType>


22948    bool operator>=(ScalarType rhs) const noexcept


22949    {


22950        return *this >= basic_json(rhs);


22951    }


22952#endif


22953#else


22954    /// @brief comparison: equal


22955    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/


22956    friend bool operator==(const_reference lhs, const_reference rhs) noexcept


22957    {


22958#ifdef __GNUC__


22959#pragma GCC diagnostic push


22960#pragma GCC diagnostic ignored "-Wfloat-equal"


22961#endif


22962        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)


22963#ifdef __GNUC__


22964#pragma GCC diagnostic pop


22965#endif


22966    }


22967


22968    /// @brief comparison: equal


22969    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/


22970    template<typename ScalarType, typename std::enable_if<


22971                 std::is_scalar<ScalarType>::value, int>::type = 0>


22972    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept


22973    {


22974        return lhs == basic_json(rhs);


22975    }


22976


22977    /// @brief comparison: equal


22978    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/


22979    template<typename ScalarType, typename std::enable_if<


22980                 std::is_scalar<ScalarType>::value, int>::type = 0>


22981    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept


22982    {


22983        return basic_json(lhs) == rhs;


22984    }


22985


22986    /// @brief comparison: not equal


22987    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/


22988    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept


22989    {


22990        if (compares_unordered(lhs, rhs, true))


22991        {


22992            return false;


22993        }


22994        return !(lhs == rhs);


22995    }


22996


22997    /// @brief comparison: not equal


22998    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/


22999    template<typename ScalarType, typename std::enable_if<


23000                 std::is_scalar<ScalarType>::value, int>::type = 0>


23001    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept


23002    {


23003        return lhs != basic_json(rhs);


23004    }


23005


23006    /// @brief comparison: not equal


23007    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/


23008    template<typename ScalarType, typename std::enable_if<


23009                 std::is_scalar<ScalarType>::value, int>::type = 0>


23010    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept


23011    {


23012        return basic_json(lhs) != rhs;


23013    }


23014


23015    /// @brief comparison: less than


23016    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/


23017    friend bool operator<(const_reference lhs, const_reference rhs) noexcept


23018    {


23019        // default_result is used if we cannot compare values. In that case,


23020        // we compare types. Note we have to call the operator explicitly,


23021        // because MSVC has problems otherwise.


23022        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))


23023    }


23024


23025    /// @brief comparison: less than


23026    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/


23027    template<typename ScalarType, typename std::enable_if<


23028                 std::is_scalar<ScalarType>::value, int>::type = 0>


23029    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept


23030    {


23031        return lhs < basic_json(rhs);


23032    }


23033


23034    /// @brief comparison: less than


23035    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/


23036    template<typename ScalarType, typename std::enable_if<


23037                 std::is_scalar<ScalarType>::value, int>::type = 0>


23038    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept


23039    {


23040        return basic_json(lhs) < rhs;


23041    }


23042


23043    /// @brief comparison: less than or equal


23044    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/


23045    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept


23046    {


23047        if (compares_unordered(lhs, rhs, true))


23048        {


23049            return false;


23050        }


23051        return !(rhs < lhs);


23052    }


23053


23054    /// @brief comparison: less than or equal


23055    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/


23056    template<typename ScalarType, typename std::enable_if<


23057                 std::is_scalar<ScalarType>::value, int>::type = 0>


23058    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept


23059    {


23060        return lhs <= basic_json(rhs);


23061    }


23062


23063    /// @brief comparison: less than or equal


23064    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/


23065    template<typename ScalarType, typename std::enable_if<


23066                 std::is_scalar<ScalarType>::value, int>::type = 0>


23067    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept


23068    {


23069        return basic_json(lhs) <= rhs;


23070    }


23071


23072    /// @brief comparison: greater than


23073    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/


23074    friend bool operator>(const_reference lhs, const_reference rhs) noexcept


23075    {


23076        // double inverse


23077        if (compares_unordered(lhs, rhs))


23078        {


23079            return false;


23080        }


23081        return !(lhs <= rhs);


23082    }


23083


23084    /// @brief comparison: greater than


23085    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/


23086    template<typename ScalarType, typename std::enable_if<


23087                 std::is_scalar<ScalarType>::value, int>::type = 0>


23088    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept


23089    {


23090        return lhs > basic_json(rhs);


23091    }


23092


23093    /// @brief comparison: greater than


23094    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/


23095    template<typename ScalarType, typename std::enable_if<


23096                 std::is_scalar<ScalarType>::value, int>::type = 0>


23097    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept


23098    {


23099        return basic_json(lhs) > rhs;


23100    }


23101


23102    /// @brief comparison: greater than or equal


23103    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/


23104    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept


23105    {


23106        if (compares_unordered(lhs, rhs, true))


23107        {


23108            return false;


23109        }


23110        return !(lhs < rhs);


23111    }


23112


23113    /// @brief comparison: greater than or equal


23114    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/


23115    template<typename ScalarType, typename std::enable_if<


23116                 std::is_scalar<ScalarType>::value, int>::type = 0>


23117    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept


23118    {


23119        return lhs >= basic_json(rhs);


23120    }


23121


23122    /// @brief comparison: greater than or equal


23123    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/


23124    template<typename ScalarType, typename std::enable_if<


23125                 std::is_scalar<ScalarType>::value, int>::type = 0>


23126    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept


23127    {


23128        return basic_json(lhs) >= rhs;


23129    }


23130#endif


23131


23132#undef JSON_IMPLEMENT_OPERATOR


23133


23134    /// @}


23135


23136    ///////////////////


23137    // serialization //


23138    ///////////////////


23139


23140    /// @name serialization


23141    /// @{


23142#ifndef JSON_NO_IO


23143    /// @brief serialize to stream


23144    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/


23145    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)


23146    {


23147        // read width member and use it as indentation parameter if nonzero


23148        const bool pretty_print = o.width() > 0;


23149        const auto indentation = pretty_print ? o.width() : 0;


23150


23151        // reset width to 0 for subsequent calls to this stream


23152        o.width(0);


23153


23154        // do the actual serialization


23155        serializer s(detail::output_adapter<char>(o), o.fill());


23156        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));


23157        return o;


23158    }


23159


23160    /// @brief serialize to stream


23161    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/


23162    /// @deprecated This function is deprecated since 3.0.0 and will be removed in


23163    ///             version 4.0.0 of the library. Please use


23164    ///             operator<<(std::ostream&, const basic_json&) instead; that is,


23165    ///             replace calls like `j >> o;` with `o << j;`.


23166    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))


23167    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)


23168    {


23169        return o << j;


23170    }


23171#endif  // JSON_NO_IO


23172    /// @}


23173


23174


23175    /////////////////////


23176    // deserialization //


23177    /////////////////////


23178


23179    /// @name deserialization


23180    /// @{


23181


23182    /// @brief deserialize from a compatible input


23183    /// @sa https://json.nlohmann.me/api/basic_json/parse/


23184    template<typename InputType>


23185    JSON_HEDLEY_WARN_UNUSED_RESULT


23186    static basic_json parse(InputType&& i,


23187                            const parser_callback_t cb = nullptr,


23188                            const bool allow_exceptions = true,


23189                            const bool ignore_comments = false)


23190    {


23191        basic_json result;


23192        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);


23193        return result;


23194    }


23195


23196    /// @brief deserialize from a pair of character iterators


23197    /// @sa https://json.nlohmann.me/api/basic_json/parse/


23198    template<typename IteratorType>


23199    JSON_HEDLEY_WARN_UNUSED_RESULT


23200    static basic_json parse(IteratorType first,


23201                            IteratorType last,


23202                            const parser_callback_t cb = nullptr,


23203                            const bool allow_exceptions = true,


23204                            const bool ignore_comments = false)


23205    {


23206        basic_json result;


23207        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);


23208        return result;


23209    }


23210


23211    JSON_HEDLEY_WARN_UNUSED_RESULT


23212    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))


23213    static basic_json parse(detail::span_input_adapter&& i,


23214                            const parser_callback_t cb = nullptr,


23215                            const bool allow_exceptions = true,


23216                            const bool ignore_comments = false)


23217    {


23218        basic_json result;


23219        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);


23220        return result;


23221    }


23222


23223    /// @brief check if the input is valid JSON


23224    /// @sa https://json.nlohmann.me/api/basic_json/accept/


23225    template<typename InputType>


23226    static bool accept(InputType&& i,


23227                       const bool ignore_comments = false)


23228    {


23229        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);


23230    }


23231


23232    /// @brief check if the input is valid JSON


23233    /// @sa https://json.nlohmann.me/api/basic_json/accept/


23234    template<typename IteratorType>


23235    static bool accept(IteratorType first, IteratorType last,


23236                       const bool ignore_comments = false)


23237    {


23238        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);


23239    }


23240


23241    JSON_HEDLEY_WARN_UNUSED_RESULT


23242    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))


23243    static bool accept(detail::span_input_adapter&& i,


23244                       const bool ignore_comments = false)


23245    {


23246        return parser(i.get(), nullptr, false, ignore_comments).accept(true);


23247    }


23248


23249    /// @brief generate SAX events


23250    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/


23251    template <typename InputType, typename SAX>


23252    JSON_HEDLEY_NON_NULL(2)


23253    static bool sax_parse(InputType&& i, SAX* sax,


23254                          input_format_t format = input_format_t::json,


23255                          const bool strict = true,


23256                          const bool ignore_comments = false)


23257    {


23258        auto ia = detail::input_adapter(std::forward<InputType>(i));


23259        return format == input_format_t::json


23260               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)


23261               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);


23262    }


23263


23264    /// @brief generate SAX events


23265    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/


23266    template<class IteratorType, class SAX>


23267    JSON_HEDLEY_NON_NULL(3)


23268    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,


23269                          input_format_t format = input_format_t::json,


23270                          const bool strict = true,


23271                          const bool ignore_comments = false)


23272    {


23273        auto ia = detail::input_adapter(std::move(first), std::move(last));


23274        return format == input_format_t::json


23275               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)


23276               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);


23277    }


23278


23279    /// @brief generate SAX events


23280    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/


23281    /// @deprecated This function is deprecated since 3.8.0 and will be removed in


23282    ///             version 4.0.0 of the library. Please use


23283    ///             sax_parse(ptr, ptr + len) instead.


23284    template <typename SAX>


23285    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))


23286    JSON_HEDLEY_NON_NULL(2)


23287    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,


23288                          input_format_t format = input_format_t::json,


23289                          const bool strict = true,


23290                          const bool ignore_comments = false)


23291    {


23292        auto ia = i.get();


23293        return format == input_format_t::json


23294               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)


23295               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)


23296               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)


23297               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);


23298    }


23299#ifndef JSON_NO_IO


23300    /// @brief deserialize from stream


23301    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/


23302    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in


23303    ///             version 4.0.0 of the library. Please use


23304    ///             operator>>(std::istream&, basic_json&) instead; that is,


23305    ///             replace calls like `j << i;` with `i >> j;`.


23306    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))


23307    friend std::istream& operator<<(basic_json& j, std::istream& i)


23308    {


23309        return operator>>(i, j);


23310    }


23311


23312    /// @brief deserialize from stream


23313    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/


23314    friend std::istream& operator>>(std::istream& i, basic_json& j)


23315    {


23316        parser(detail::input_adapter(i)).parse(false, j);


23317        return i;


23318    }


23319#endif  // JSON_NO_IO


23320    /// @}


23321


23322    ///////////////////////////


23323    // convenience functions //


23324    ///////////////////////////


23325


23326    /// @brief return the type as string


23327    /// @sa https://json.nlohmann.me/api/basic_json/type_name/


23328    JSON_HEDLEY_RETURNS_NON_NULL


23329    const char* type_name() const noexcept


23330    {


23331        switch (m_type)


23332        {


23333            case value_t::null:


23334                return "null";


23335            case value_t::object:


23336                return "object";


23337            case value_t::array:


23338                return "array";


23339            case value_t::string:


23340                return "string";


23341            case value_t::boolean:


23342                return "boolean";


23343            case value_t::binary:


23344                return "binary";


23345            case value_t::discarded:


23346                return "discarded";


23347            case value_t::number_integer:


23348            case value_t::number_unsigned:


23349            case value_t::number_float:


23350            default:


23351                return "number";


23352        }


23353    }


23354


23355


23356  JSON_PRIVATE_UNLESS_TESTED:


23357    //////////////////////


23358    // member variables //


23359    //////////////////////


23360


23361    /// the type of the current element


23362    value_t m_type = value_t::null;


23363


23364    /// the value of the current element


23365    json_value m_value = {};


23366


23367#if JSON_DIAGNOSTICS


23368    /// a pointer to a parent value (for debugging purposes)


23369    basic_json* m_parent = nullptr;


23370#endif


23371


23372    //////////////////////////////////////////


23373    // binary serialization/deserialization //


23374    //////////////////////////////////////////


23375


23376    /// @name binary serialization/deserialization support


23377    /// @{


23378


23379  public:


23380    /// @brief create a CBOR serialization of a given JSON value


23381    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/


23382    static std::vector<std::uint8_t> to_cbor(const basic_json& j)


23383    {


23384        std::vector<std::uint8_t> result;


23385        to_cbor(j, result);


23386        return result;


23387    }


23388


23389    /// @brief create a CBOR serialization of a given JSON value


23390    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/


23391    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)


23392    {


23393        binary_writer<std::uint8_t>(o).write_cbor(j);


23394    }


23395


23396    /// @brief create a CBOR serialization of a given JSON value


23397    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/


23398    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)


23399    {


23400        binary_writer<char>(o).write_cbor(j);


23401    }


23402


23403    /// @brief create a MessagePack serialization of a given JSON value


23404    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/


23405    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)


23406    {


23407        std::vector<std::uint8_t> result;


23408        to_msgpack(j, result);


23409        return result;


23410    }


23411


23412    /// @brief create a MessagePack serialization of a given JSON value


23413    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/


23414    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)


23415    {


23416        binary_writer<std::uint8_t>(o).write_msgpack(j);


23417    }


23418


23419    /// @brief create a MessagePack serialization of a given JSON value


23420    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/


23421    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)


23422    {


23423        binary_writer<char>(o).write_msgpack(j);


23424    }


23425


23426    /// @brief create a UBJSON serialization of a given JSON value


23427    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/


23428    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,


23429            const bool use_size = false,


23430            const bool use_type = false)


23431    {


23432        std::vector<std::uint8_t> result;


23433        to_ubjson(j, result, use_size, use_type);


23434        return result;


23435    }


23436


23437    /// @brief create a UBJSON serialization of a given JSON value


23438    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/


23439    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,


23440                          const bool use_size = false, const bool use_type = false)


23441    {


23442        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);


23443    }


23444


23445    /// @brief create a UBJSON serialization of a given JSON value


23446    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/


23447    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,


23448                          const bool use_size = false, const bool use_type = false)


23449    {


23450        binary_writer<char>(o).write_ubjson(j, use_size, use_type);


23451    }


23452


23453    /// @brief create a BJData serialization of a given JSON value


23454    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/


23455    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,


23456            const bool use_size = false,


23457            const bool use_type = false)


23458    {


23459        std::vector<std::uint8_t> result;


23460        to_bjdata(j, result, use_size, use_type);


23461        return result;


23462    }


23463


23464    /// @brief create a BJData serialization of a given JSON value


23465    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/


23466    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,


23467                          const bool use_size = false, const bool use_type = false)


23468    {


23469        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);


23470    }


23471


23472    /// @brief create a BJData serialization of a given JSON value


23473    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/


23474    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,


23475                          const bool use_size = false, const bool use_type = false)


23476    {


23477        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);


23478    }


23479


23480    /// @brief create a BSON serialization of a given JSON value


23481    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/


23482    static std::vector<std::uint8_t> to_bson(const basic_json& j)


23483    {


23484        std::vector<std::uint8_t> result;


23485        to_bson(j, result);


23486        return result;


23487    }


23488


23489    /// @brief create a BSON serialization of a given JSON value


23490    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/


23491    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)


23492    {


23493        binary_writer<std::uint8_t>(o).write_bson(j);


23494    }


23495


23496    /// @brief create a BSON serialization of a given JSON value


23497    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/


23498    static void to_bson(const basic_json& j, detail::output_adapter<char> o)


23499    {


23500        binary_writer<char>(o).write_bson(j);


23501    }


23502


23503    /// @brief create a JSON value from an input in CBOR format


23504    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/


23505    template<typename InputType>


23506    JSON_HEDLEY_WARN_UNUSED_RESULT


23507    static basic_json from_cbor(InputType&& i,


23508                                const bool strict = true,


23509                                const bool allow_exceptions = true,


23510                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)


23511    {


23512        basic_json result;


23513        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23514        auto ia = detail::input_adapter(std::forward<InputType>(i));


23515        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);


23516        return res ? result : basic_json(value_t::discarded);


23517    }


23518


23519    /// @brief create a JSON value from an input in CBOR format


23520    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/


23521    template<typename IteratorType>


23522    JSON_HEDLEY_WARN_UNUSED_RESULT


23523    static basic_json from_cbor(IteratorType first, IteratorType last,


23524                                const bool strict = true,


23525                                const bool allow_exceptions = true,


23526                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)


23527    {


23528        basic_json result;


23529        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23530        auto ia = detail::input_adapter(std::move(first), std::move(last));


23531        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);


23532        return res ? result : basic_json(value_t::discarded);


23533    }


23534


23535    template<typename T>


23536    JSON_HEDLEY_WARN_UNUSED_RESULT


23537    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))


23538    static basic_json from_cbor(const T* ptr, std::size_t len,


23539                                const bool strict = true,


23540                                const bool allow_exceptions = true,


23541                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)


23542    {


23543        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);


23544    }


23545


23546


23547    JSON_HEDLEY_WARN_UNUSED_RESULT


23548    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))


23549    static basic_json from_cbor(detail::span_input_adapter&& i,


23550                                const bool strict = true,


23551                                const bool allow_exceptions = true,


23552                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)


23553    {


23554        basic_json result;


23555        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23556        auto ia = i.get();


23557        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)


23558        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);


23559        return res ? result : basic_json(value_t::discarded);


23560    }


23561


23562    /// @brief create a JSON value from an input in MessagePack format


23563    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/


23564    template<typename InputType>


23565    JSON_HEDLEY_WARN_UNUSED_RESULT


23566    static basic_json from_msgpack(InputType&& i,


23567                                   const bool strict = true,


23568                                   const bool allow_exceptions = true)


23569    {


23570        basic_json result;


23571        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23572        auto ia = detail::input_adapter(std::forward<InputType>(i));


23573        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);


23574        return res ? result : basic_json(value_t::discarded);


23575    }


23576


23577    /// @brief create a JSON value from an input in MessagePack format


23578    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/


23579    template<typename IteratorType>


23580    JSON_HEDLEY_WARN_UNUSED_RESULT


23581    static basic_json from_msgpack(IteratorType first, IteratorType last,


23582                                   const bool strict = true,


23583                                   const bool allow_exceptions = true)


23584    {


23585        basic_json result;


23586        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23587        auto ia = detail::input_adapter(std::move(first), std::move(last));


23588        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);


23589        return res ? result : basic_json(value_t::discarded);


23590    }


23591


23592    template<typename T>


23593    JSON_HEDLEY_WARN_UNUSED_RESULT


23594    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))


23595    static basic_json from_msgpack(const T* ptr, std::size_t len,


23596                                   const bool strict = true,


23597                                   const bool allow_exceptions = true)


23598    {


23599        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);


23600    }


23601


23602    JSON_HEDLEY_WARN_UNUSED_RESULT


23603    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))


23604    static basic_json from_msgpack(detail::span_input_adapter&& i,


23605                                   const bool strict = true,


23606                                   const bool allow_exceptions = true)


23607    {


23608        basic_json result;


23609        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23610        auto ia = i.get();


23611        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)


23612        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);


23613        return res ? result : basic_json(value_t::discarded);


23614    }


23615


23616    /// @brief create a JSON value from an input in UBJSON format


23617    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/


23618    template<typename InputType>


23619    JSON_HEDLEY_WARN_UNUSED_RESULT


23620    static basic_json from_ubjson(InputType&& i,


23621                                  const bool strict = true,


23622                                  const bool allow_exceptions = true)


23623    {


23624        basic_json result;


23625        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23626        auto ia = detail::input_adapter(std::forward<InputType>(i));


23627        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);


23628        return res ? result : basic_json(value_t::discarded);


23629    }


23630


23631    /// @brief create a JSON value from an input in UBJSON format


23632    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/


23633    template<typename IteratorType>


23634    JSON_HEDLEY_WARN_UNUSED_RESULT


23635    static basic_json from_ubjson(IteratorType first, IteratorType last,


23636                                  const bool strict = true,


23637                                  const bool allow_exceptions = true)


23638    {


23639        basic_json result;


23640        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23641        auto ia = detail::input_adapter(std::move(first), std::move(last));


23642        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);


23643        return res ? result : basic_json(value_t::discarded);


23644    }


23645


23646    template<typename T>


23647    JSON_HEDLEY_WARN_UNUSED_RESULT


23648    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))


23649    static basic_json from_ubjson(const T* ptr, std::size_t len,


23650                                  const bool strict = true,


23651                                  const bool allow_exceptions = true)


23652    {


23653        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);


23654    }


23655


23656    JSON_HEDLEY_WARN_UNUSED_RESULT


23657    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))


23658    static basic_json from_ubjson(detail::span_input_adapter&& i,


23659                                  const bool strict = true,


23660                                  const bool allow_exceptions = true)


23661    {


23662        basic_json result;


23663        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23664        auto ia = i.get();


23665        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)


23666        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);


23667        return res ? result : basic_json(value_t::discarded);


23668    }


23669


23670


23671    /// @brief create a JSON value from an input in BJData format


23672    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/


23673    template<typename InputType>


23674    JSON_HEDLEY_WARN_UNUSED_RESULT


23675    static basic_json from_bjdata(InputType&& i,


23676                                  const bool strict = true,


23677                                  const bool allow_exceptions = true)


23678    {


23679        basic_json result;


23680        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23681        auto ia = detail::input_adapter(std::forward<InputType>(i));


23682        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);


23683        return res ? result : basic_json(value_t::discarded);


23684    }


23685


23686    /// @brief create a JSON value from an input in BJData format


23687    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/


23688    template<typename IteratorType>


23689    JSON_HEDLEY_WARN_UNUSED_RESULT


23690    static basic_json from_bjdata(IteratorType first, IteratorType last,


23691                                  const bool strict = true,


23692                                  const bool allow_exceptions = true)


23693    {


23694        basic_json result;


23695        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23696        auto ia = detail::input_adapter(std::move(first), std::move(last));


23697        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);


23698        return res ? result : basic_json(value_t::discarded);


23699    }


23700


23701    /// @brief create a JSON value from an input in BSON format


23702    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/


23703    template<typename InputType>


23704    JSON_HEDLEY_WARN_UNUSED_RESULT


23705    static basic_json from_bson(InputType&& i,


23706                                const bool strict = true,


23707                                const bool allow_exceptions = true)


23708    {


23709        basic_json result;


23710        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23711        auto ia = detail::input_adapter(std::forward<InputType>(i));


23712        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);


23713        return res ? result : basic_json(value_t::discarded);


23714    }


23715


23716    /// @brief create a JSON value from an input in BSON format


23717    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/


23718    template<typename IteratorType>


23719    JSON_HEDLEY_WARN_UNUSED_RESULT


23720    static basic_json from_bson(IteratorType first, IteratorType last,


23721                                const bool strict = true,


23722                                const bool allow_exceptions = true)


23723    {


23724        basic_json result;


23725        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23726        auto ia = detail::input_adapter(std::move(first), std::move(last));


23727        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);


23728        return res ? result : basic_json(value_t::discarded);


23729    }


23730


23731    template<typename T>


23732    JSON_HEDLEY_WARN_UNUSED_RESULT


23733    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))


23734    static basic_json from_bson(const T* ptr, std::size_t len,


23735                                const bool strict = true,


23736                                const bool allow_exceptions = true)


23737    {


23738        return from_bson(ptr, ptr + len, strict, allow_exceptions);


23739    }


23740


23741    JSON_HEDLEY_WARN_UNUSED_RESULT


23742    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))


23743    static basic_json from_bson(detail::span_input_adapter&& i,


23744                                const bool strict = true,


23745                                const bool allow_exceptions = true)


23746    {


23747        basic_json result;


23748        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);


23749        auto ia = i.get();


23750        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)


23751        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);


23752        return res ? result : basic_json(value_t::discarded);


23753    }


23754    /// @}


23755


23756    //////////////////////////


23757    // JSON Pointer support //


23758    //////////////////////////


23759


23760    /// @name JSON Pointer functions


23761    /// @{


23762


23763    /// @brief access specified element via JSON Pointer


23764    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


23765    reference operator[](const json_pointer& ptr)


23766    {


23767        return ptr.get_unchecked(this);


23768    }


23769


23770    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>


23771    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


23772    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)


23773    {


23774        return ptr.get_unchecked(this);


23775    }


23776


23777    /// @brief access specified element via JSON Pointer


23778    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/


23779    const_reference operator[](const json_pointer& ptr) const


23780    {


23781        return ptr.get_unchecked(this);


23782    }


23783


23784    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>


23785    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


23786    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const


23787    {


23788        return ptr.get_unchecked(this);


23789    }


23790


23791    /// @brief access specified element via JSON Pointer


23792    /// @sa https://json.nlohmann.me/api/basic_json/at/


23793    reference at(const json_pointer& ptr)


23794    {


23795        return ptr.get_checked(this);


23796    }


23797


23798    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>


23799    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


23800    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)


23801    {


23802        return ptr.get_checked(this);


23803    }


23804


23805    /// @brief access specified element via JSON Pointer


23806    /// @sa https://json.nlohmann.me/api/basic_json/at/


23807    const_reference at(const json_pointer& ptr) const


23808    {


23809        return ptr.get_checked(this);


23810    }


23811


23812    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>


23813    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)


23814    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const


23815    {


23816        return ptr.get_checked(this);


23817    }


23818


23819    /// @brief return flattened JSON value


23820    /// @sa https://json.nlohmann.me/api/basic_json/flatten/


23821    basic_json flatten() const


23822    {


23823        basic_json result(value_t::object);


23824        json_pointer::flatten("", *this, result);


23825        return result;


23826    }


23827


23828    /// @brief unflatten a previously flattened JSON value


23829    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/


23830    basic_json unflatten() const


23831    {


23832        return json_pointer::unflatten(*this);


23833    }


23834


23835    /// @}


23836


23837    //////////////////////////


23838    // JSON Patch functions //


23839    //////////////////////////


23840


23841    /// @name JSON Patch functions


23842    /// @{


23843


23844    /// @brief applies a JSON patch in-place without copying the object


23845    /// @sa https://json.nlohmann.me/api/basic_json/patch/


23846    void patch_inplace(const basic_json& json_patch)


23847    {


23848        basic_json& result = *this;


23849        // the valid JSON Patch operations


23850        enum class patch_operations {add, remove, replace, move, copy, test, invalid};


23851


23852        const auto get_op = [](const std::string & op)


23853        {


23854            if (op == "add")


23855            {


23856                return patch_operations::add;


23857            }


23858            if (op == "remove")


23859            {


23860                return patch_operations::remove;


23861            }


23862            if (op == "replace")


23863            {


23864                return patch_operations::replace;


23865            }


23866            if (op == "move")


23867            {


23868                return patch_operations::move;


23869            }


23870            if (op == "copy")


23871            {


23872                return patch_operations::copy;


23873            }


23874            if (op == "test")


23875            {


23876                return patch_operations::test;


23877            }


23878


23879            return patch_operations::invalid;


23880        };


23881


23882        // wrapper for "add" operation; add value at ptr


23883        const auto operation_add = [&result](json_pointer & ptr, basic_json val)


23884        {


23885            // adding to the root of the target document means replacing it


23886            if (ptr.empty())


23887            {


23888                result = val;


23889                return;


23890            }


23891


23892            // make sure the top element of the pointer exists


23893            json_pointer top_pointer = ptr.top();


23894            if (top_pointer != ptr)


23895            {


23896                result.at(top_pointer);


23897            }


23898


23899            // get reference to parent of JSON pointer ptr


23900            const auto last_path = ptr.back();


23901            ptr.pop_back();


23902            // parent must exist when performing patch add per RFC6902 specs


23903            basic_json& parent = result.at(ptr);


23904


23905            switch (parent.m_type)


23906            {


23907                case value_t::null:


23908                case value_t::object:


23909                {


23910                    // use operator[] to add value


23911                    parent[last_path] = val;


23912                    break;


23913                }


23914


23915                case value_t::array:


23916                {


23917                    if (last_path == "-")


23918                    {


23919                        // special case: append to back


23920                        parent.push_back(val);


23921                    }


23922                    else


23923                    {


23924                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);


23925                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))


23926                        {


23927                            // avoid undefined behavior


23928                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));


23929                        }


23930


23931                        // default case: insert add offset


23932                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);


23933                    }


23934                    break;


23935                }


23936


23937                // if there exists a parent it cannot be primitive


23938                case value_t::string: // LCOV_EXCL_LINE


23939                case value_t::boolean: // LCOV_EXCL_LINE


23940                case value_t::number_integer: // LCOV_EXCL_LINE


23941                case value_t::number_unsigned: // LCOV_EXCL_LINE


23942                case value_t::number_float: // LCOV_EXCL_LINE


23943                case value_t::binary: // LCOV_EXCL_LINE


23944                case value_t::discarded: // LCOV_EXCL_LINE


23945                default:            // LCOV_EXCL_LINE


23946                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE


23947            }


23948        };


23949


23950        // wrapper for "remove" operation; remove value at ptr


23951        const auto operation_remove = [this, &result](json_pointer & ptr)


23952        {


23953            // get reference to parent of JSON pointer ptr


23954            const auto last_path = ptr.back();


23955            ptr.pop_back();


23956            basic_json& parent = result.at(ptr);


23957


23958            // remove child


23959            if (parent.is_object())


23960            {


23961                // perform range check


23962                auto it = parent.find(last_path);


23963                if (JSON_HEDLEY_LIKELY(it != parent.end()))


23964                {


23965                    parent.erase(it);


23966                }


23967                else


23968                {


23969                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));


23970                }


23971            }


23972            else if (parent.is_array())


23973            {


23974                // note erase performs range check


23975                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));


23976            }


23977        };


23978


23979        // type check: top level value must be an array


23980        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))


23981        {


23982            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));


23983        }


23984


23985        // iterate and apply the operations


23986        for (const auto& val : json_patch)


23987        {


23988            // wrapper to get a value for an operation


23989            const auto get_value = [&val](const std::string & op,


23990                                          const std::string & member,


23991                                          bool string_type) -> basic_json &


23992            {


23993                // find value


23994                auto it = val.m_value.object->find(member);


23995


23996                // context-sensitive error message


23997                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');


23998


23999                // check if desired value is present


24000                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))


24001                {


24002                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)


24003                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));


24004                }


24005


24006                // check if result is of type string


24007                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))


24008                {


24009                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)


24010                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));


24011                }


24012


24013                // no error: return value


24014                return it->second;


24015            };


24016


24017            // type check: every element of the array must be an object


24018            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))


24019            {


24020                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));


24021            }


24022


24023            // collect mandatory members


24024            const auto op = get_value("op", "op", true).template get<std::string>();


24025            const auto path = get_value(op, "path", true).template get<std::string>();


24026            json_pointer ptr(path);


24027


24028            switch (get_op(op))


24029            {


24030                case patch_operations::add:


24031                {


24032                    operation_add(ptr, get_value("add", "value", false));


24033                    break;


24034                }


24035


24036                case patch_operations::remove:


24037                {


24038                    operation_remove(ptr);


24039                    break;


24040                }


24041


24042                case patch_operations::replace:


24043                {


24044                    // the "path" location must exist - use at()


24045                    result.at(ptr) = get_value("replace", "value", false);


24046                    break;


24047                }


24048


24049                case patch_operations::move:


24050                {


24051                    const auto from_path = get_value("move", "from", true).template get<std::string>();


24052                    json_pointer from_ptr(from_path);


24053


24054                    // the "from" location must exist - use at()


24055                    basic_json v = result.at(from_ptr);


24056


24057                    // The move operation is functionally identical to a


24058                    // "remove" operation on the "from" location, followed


24059                    // immediately by an "add" operation at the target


24060                    // location with the value that was just removed.


24061                    operation_remove(from_ptr);


24062                    operation_add(ptr, v);


24063                    break;


24064                }


24065


24066                case patch_operations::copy:


24067                {


24068                    const auto from_path = get_value("copy", "from", true).template get<std::string>();


24069                    const json_pointer from_ptr(from_path);


24070


24071                    // the "from" location must exist - use at()


24072                    basic_json v = result.at(from_ptr);


24073


24074                    // The copy is functionally identical to an "add"


24075                    // operation at the target location using the value


24076                    // specified in the "from" member.


24077                    operation_add(ptr, v);


24078                    break;


24079                }


24080


24081                case patch_operations::test:


24082                {


24083                    bool success = false;


24084                    JSON_TRY


24085                    {


24086                        // check if "value" matches the one at "path"


24087                        // the "path" location must exist - use at()


24088                        success = (result.at(ptr) == get_value("test", "value", false));


24089                    }


24090                    JSON_INTERNAL_CATCH (out_of_range&)


24091                    {


24092                        // ignore out of range errors: success remains false


24093                    }


24094


24095                    // throw an exception if test fails


24096                    if (JSON_HEDLEY_UNLIKELY(!success))


24097                    {


24098                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));


24099                    }


24100


24101                    break;


24102                }


24103


24104                case patch_operations::invalid:


24105                default:


24106                {


24107                    // op must be "add", "remove", "replace", "move", "copy", or


24108                    // "test"


24109                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));


24110                }


24111            }


24112        }


24113    }


24114


24115    /// @brief applies a JSON patch to a copy of the current object


24116    /// @sa https://json.nlohmann.me/api/basic_json/patch/


24117    basic_json patch(const basic_json& json_patch) const


24118    {


24119        basic_json result = *this;


24120        result.patch_inplace(json_patch);


24121        return result;


24122    }


24123


24124    /// @brief creates a diff as a JSON patch


24125    /// @sa https://json.nlohmann.me/api/basic_json/diff/


24126    JSON_HEDLEY_WARN_UNUSED_RESULT


24127    static basic_json diff(const basic_json& source, const basic_json& target,


24128                           const std::string& path = "")


24129    {


24130        // the patch


24131        basic_json result(value_t::array);


24132


24133        // if the values are the same, return empty patch


24134        if (source == target)


24135        {


24136            return result;


24137        }


24138


24139        if (source.type() != target.type())


24140        {


24141            // different types: replace value


24142            result.push_back(


24143            {


24144                {"op", "replace"}, {"path", path}, {"value", target}


24145            });


24146            return result;


24147        }


24148


24149        switch (source.type())


24150        {


24151            case value_t::array:


24152            {


24153                // first pass: traverse common elements


24154                std::size_t i = 0;


24155                while (i < source.size() && i < target.size())


24156                {


24157                    // recursive call to compare array values at index i


24158                    auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));


24159                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());


24160                    ++i;


24161                }


24162


24163                // We now reached the end of at least one array


24164                // in a second pass, traverse the remaining elements


24165


24166                // remove my remaining elements


24167                const auto end_index = static_cast<difference_type>(result.size());


24168                while (i < source.size())


24169                {


24170                    // add operations in reverse order to avoid invalid


24171                    // indices


24172                    result.insert(result.begin() + end_index, object(


24173                    {


24174                        {"op", "remove"},


24175                        {"path", detail::concat(path, '/', std::to_string(i))}


24176                    }));


24177                    ++i;


24178                }


24179


24180                // add other remaining elements


24181                while (i < target.size())


24182                {


24183                    result.push_back(


24184                    {


24185                        {"op", "add"},


24186                        {"path", detail::concat(path, "/-")},


24187                        {"value", target[i]}


24188                    });


24189                    ++i;


24190                }


24191


24192                break;


24193            }


24194


24195            case value_t::object:


24196            {


24197                // first pass: traverse this object's elements


24198                for (auto it = source.cbegin(); it != source.cend(); ++it)


24199                {


24200                    // escape the key name to be used in a JSON patch


24201                    const auto path_key = detail::concat(path, '/', detail::escape(it.key()));


24202


24203                    if (target.find(it.key()) != target.end())


24204                    {


24205                        // recursive call to compare object values at key it


24206                        auto temp_diff = diff(it.value(), target[it.key()], path_key);


24207                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());


24208                    }


24209                    else


24210                    {


24211                        // found a key that is not in o -> remove it


24212                        result.push_back(object(


24213                        {


24214                            {"op", "remove"}, {"path", path_key}


24215                        }));


24216                    }


24217                }


24218


24219                // second pass: traverse other object's elements


24220                for (auto it = target.cbegin(); it != target.cend(); ++it)


24221                {


24222                    if (source.find(it.key()) == source.end())


24223                    {


24224                        // found a key that is not in this -> add it


24225                        const auto path_key = detail::concat(path, '/', detail::escape(it.key()));


24226                        result.push_back(


24227                        {


24228                            {"op", "add"}, {"path", path_key},


24229                            {"value", it.value()}


24230                        });


24231                    }


24232                }


24233


24234                break;


24235            }


24236


24237            case value_t::null:


24238            case value_t::string:


24239            case value_t::boolean:


24240            case value_t::number_integer:


24241            case value_t::number_unsigned:


24242            case value_t::number_float:


24243            case value_t::binary:


24244            case value_t::discarded:


24245            default:


24246            {


24247                // both primitive type: replace value


24248                result.push_back(


24249                {


24250                    {"op", "replace"}, {"path", path}, {"value", target}


24251                });


24252                break;


24253            }


24254        }


24255


24256        return result;


24257    }


24258    /// @}


24259


24260    ////////////////////////////////


24261    // JSON Merge Patch functions //


24262    ////////////////////////////////


24263


24264    /// @name JSON Merge Patch functions


24265    /// @{


24266


24267    /// @brief applies a JSON Merge Patch


24268    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/


24269    void merge_patch(const basic_json& apply_patch)


24270    {


24271        if (apply_patch.is_object())


24272        {


24273            if (!is_object())


24274            {


24275                *this = object();


24276            }


24277            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)


24278            {


24279                if (it.value().is_null())


24280                {


24281                    erase(it.key());


24282                }


24283                else


24284                {


24285                    operator[](it.key()).merge_patch(it.value());


24286                }


24287            }


24288        }


24289        else


24290        {


24291            *this = apply_patch;


24292        }


24293    }


24294


24295    /// @}


24296};


24297


24298/// @brief user-defined to_string function for JSON values


24299/// @sa https://json.nlohmann.me/api/basic_json/to_string/


24300NLOHMANN_BASIC_JSON_TPL_DECLARATION


24301std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)


24302{


24303    return j.dump();


24304}


24305


24306inline namespace literals


24307{


24308inline namespace json_literals


24309{


24310


24311/// @brief user-defined string literal for JSON values


24312/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/


24313JSON_HEDLEY_NON_NULL(1)


24314inline nlohmann::json operator "" _json(const char* s, std::size_t n)


24315{


24316    return nlohmann::json::parse(s, s + n);


24317}


24318


24319/// @brief user-defined string literal for JSON pointer


24320/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/


24321JSON_HEDLEY_NON_NULL(1)


24322inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)


24323{


24324    return nlohmann::json::json_pointer(std::string(s, n));


24325}


24326


24327}  // namespace json_literals


24328}  // namespace literals


24329NLOHMANN_JSON_NAMESPACE_END


24330


24331///////////////////////


24332// nonmember support //


24333///////////////////////


24334


24335namespace std // NOLINT(cert-dcl58-cpp)


24336{


24337


24338/// @brief hash value for JSON objects


24339/// @sa https://json.nlohmann.me/api/basic_json/std_hash/


24340NLOHMANN_BASIC_JSON_TPL_DECLARATION


24341struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL>


24342{


24343    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const


24344    {


24345        return nlohmann::detail::hash(j);


24346    }


24347};


24348


24349// specialization for std::less<value_t>


24350template<>


24351struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679


24352{


24353    /*!


24354    @brief compare two value_t enum values


24355    @since version 3.0.0


24356    */


24357    bool operator()(::nlohmann::detail::value_t lhs,


24358                    ::nlohmann::detail::value_t rhs) const noexcept


24359    {


24360#if JSON_HAS_THREE_WAY_COMPARISON


24361        return std::is_lt(lhs <=> rhs); // *NOPAD*


24362#else


24363        return ::nlohmann::detail::operator<(lhs, rhs);


24364#endif


24365    }


24366};


24367


24368// C++20 prohibit function specialization in the std namespace.


24369#ifndef JSON_HAS_CPP_20


24370


24371/// @brief exchanges the values of two JSON objects


24372/// @sa https://json.nlohmann.me/api/basic_json/std_swap/


24373NLOHMANN_BASIC_JSON_TPL_DECLARATION


24374inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name)


24375    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression)


24376    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)


24377{


24378    j1.swap(j2);


24379}


24380


24381#endif


24382


24383}  // namespace std


24384


24385#if JSON_USE_GLOBAL_UDLS


24386    using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)


24387    using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)


24388#endif


24389


24390// #include <nlohmann/detail/macro_unscope.hpp>


24391//     __ _____ _____ _____


24392//  __|  |   __|     |   | |  JSON for Modern C++


24393// |  |  |__   |  |  | | | |  version 3.11.2


24394// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


24395//


24396// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


24397// SPDX-License-Identifier: MIT


24398


24399


24400


24401// restore clang diagnostic settings


24402#if defined(__clang__)


24403    #pragma clang diagnostic pop


24404#endif


24405


24406// clean up


24407#undef JSON_ASSERT


24408#undef JSON_INTERNAL_CATCH


24409#undef JSON_THROW


24410#undef JSON_PRIVATE_UNLESS_TESTED


24411#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION


24412#undef NLOHMANN_BASIC_JSON_TPL


24413#undef JSON_EXPLICIT


24414#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL


24415#undef JSON_INLINE_VARIABLE


24416#undef JSON_NO_UNIQUE_ADDRESS


24417#undef JSON_DISABLE_ENUM_SERIALIZATION


24418#undef JSON_USE_GLOBAL_UDLS


24419


24420#ifndef JSON_TEST_KEEP_MACROS


24421    #undef JSON_CATCH


24422    #undef JSON_TRY


24423    #undef JSON_HAS_CPP_11


24424    #undef JSON_HAS_CPP_14


24425    #undef JSON_HAS_CPP_17


24426    #undef JSON_HAS_CPP_20


24427    #undef JSON_HAS_FILESYSTEM


24428    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM


24429    #undef JSON_HAS_THREE_WAY_COMPARISON


24430    #undef JSON_HAS_RANGES


24431    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON


24432#endif


24433


24434// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>


24435//     __ _____ _____ _____


24436//  __|  |   __|     |   | |  JSON for Modern C++


24437// |  |  |__   |  |  | | | |  version 3.11.2


24438// |_____|_____|_____|_|___|  https://github.com/nlohmann/json


24439//


24440// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann <https://nlohmann.me>


24441// SPDX-License-Identifier: MIT


24442


24443


24444


24445#undef JSON_HEDLEY_ALWAYS_INLINE


24446#undef JSON_HEDLEY_ARM_VERSION


24447#undef JSON_HEDLEY_ARM_VERSION_CHECK


24448#undef JSON_HEDLEY_ARRAY_PARAM


24449#undef JSON_HEDLEY_ASSUME


24450#undef JSON_HEDLEY_BEGIN_C_DECLS


24451#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE


24452#undef JSON_HEDLEY_CLANG_HAS_BUILTIN


24453#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE


24454#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE


24455#undef JSON_HEDLEY_CLANG_HAS_EXTENSION


24456#undef JSON_HEDLEY_CLANG_HAS_FEATURE


24457#undef JSON_HEDLEY_CLANG_HAS_WARNING


24458#undef JSON_HEDLEY_COMPCERT_VERSION


24459#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK


24460#undef JSON_HEDLEY_CONCAT


24461#undef JSON_HEDLEY_CONCAT3


24462#undef JSON_HEDLEY_CONCAT3_EX


24463#undef JSON_HEDLEY_CONCAT_EX


24464#undef JSON_HEDLEY_CONST


24465#undef JSON_HEDLEY_CONSTEXPR


24466#undef JSON_HEDLEY_CONST_CAST


24467#undef JSON_HEDLEY_CPP_CAST


24468#undef JSON_HEDLEY_CRAY_VERSION


24469#undef JSON_HEDLEY_CRAY_VERSION_CHECK


24470#undef JSON_HEDLEY_C_DECL


24471#undef JSON_HEDLEY_DEPRECATED


24472#undef JSON_HEDLEY_DEPRECATED_FOR


24473#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL


24474#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_


24475#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED


24476#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES


24477#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS


24478#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION


24479#undef JSON_HEDLEY_DIAGNOSTIC_POP


24480#undef JSON_HEDLEY_DIAGNOSTIC_PUSH


24481#undef JSON_HEDLEY_DMC_VERSION


24482#undef JSON_HEDLEY_DMC_VERSION_CHECK


24483#undef JSON_HEDLEY_EMPTY_BASES


24484#undef JSON_HEDLEY_EMSCRIPTEN_VERSION


24485#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK


24486#undef JSON_HEDLEY_END_C_DECLS


24487#undef JSON_HEDLEY_FLAGS


24488#undef JSON_HEDLEY_FLAGS_CAST


24489#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE


24490#undef JSON_HEDLEY_GCC_HAS_BUILTIN


24491#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE


24492#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE


24493#undef JSON_HEDLEY_GCC_HAS_EXTENSION


24494#undef JSON_HEDLEY_GCC_HAS_FEATURE


24495#undef JSON_HEDLEY_GCC_HAS_WARNING


24496#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK


24497#undef JSON_HEDLEY_GCC_VERSION


24498#undef JSON_HEDLEY_GCC_VERSION_CHECK


24499#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE


24500#undef JSON_HEDLEY_GNUC_HAS_BUILTIN


24501#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE


24502#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE


24503#undef JSON_HEDLEY_GNUC_HAS_EXTENSION


24504#undef JSON_HEDLEY_GNUC_HAS_FEATURE


24505#undef JSON_HEDLEY_GNUC_HAS_WARNING


24506#undef JSON_HEDLEY_GNUC_VERSION


24507#undef JSON_HEDLEY_GNUC_VERSION_CHECK


24508#undef JSON_HEDLEY_HAS_ATTRIBUTE


24509#undef JSON_HEDLEY_HAS_BUILTIN


24510#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE


24511#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS


24512#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE


24513#undef JSON_HEDLEY_HAS_EXTENSION


24514#undef JSON_HEDLEY_HAS_FEATURE


24515#undef JSON_HEDLEY_HAS_WARNING


24516#undef JSON_HEDLEY_IAR_VERSION


24517#undef JSON_HEDLEY_IAR_VERSION_CHECK


24518#undef JSON_HEDLEY_IBM_VERSION


24519#undef JSON_HEDLEY_IBM_VERSION_CHECK


24520#undef JSON_HEDLEY_IMPORT


24521#undef JSON_HEDLEY_INLINE


24522#undef JSON_HEDLEY_INTEL_CL_VERSION


24523#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK


24524#undef JSON_HEDLEY_INTEL_VERSION


24525#undef JSON_HEDLEY_INTEL_VERSION_CHECK


24526#undef JSON_HEDLEY_IS_CONSTANT


24527#undef JSON_HEDLEY_IS_CONSTEXPR_


24528#undef JSON_HEDLEY_LIKELY


24529#undef JSON_HEDLEY_MALLOC


24530#undef JSON_HEDLEY_MCST_LCC_VERSION


24531#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK


24532#undef JSON_HEDLEY_MESSAGE


24533#undef JSON_HEDLEY_MSVC_VERSION


24534#undef JSON_HEDLEY_MSVC_VERSION_CHECK


24535#undef JSON_HEDLEY_NEVER_INLINE


24536#undef JSON_HEDLEY_NON_NULL


24537#undef JSON_HEDLEY_NO_ESCAPE


24538#undef JSON_HEDLEY_NO_RETURN


24539#undef JSON_HEDLEY_NO_THROW


24540#undef JSON_HEDLEY_NULL


24541#undef JSON_HEDLEY_PELLES_VERSION


24542#undef JSON_HEDLEY_PELLES_VERSION_CHECK


24543#undef JSON_HEDLEY_PGI_VERSION


24544#undef JSON_HEDLEY_PGI_VERSION_CHECK


24545#undef JSON_HEDLEY_PREDICT


24546#undef JSON_HEDLEY_PRINTF_FORMAT


24547#undef JSON_HEDLEY_PRIVATE


24548#undef JSON_HEDLEY_PUBLIC


24549#undef JSON_HEDLEY_PURE


24550#undef JSON_HEDLEY_REINTERPRET_CAST


24551#undef JSON_HEDLEY_REQUIRE


24552#undef JSON_HEDLEY_REQUIRE_CONSTEXPR


24553#undef JSON_HEDLEY_REQUIRE_MSG


24554#undef JSON_HEDLEY_RESTRICT


24555#undef JSON_HEDLEY_RETURNS_NON_NULL


24556#undef JSON_HEDLEY_SENTINEL


24557#undef JSON_HEDLEY_STATIC_ASSERT


24558#undef JSON_HEDLEY_STATIC_CAST


24559#undef JSON_HEDLEY_STRINGIFY


24560#undef JSON_HEDLEY_STRINGIFY_EX


24561#undef JSON_HEDLEY_SUNPRO_VERSION


24562#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK


24563#undef JSON_HEDLEY_TINYC_VERSION


24564#undef JSON_HEDLEY_TINYC_VERSION_CHECK


24565#undef JSON_HEDLEY_TI_ARMCL_VERSION


24566#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK


24567#undef JSON_HEDLEY_TI_CL2000_VERSION


24568#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK


24569#undef JSON_HEDLEY_TI_CL430_VERSION


24570#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK


24571#undef JSON_HEDLEY_TI_CL6X_VERSION


24572#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK


24573#undef JSON_HEDLEY_TI_CL7X_VERSION


24574#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK


24575#undef JSON_HEDLEY_TI_CLPRU_VERSION


24576#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK


24577#undef JSON_HEDLEY_TI_VERSION


24578#undef JSON_HEDLEY_TI_VERSION_CHECK


24579#undef JSON_HEDLEY_UNAVAILABLE


24580#undef JSON_HEDLEY_UNLIKELY


24581#undef JSON_HEDLEY_UNPREDICTABLE


24582#undef JSON_HEDLEY_UNREACHABLE


24583#undef JSON_HEDLEY_UNREACHABLE_RETURN


24584#undef JSON_HEDLEY_VERSION


24585#undef JSON_HEDLEY_VERSION_DECODE_MAJOR


24586#undef JSON_HEDLEY_VERSION_DECODE_MINOR


24587#undef JSON_HEDLEY_VERSION_DECODE_REVISION


24588#undef JSON_HEDLEY_VERSION_ENCODE


24589#undef JSON_HEDLEY_WARNING


24590#undef JSON_HEDLEY_WARN_UNUSED_RESULT


24591#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG


24592#undef JSON_HEDLEY_FALL_THROUGH


24593


24594


24595


24596#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/vendor/libtwittercpp b/vendor/libtwittercpp
deleted file mode 160000


Subproject d1d20515281e32b23657762e72bf37dcff14f0a

diff --git a/vendor/verbly b/vendor/verbly


Subproject 84bae572d353b03ecb3498df83ba301a456b6c6
Subproject 51d7ceb62c753479af08e49b023ef90ddac34aa
 

generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-11-21 20:03:05 +0000