move to json v3.6.1
diff --git a/third_party/include/nlohmann/json.hpp b/third_party/include/nlohmann/json.hpp
index 06da815..5003a4f 100644
--- a/third_party/include/nlohmann/json.hpp
+++ b/third_party/include/nlohmann/json.hpp
@@ -1,7 +1,7 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++
-| | |__ | | | | | | version 3.7.3
+| | |__ | | | | | | version 3.6.1
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
@@ -31,8 +31,8 @@
#define INCLUDE_NLOHMANN_JSON_HPP_
#define NLOHMANN_JSON_VERSION_MAJOR 3
-#define NLOHMANN_JSON_VERSION_MINOR 7
-#define NLOHMANN_JSON_VERSION_PATCH 3
+#define NLOHMANN_JSON_VERSION_MINOR 6
+#define NLOHMANN_JSON_VERSION_PATCH 1
#include <algorithm> // all_of, find, for_each
#include <cassert> // assert
@@ -105,1725 +105,6 @@
} // namespace detail
} // namespace nlohmann
-// #include <nlohmann/detail/macro_scope.hpp>
-
-
-#include <utility> // pair
-// #include <nlohmann/thirdparty/hedley/hedley.hpp>
-/* Hedley - https://nemequ.github.io/hedley
- * Created by Evan Nemerson <evan@nemerson.com>
- *
- * To the extent possible under law, the author(s) have dedicated all
- * copyright and related and neighboring rights to this software to
- * the public domain worldwide. This software is distributed without
- * any warranty.
- *
- * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
- * SPDX-License-Identifier: CC0-1.0
- */
-
-#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 11)
-#if defined(JSON_HEDLEY_VERSION)
- #undef JSON_HEDLEY_VERSION
-#endif
-#define JSON_HEDLEY_VERSION 11
-
-#if defined(JSON_HEDLEY_STRINGIFY_EX)
- #undef JSON_HEDLEY_STRINGIFY_EX
-#endif
-#define JSON_HEDLEY_STRINGIFY_EX(x) #x
-
-#if defined(JSON_HEDLEY_STRINGIFY)
- #undef JSON_HEDLEY_STRINGIFY
-#endif
-#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
-
-#if defined(JSON_HEDLEY_CONCAT_EX)
- #undef JSON_HEDLEY_CONCAT_EX
-#endif
-#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
-
-#if defined(JSON_HEDLEY_CONCAT)
- #undef JSON_HEDLEY_CONCAT
-#endif
-#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
-
-#if defined(JSON_HEDLEY_VERSION_ENCODE)
- #undef JSON_HEDLEY_VERSION_ENCODE
-#endif
-#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
- #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
- #undef JSON_HEDLEY_VERSION_DECODE_MINOR
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
-
-#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
- #undef JSON_HEDLEY_VERSION_DECODE_REVISION
-#endif
-#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
-
-#if defined(JSON_HEDLEY_GNUC_VERSION)
- #undef JSON_HEDLEY_GNUC_VERSION
-#endif
-#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
- #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
-#elif defined(__GNUC__)
- #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
- #undef JSON_HEDLEY_GNUC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_GNUC_VERSION)
- #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_MSVC_VERSION)
- #undef JSON_HEDLEY_MSVC_VERSION
-#endif
-#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
- #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
-#elif defined(_MSC_FULL_VER)
- #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
-#elif defined(_MSC_VER)
- #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
- #undef JSON_HEDLEY_MSVC_VERSION_CHECK
-#endif
-#if !defined(_MSC_VER)
- #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
- #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
-#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
- #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
-#else
- #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_VERSION)
- #undef JSON_HEDLEY_INTEL_VERSION
-#endif
-#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
- #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
-#elif defined(__INTEL_COMPILER)
- #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
- #undef JSON_HEDLEY_INTEL_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_INTEL_VERSION)
- #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_PGI_VERSION)
- #undef JSON_HEDLEY_PGI_VERSION
-#endif
-#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
- #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
-#endif
-
-#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
- #undef JSON_HEDLEY_PGI_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_PGI_VERSION)
- #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_SUNPRO_VERSION)
- #undef JSON_HEDLEY_SUNPRO_VERSION
-#endif
-#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
- #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)
-#elif defined(__SUNPRO_C)
- #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
-#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
- #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)
-#elif defined(__SUNPRO_CC)
- #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
-#endif
-
-#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
- #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_SUNPRO_VERSION)
- #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
- #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
-#endif
-#if defined(__EMSCRIPTEN__)
- #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
-#endif
-
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
- #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
- #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_ARM_VERSION)
- #undef JSON_HEDLEY_ARM_VERSION
-#endif
-#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
- #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
-#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
- #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
-#endif
-
-#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
- #undef JSON_HEDLEY_ARM_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_ARM_VERSION)
- #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_IBM_VERSION)
- #undef JSON_HEDLEY_IBM_VERSION
-#endif
-#if defined(__ibmxl__)
- #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
-#elif defined(__xlC__) && defined(__xlC_ver__)
- #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
-#elif defined(__xlC__)
- #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
-#endif
-
-#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
- #undef JSON_HEDLEY_IBM_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_IBM_VERSION)
- #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TI_VERSION)
- #undef JSON_HEDLEY_TI_VERSION
-#endif
-#if defined(__TI_COMPILER_VERSION__)
- #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
-#endif
-
-#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
- #undef JSON_HEDLEY_TI_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TI_VERSION)
- #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_CRAY_VERSION)
- #undef JSON_HEDLEY_CRAY_VERSION
-#endif
-#if defined(_CRAYC)
- #if defined(_RELEASE_PATCHLEVEL)
- #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
- #else
- #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
- #endif
-#endif
-
-#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
- #undef JSON_HEDLEY_CRAY_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_CRAY_VERSION)
- #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_IAR_VERSION)
- #undef JSON_HEDLEY_IAR_VERSION
-#endif
-#if defined(__IAR_SYSTEMS_ICC__)
- #if __VER__ > 1000
- #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
- #else
- #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
- #endif
-#endif
-
-#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
- #undef JSON_HEDLEY_IAR_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_IAR_VERSION)
- #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_TINYC_VERSION)
- #undef JSON_HEDLEY_TINYC_VERSION
-#endif
-#if defined(__TINYC__)
- #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
-#endif
-
-#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
- #undef JSON_HEDLEY_TINYC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_TINYC_VERSION)
- #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_DMC_VERSION)
- #undef JSON_HEDLEY_DMC_VERSION
-#endif
-#if defined(__DMC__)
- #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
-#endif
-
-#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
- #undef JSON_HEDLEY_DMC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_DMC_VERSION)
- #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_COMPCERT_VERSION)
- #undef JSON_HEDLEY_COMPCERT_VERSION
-#endif
-#if defined(__COMPCERT_VERSION__)
- #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
-#endif
-
-#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
- #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_COMPCERT_VERSION)
- #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_PELLES_VERSION)
- #undef JSON_HEDLEY_PELLES_VERSION
-#endif
-#if defined(__POCC__)
- #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
-#endif
-
-#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
- #undef JSON_HEDLEY_PELLES_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_PELLES_VERSION)
- #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_VERSION)
- #undef JSON_HEDLEY_GCC_VERSION
-#endif
-#if \
- defined(JSON_HEDLEY_GNUC_VERSION) && \
- !defined(__clang__) && \
- !defined(JSON_HEDLEY_INTEL_VERSION) && \
- !defined(JSON_HEDLEY_PGI_VERSION) && \
- !defined(JSON_HEDLEY_ARM_VERSION) && \
- !defined(JSON_HEDLEY_TI_VERSION) && \
- !defined(__COMPCERT__)
- #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
-#endif
-
-#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
- #undef JSON_HEDLEY_GCC_VERSION_CHECK
-#endif
-#if defined(JSON_HEDLEY_GCC_VERSION)
- #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
-#else
- #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
- #undef JSON_HEDLEY_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
- #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
-#else
- #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
- #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
- #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
-#else
- #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
- #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-#endif
-#if defined(__has_attribute)
- #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
-#else
- #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
- #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-#endif
-#if \
- defined(__has_cpp_attribute) && \
- defined(__cplusplus) && \
- (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
- #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
-#else
- #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
- #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#endif
-#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
- #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
-#elif \
- !defined(JSON_HEDLEY_PGI_VERSION) && \
- (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
- (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
- #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
-#else
- #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
- #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus)
- #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
-#else
- #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
- #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#endif
-#if defined(__has_cpp_attribute) && defined(__cplusplus)
- #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
-#else
- #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_BUILTIN)
- #undef JSON_HEDLEY_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
- #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
-#else
- #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
- #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
- #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
-#else
- #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
- #undef JSON_HEDLEY_GCC_HAS_BUILTIN
-#endif
-#if defined(__has_builtin)
- #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
-#else
- #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_FEATURE)
- #undef JSON_HEDLEY_HAS_FEATURE
-#endif
-#if defined(__has_feature)
- #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
-#else
- #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
- #undef JSON_HEDLEY_GNUC_HAS_FEATURE
-#endif
-#if defined(__has_feature)
- #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
-#else
- #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
- #undef JSON_HEDLEY_GCC_HAS_FEATURE
-#endif
-#if defined(__has_feature)
- #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
-#else
- #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_EXTENSION)
- #undef JSON_HEDLEY_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
- #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
-#else
- #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
- #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
- #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
-#else
- #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
- #undef JSON_HEDLEY_GCC_HAS_EXTENSION
-#endif
-#if defined(__has_extension)
- #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
-#else
- #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
- #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
- #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
-#else
- #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
- #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
- #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
-#else
- #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
- #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#endif
-#if defined(__has_declspec_attribute)
- #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
-#else
- #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_HAS_WARNING)
- #undef JSON_HEDLEY_HAS_WARNING
-#endif
-#if defined(__has_warning)
- #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
-#else
- #define JSON_HEDLEY_HAS_WARNING(warning) (0)
-#endif
-
-#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
- #undef JSON_HEDLEY_GNUC_HAS_WARNING
-#endif
-#if defined(__has_warning)
- #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
-#else
- #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
- #undef JSON_HEDLEY_GCC_HAS_WARNING
-#endif
-#if defined(__has_warning)
- #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
-#else
- #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
- HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
- #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#endif
-#if defined(__cplusplus) && JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
-# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
- xpr \
- JSON_HEDLEY_DIAGNOSTIC_POP
-#else
-# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
-#endif
-
-#if \
- (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
- defined(__clang__) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) || \
- JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
- JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
- #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
- #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
-#else
- #define JSON_HEDLEY_PRAGMA(value)
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
- #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
-#endif
-#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
- #undef JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-#if defined(__clang__)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
- #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
- #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
- #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
- #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
-#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
- #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(8,1,0)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
- #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
- #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
-#else
- #define JSON_HEDLEY_DIAGNOSTIC_PUSH
- #define JSON_HEDLEY_DIAGNOSTIC_POP
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
- #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
-#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
-#else
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
- #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
-#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
-#else
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
- #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
-#else
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#endif
-
-#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
- #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
-#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
-#else
- #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#endif
-
-#if defined(JSON_HEDLEY_DEPRECATED)
- #undef JSON_HEDLEY_DEPRECATED
-#endif
-#if defined(JSON_HEDLEY_DEPRECATED_FOR)
- #undef JSON_HEDLEY_DEPRECATED_FOR
-#endif
-#if defined(__cplusplus) && (__cplusplus >= 201402L)
- #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
-#elif \
- JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,3,0)
- #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
-#elif \
- JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
- #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
-#elif \
- JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
- JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
- #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
-#else
- #define JSON_HEDLEY_DEPRECATED(since)
- #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
-#endif
-
-#if defined(JSON_HEDLEY_UNAVAILABLE)
- #undef JSON_HEDLEY_UNAVAILABLE
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
-#else
- #define JSON_HEDLEY_UNAVAILABLE(available_since)
-#endif
-
-#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
- #undef JSON_HEDLEY_WARN_UNUSED_RESULT
-#endif
-#if defined(__cplusplus) && (__cplusplus >= 201703L)
- #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
-#elif \
- JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
- (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
- #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
-#elif defined(_Check_return_) /* SAL */
- #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
-#else
- #define JSON_HEDLEY_WARN_UNUSED_RESULT
-#endif
-
-#if defined(JSON_HEDLEY_SENTINEL)
- #undef JSON_HEDLEY_SENTINEL
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
- #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
-#else
- #define JSON_HEDLEY_SENTINEL(position)
-#endif
-
-#if defined(JSON_HEDLEY_NO_RETURN)
- #undef JSON_HEDLEY_NO_RETURN
-#endif
-#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_NO_RETURN __noreturn
-#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
-#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
- #define JSON_HEDLEY_NO_RETURN _Noreturn
-#elif defined(__cplusplus) && (__cplusplus >= 201103L)
- #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
-#elif \
- JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(18,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(17,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
- #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
- #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
-#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
- #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
-#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
- #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
- #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
-#else
- #define JSON_HEDLEY_NO_RETURN
-#endif
-
-#if defined(JSON_HEDLEY_NO_ESCAPE)
- #undef JSON_HEDLEY_NO_ESCAPE
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
- #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
-#else
- #define JSON_HEDLEY_NO_ESCAPE
-#endif
-
-#if defined(JSON_HEDLEY_UNREACHABLE)
- #undef JSON_HEDLEY_UNREACHABLE
-#endif
-#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
- #undef JSON_HEDLEY_UNREACHABLE_RETURN
-#endif
-#if \
- (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
- #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
- #define JSON_HEDLEY_UNREACHABLE() __assume(0)
-#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
- #if defined(__cplusplus)
- #define JSON_HEDLEY_UNREACHABLE() std::_nassert(0)
- #else
- #define JSON_HEDLEY_UNREACHABLE() _nassert(0)
- #endif
- #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
-#elif defined(EXIT_FAILURE)
- #define JSON_HEDLEY_UNREACHABLE() abort()
-#else
- #define JSON_HEDLEY_UNREACHABLE()
- #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
-#endif
-#if !defined(JSON_HEDLEY_UNREACHABLE_RETURN)
- #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
-#endif
-
-#if defined(JSON_HEDLEY_ASSUME)
- #undef JSON_HEDLEY_ASSUME
-#endif
-#if \
- JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
-#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
- #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
-#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
- #if defined(__cplusplus)
- #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
- #else
- #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
- #endif
-#elif \
- (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && !defined(JSON_HEDLEY_ARM_VERSION)) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
- #define JSON_HEDLEY_ASSUME(expr) ((void) ((expr) ? 1 : (__builtin_unreachable(), 1)))
-#else
- #define JSON_HEDLEY_ASSUME(expr) ((void) (expr))
-#endif
-
-JSON_HEDLEY_DIAGNOSTIC_PUSH
-#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
- #pragma clang diagnostic ignored "-Wpedantic"
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
- #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
-#endif
-#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
- #if defined(__clang__)
- #pragma clang diagnostic ignored "-Wvariadic-macros"
- #elif defined(JSON_HEDLEY_GCC_VERSION)
- #pragma GCC diagnostic ignored "-Wvariadic-macros"
- #endif
-#endif
-#if defined(JSON_HEDLEY_NON_NULL)
- #undef JSON_HEDLEY_NON_NULL
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
- #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
-#else
- #define JSON_HEDLEY_NON_NULL(...)
-#endif
-JSON_HEDLEY_DIAGNOSTIC_POP
-
-#if defined(JSON_HEDLEY_PRINTF_FORMAT)
- #undef JSON_HEDLEY_PRINTF_FORMAT
-#endif
-#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
- #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
-#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
- #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
-#elif \
- JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
- #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
-#else
- #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
-#endif
-
-#if defined(JSON_HEDLEY_CONSTEXPR)
- #undef JSON_HEDLEY_CONSTEXPR
-#endif
-#if defined(__cplusplus)
- #if __cplusplus >= 201103L
- #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
- #endif
-#endif
-#if !defined(JSON_HEDLEY_CONSTEXPR)
- #define JSON_HEDLEY_CONSTEXPR
-#endif
-
-#if defined(JSON_HEDLEY_PREDICT)
- #undef JSON_HEDLEY_PREDICT
-#endif
-#if defined(JSON_HEDLEY_LIKELY)
- #undef JSON_HEDLEY_LIKELY
-#endif
-#if defined(JSON_HEDLEY_UNLIKELY)
- #undef JSON_HEDLEY_UNLIKELY
-#endif
-#if defined(JSON_HEDLEY_UNPREDICTABLE)
- #undef JSON_HEDLEY_UNPREDICTABLE
-#endif
-#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
- #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable(!!(expr))
-#endif
-#if \
- JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
-# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(expr, value, probability)
-# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1, probability)
-# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0, probability)
-# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
-# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#if !defined(JSON_HEDLEY_BUILTIN_UNPREDICTABLE)
- #define JSON_HEDLEY_BUILTIN_UNPREDICTABLE(expr) __builtin_expect_with_probability(!!(expr), 1, 0.5)
-#endif
-#elif \
- JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
- JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27)
-# define JSON_HEDLEY_PREDICT(expr, expected, probability) \
- (((probability) >= 0.9) ? __builtin_expect(!!(expr), (expected)) : (((void) (expected)), !!(expr)))
-# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
- (__extension__ ({ \
- JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
- ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
- }))
-# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
- (__extension__ ({ \
- JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
- ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
- }))
-# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
-# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
-#else
-# define JSON_HEDLEY_PREDICT(expr, expected, probability) (((void) (expected)), !!(expr))
-# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
-# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
-# define JSON_HEDLEY_LIKELY(expr) (!!(expr))
-# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
-#endif
-#if !defined(JSON_HEDLEY_UNPREDICTABLE)
- #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
-#endif
-
-#if defined(JSON_HEDLEY_MALLOC)
- #undef JSON_HEDLEY_MALLOC
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
- #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
- #define JSON_HEDLEY_MALLOC __declspec(restrict)
-#else
- #define JSON_HEDLEY_MALLOC
-#endif
-
-#if defined(JSON_HEDLEY_PURE)
- #undef JSON_HEDLEY_PURE
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
- #define JSON_HEDLEY_PURE __attribute__((__pure__))
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
- #define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
- #define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
-#else
- #define JSON_HEDLEY_PURE
-#endif
-
-#if defined(JSON_HEDLEY_CONST)
- #undef JSON_HEDLEY_CONST
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
- #define JSON_HEDLEY_CONST __attribute__((__const__))
-#elif \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
- #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
-#else
- #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
-#endif
-
-#if defined(JSON_HEDLEY_RESTRICT)
- #undef JSON_HEDLEY_RESTRICT
-#endif
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
- #define JSON_HEDLEY_RESTRICT restrict
-#elif \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
- JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
- JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
- defined(__clang__)
- #define JSON_HEDLEY_RESTRICT __restrict
-#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
- #define JSON_HEDLEY_RESTRICT _Restrict
-#else
- #define JSON_HEDLEY_RESTRICT
-#endif
-
-#if defined(JSON_HEDLEY_INLINE)
- #undef JSON_HEDLEY_INLINE
-#endif
-#if \
- (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
- (defined(__cplusplus) && (__cplusplus >= 199711L))
- #define JSON_HEDLEY_INLINE inline
-#elif \
- defined(JSON_HEDLEY_GCC_VERSION) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
- #define JSON_HEDLEY_INLINE __inline__
-#elif \
- JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_INLINE __inline
-#else
- #define JSON_HEDLEY_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_ALWAYS_INLINE)
- #undef JSON_HEDLEY_ALWAYS_INLINE
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
- #define JSON_HEDLEY_ALWAYS_INLINE __forceinline
-#elif JSON_HEDLEY_TI_VERSION_CHECK(7,0,0) && defined(__cplusplus)
- #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
-#else
- #define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_NEVER_INLINE)
- #undef JSON_HEDLEY_NEVER_INLINE
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
- #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
-#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
- #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
-#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
- #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
- #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
-#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
- #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
- #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
-#else
- #define JSON_HEDLEY_NEVER_INLINE
-#endif
-
-#if defined(JSON_HEDLEY_PRIVATE)
- #undef JSON_HEDLEY_PRIVATE
-#endif
-#if defined(JSON_HEDLEY_PUBLIC)
- #undef JSON_HEDLEY_PUBLIC
-#endif
-#if defined(JSON_HEDLEY_IMPORT)
- #undef JSON_HEDLEY_IMPORT
-#endif
-#if defined(_WIN32) || defined(__CYGWIN__)
- #define JSON_HEDLEY_PRIVATE
- #define JSON_HEDLEY_PUBLIC __declspec(dllexport)
- #define JSON_HEDLEY_IMPORT __declspec(dllimport)
-#else
- #if \
- JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
- JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
- (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_EABI__) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
- #define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
- #define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
- #else
- #define JSON_HEDLEY_PRIVATE
- #define JSON_HEDLEY_PUBLIC
- #endif
- #define JSON_HEDLEY_IMPORT extern
-#endif
-
-#if defined(JSON_HEDLEY_NO_THROW)
- #undef JSON_HEDLEY_NO_THROW
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
- #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
-#elif \
- JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
- #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
-#else
- #define JSON_HEDLEY_NO_THROW
-#endif
-
-#if defined(JSON_HEDLEY_FALL_THROUGH)
- #undef JSON_HEDLEY_FALL_THROUGH
-#endif
-#if JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(fallthrough,7,0,0) && !defined(JSON_HEDLEY_PGI_VERSION)
- #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
- #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
-#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
- #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
-#elif defined(__fallthrough) /* SAL */
- #define JSON_HEDLEY_FALL_THROUGH __fallthrough
-#else
- #define JSON_HEDLEY_FALL_THROUGH
-#endif
-
-#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
- #undef JSON_HEDLEY_RETURNS_NON_NULL
-#endif
-#if \
- JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
- #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
-#elif defined(_Ret_notnull_) /* SAL */
- #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
-#else
- #define JSON_HEDLEY_RETURNS_NON_NULL
-#endif
-
-#if defined(JSON_HEDLEY_ARRAY_PARAM)
- #undef JSON_HEDLEY_ARRAY_PARAM
-#endif
-#if \
- defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
- !defined(__STDC_NO_VLA__) && \
- !defined(__cplusplus) && \
- !defined(JSON_HEDLEY_PGI_VERSION) && \
- !defined(JSON_HEDLEY_TINYC_VERSION)
- #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
-#else
- #define JSON_HEDLEY_ARRAY_PARAM(name)
-#endif
-
-#if defined(JSON_HEDLEY_IS_CONSTANT)
- #undef JSON_HEDLEY_IS_CONSTANT
-#endif
-#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
- #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
-#endif
-/* JSON_HEDLEY_IS_CONSTEXPR_ is for
- HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
-#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
- #undef JSON_HEDLEY_IS_CONSTEXPR_
-#endif
-#if \
- JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
- JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
- (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
- JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
- #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
-#endif
-#if !defined(__cplusplus)
-# if \
- JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
- JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
- JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
-#if defined(__INTPTR_TYPE__)
- #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
-#else
- #include <stdint.h>
- #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
-#endif
-# elif \
- (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(JSON_HEDLEY_SUNPRO_VERSION) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
- JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
- JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
- JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
-#if defined(__INTPTR_TYPE__)
- #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
-#else
- #include <stdint.h>
- #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
-#endif
-# elif \
- defined(JSON_HEDLEY_GCC_VERSION) || \
- defined(JSON_HEDLEY_INTEL_VERSION) || \
- defined(JSON_HEDLEY_TINYC_VERSION) || \
- defined(JSON_HEDLEY_TI_VERSION) || \
- defined(__clang__)
-# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
- sizeof(void) != \
- sizeof(*( \
- 1 ? \
- ((void*) ((expr) * 0L) ) : \
-((struct { char v[sizeof(void) * 2]; } *) 1) \
- ) \
- ) \
- )
-# endif
-#endif
-#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
- #if !defined(JSON_HEDLEY_IS_CONSTANT)
- #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
- #endif
- #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
-#else
- #if !defined(JSON_HEDLEY_IS_CONSTANT)
- #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
- #endif
- #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
-#endif
-
-#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
- #undef JSON_HEDLEY_BEGIN_C_DECLS
-#endif
-#if defined(JSON_HEDLEY_END_C_DECLS)
- #undef JSON_HEDLEY_END_C_DECLS
-#endif
-#if defined(JSON_HEDLEY_C_DECL)
- #undef JSON_HEDLEY_C_DECL
-#endif
-#if defined(__cplusplus)
- #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
- #define JSON_HEDLEY_END_C_DECLS }
- #define JSON_HEDLEY_C_DECL extern "C"
-#else
- #define JSON_HEDLEY_BEGIN_C_DECLS
- #define JSON_HEDLEY_END_C_DECLS
- #define JSON_HEDLEY_C_DECL
-#endif
-
-#if defined(JSON_HEDLEY_STATIC_ASSERT)
- #undef JSON_HEDLEY_STATIC_ASSERT
-#endif
-#if \
- !defined(__cplusplus) && ( \
- (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
- JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
- JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
- defined(_Static_assert) \
- )
-# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
-#elif \
- (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
- JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
- (defined(__cplusplus) && JSON_HEDLEY_TI_VERSION_CHECK(8,3,0))
-# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
-#else
-# define JSON_HEDLEY_STATIC_ASSERT(expr, message)
-#endif
-
-#if defined(JSON_HEDLEY_CONST_CAST)
- #undef JSON_HEDLEY_CONST_CAST
-#endif
-#if defined(__cplusplus)
-# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
-#elif \
- JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
- ((T) (expr)); \
- JSON_HEDLEY_DIAGNOSTIC_POP \
- }))
-#else
-# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
-#endif
-
-#if defined(JSON_HEDLEY_REINTERPRET_CAST)
- #undef JSON_HEDLEY_REINTERPRET_CAST
-#endif
-#if defined(__cplusplus)
- #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
-#else
- #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (*((T*) &(expr)))
-#endif
-
-#if defined(JSON_HEDLEY_STATIC_CAST)
- #undef JSON_HEDLEY_STATIC_CAST
-#endif
-#if defined(__cplusplus)
- #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
-#else
- #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
-#endif
-
-#if defined(JSON_HEDLEY_CPP_CAST)
- #undef JSON_HEDLEY_CPP_CAST
-#endif
-#if defined(__cplusplus)
- #define JSON_HEDLEY_CPP_CAST(T, expr) static_cast<T>(expr)
-#else
- #define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
-#endif
-
-#if defined(JSON_HEDLEY_NULL)
- #undef JSON_HEDLEY_NULL
-#endif
-#if defined(__cplusplus)
- #if __cplusplus >= 201103L
- #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
- #elif defined(NULL)
- #define JSON_HEDLEY_NULL NULL
- #else
- #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
- #endif
-#elif defined(NULL)
- #define JSON_HEDLEY_NULL NULL
-#else
- #define JSON_HEDLEY_NULL ((void*) 0)
-#endif
-
-#if defined(JSON_HEDLEY_MESSAGE)
- #undef JSON_HEDLEY_MESSAGE
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-# define JSON_HEDLEY_MESSAGE(msg) \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
- JSON_HEDLEY_PRAGMA(message msg) \
- JSON_HEDLEY_DIAGNOSTIC_POP
-#elif \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
- JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
-# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
-#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
-# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
-#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
-# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
-# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#else
-# define JSON_HEDLEY_MESSAGE(msg)
-#endif
-
-#if defined(JSON_HEDLEY_WARNING)
- #undef JSON_HEDLEY_WARNING
-#endif
-#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
-# define JSON_HEDLEY_WARNING(msg) \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
- JSON_HEDLEY_PRAGMA(clang warning msg) \
- JSON_HEDLEY_DIAGNOSTIC_POP
-#elif \
- JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
- JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0)
-# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
-#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
-# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
-#else
-# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
-#endif
-
-#if defined(JSON_HEDLEY_REQUIRE)
- #undef JSON_HEDLEY_REQUIRE
-#endif
-#if defined(JSON_HEDLEY_REQUIRE_MSG)
- #undef JSON_HEDLEY_REQUIRE_MSG
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
-# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
-# define JSON_HEDLEY_REQUIRE(expr) \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
- __attribute__((diagnose_if(!(expr), #expr, "error"))) \
- JSON_HEDLEY_DIAGNOSTIC_POP
-# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
- __attribute__((diagnose_if(!(expr), msg, "error"))) \
- JSON_HEDLEY_DIAGNOSTIC_POP
-# else
-# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
-# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
-# endif
-#else
-# define JSON_HEDLEY_REQUIRE(expr)
-# define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
-#endif
-
-#if defined(JSON_HEDLEY_FLAGS)
- #undef JSON_HEDLEY_FLAGS
-#endif
-#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
- #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
-#endif
-
-#if defined(JSON_HEDLEY_FLAGS_CAST)
- #undef JSON_HEDLEY_FLAGS_CAST
-#endif
-#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
-# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
- JSON_HEDLEY_DIAGNOSTIC_PUSH \
- _Pragma("warning(disable:188)") \
- ((T) (expr)); \
- JSON_HEDLEY_DIAGNOSTIC_POP \
- }))
-#else
-# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
-#endif
-
-#if defined(JSON_HEDLEY_EMPTY_BASES)
- #undef JSON_HEDLEY_EMPTY_BASES
-#endif
-#if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
- #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
-#else
- #define JSON_HEDLEY_EMPTY_BASES
-#endif
-
-/* Remaining macros are deprecated. */
-
-#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
- #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#endif
-#if defined(__clang__)
- #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
-#else
- #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
-#endif
-
-#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
- #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
- #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
- #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
-#endif
-#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
- #undef JSON_HEDLEY_CLANG_HAS_FEATURE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
- #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
-#endif
-#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
- #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
-#endif
-#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
-
-#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
- #undef JSON_HEDLEY_CLANG_HAS_WARNING
-#endif
-#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
-
-#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
-
-
-// This file contains all internal macro definitions
-// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
-
-// exclude unsupported compilers
-#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
- #if defined(__clang__)
- #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
- #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
- #endif
- #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
- #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
- #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
- #endif
- #endif
-#endif
-
-// C++ language standard detection
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
- #define JSON_HAS_CPP_17
- #define JSON_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
- #define JSON_HAS_CPP_14
-#endif
-
-// disable float-equal warnings on GCC/clang
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-
-// disable documentation warnings on clang
-#if defined(__clang__)
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wdocumentation"
-#endif
-
-// allow to disable exceptions
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
- #define JSON_THROW(exception) throw exception
- #define JSON_TRY try
- #define JSON_CATCH(exception) catch(exception)
- #define JSON_INTERNAL_CATCH(exception) catch(exception)
-#else
- #include <cstdlib>
- #define JSON_THROW(exception) std::abort()
- #define JSON_TRY if(true)
- #define JSON_CATCH(exception) if(false)
- #define JSON_INTERNAL_CATCH(exception) if(false)
-#endif
-
-// override exception macros
-#if defined(JSON_THROW_USER)
- #undef JSON_THROW
- #define JSON_THROW JSON_THROW_USER
-#endif
-#if defined(JSON_TRY_USER)
- #undef JSON_TRY
- #define JSON_TRY JSON_TRY_USER
-#endif
-#if defined(JSON_CATCH_USER)
- #undef JSON_CATCH
- #define JSON_CATCH JSON_CATCH_USER
- #undef JSON_INTERNAL_CATCH
- #define JSON_INTERNAL_CATCH JSON_CATCH_USER
-#endif
-#if defined(JSON_INTERNAL_CATCH_USER)
- #undef JSON_INTERNAL_CATCH
- #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
-#endif
-
-/*!
-@brief macro to briefly define a mapping between an enum and JSON
-@def NLOHMANN_JSON_SERIALIZE_ENUM
-@since version 3.4.0
-*/
-#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
- template<typename BasicJsonType> \
- inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
- { \
- static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
- static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
- auto it = std::find_if(std::begin(m), std::end(m), \
- [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
- { \
- return ej_pair.first == e; \
- }); \
- j = ((it != std::end(m)) ? it : std::begin(m))->second; \
- } \
- template<typename BasicJsonType> \
- inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
- { \
- static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
- static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
- auto it = std::find_if(std::begin(m), std::end(m), \
- [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
- { \
- return ej_pair.second == j; \
- }); \
- e = ((it != std::end(m)) ? it : std::begin(m))->first; \
- }
-
-// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
-// may be removed in the future once the class is split.
-
-#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
- template<template<typename, typename, typename...> class ObjectType, \
- template<typename, typename...> class ArrayType, \
- class StringType, class BooleanType, class NumberIntegerType, \
- class NumberUnsignedType, class NumberFloatType, \
- template<typename> class AllocatorType, \
- template<typename, typename = void> class JSONSerializer>
-
-#define NLOHMANN_BASIC_JSON_TPL \
- basic_json<ObjectType, ArrayType, StringType, BooleanType, \
- NumberIntegerType, NumberUnsignedType, NumberFloatType, \
- AllocatorType, JSONSerializer>
-
namespace nlohmann
{
@@ -1865,7 +146,6 @@
{
public:
/// returns the explanatory string
- JSON_HEDLEY_RETURNS_NON_NULL
const char* what() const noexcept override
{
return m.what();
@@ -1875,7 +155,6 @@
const int id;
protected:
- JSON_HEDLEY_NON_NULL(3)
exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
static std::string name(const std::string& ename, int id_)
@@ -2028,7 +307,6 @@
}
private:
- JSON_HEDLEY_NON_NULL(3)
invalid_iterator(int id_, const char* what_arg)
: exception(id_, what_arg) {}
};
@@ -2082,7 +360,6 @@
}
private:
- JSON_HEDLEY_NON_NULL(3)
type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
};
@@ -2129,7 +406,6 @@
}
private:
- JSON_HEDLEY_NON_NULL(3)
out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
};
@@ -2167,7 +443,6 @@
}
private:
- JSON_HEDLEY_NON_NULL(3)
other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
};
} // namespace detail
@@ -2175,6 +450,157 @@
// #include <nlohmann/detail/macro_scope.hpp>
+
+#include <utility> // pair
+
+// This file contains all internal macro definitions
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+ #if defined(__clang__)
+ #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+ #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+ #endif
+ #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+ #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+ #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+ #endif
+ #endif
+#endif
+
+// disable float-equal warnings on GCC/clang
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wdocumentation"
+#endif
+
+// allow for portable deprecation warnings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+ #define JSON_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+ #define JSON_DEPRECATED __declspec(deprecated)
+#else
+ #define JSON_DEPRECATED
+#endif
+
+// allow for portable nodiscard warnings
+#if defined(__has_cpp_attribute)
+ #if __has_cpp_attribute(nodiscard)
+ #define JSON_NODISCARD [[nodiscard]]
+ #elif __has_cpp_attribute(gnu::warn_unused_result)
+ #define JSON_NODISCARD [[gnu::warn_unused_result]]
+ #else
+ #define JSON_NODISCARD
+ #endif
+#else
+ #define JSON_NODISCARD
+#endif
+
+// allow to disable exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+ #define JSON_THROW(exception) throw exception
+ #define JSON_TRY try
+ #define JSON_CATCH(exception) catch(exception)
+ #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+ #include <cstdlib>
+ #define JSON_THROW(exception) std::abort()
+ #define JSON_TRY if(true)
+ #define JSON_CATCH(exception) if(false)
+ #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+ #undef JSON_THROW
+ #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+ #undef JSON_TRY
+ #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+ #undef JSON_CATCH
+ #define JSON_CATCH JSON_CATCH_USER
+ #undef JSON_INTERNAL_CATCH
+ #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+ #undef JSON_INTERNAL_CATCH
+ #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// manual branch prediction
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+ #define JSON_LIKELY(x) __builtin_expect(x, 1)
+ #define JSON_UNLIKELY(x) __builtin_expect(x, 0)
+#else
+ #define JSON_LIKELY(x) x
+ #define JSON_UNLIKELY(x) x
+#endif
+
+// C++ language standard detection
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+ #define JSON_HAS_CPP_17
+ #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+ #define JSON_HAS_CPP_14
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
+ template<typename BasicJsonType> \
+ inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
+ { \
+ static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
+ static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
+ auto it = std::find_if(std::begin(m), std::end(m), \
+ [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+ { \
+ return ej_pair.first == e; \
+ }); \
+ j = ((it != std::end(m)) ? it : std::begin(m))->second; \
+ } \
+ template<typename BasicJsonType> \
+ inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
+ { \
+ static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
+ static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
+ auto it = std::find_if(std::begin(m), std::end(m), \
+ [j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+ { \
+ return ej_pair.second == j; \
+ }); \
+ e = ((it != std::end(m)) ? it : std::begin(m))->first; \
+ }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
+ template<template<typename, typename, typename...> class ObjectType, \
+ template<typename, typename...> class ArrayType, \
+ class StringType, class BooleanType, class NumberIntegerType, \
+ class NumberUnsignedType, class NumberFloatType, \
+ template<typename> class AllocatorType, \
+ template<typename, typename = void> class JSONSerializer>
+
+#define NLOHMANN_BASIC_JSON_TPL \
+ basic_json<ObjectType, ArrayType, StringType, BooleanType, \
+ NumberIntegerType, NumberUnsignedType, NumberFloatType, \
+ AllocatorType, JSONSerializer>
+
// #include <nlohmann/detail/meta/cpp_future.hpp>
@@ -2629,19 +1055,10 @@
using object_t = typename BasicJsonType::object_t;
static constexpr bool value =
- (std::is_default_constructible<ConstructibleObjectType>::value and
- (std::is_move_assignable<ConstructibleObjectType>::value or
- std::is_copy_assignable<ConstructibleObjectType>::value) and
- (std::is_constructible<typename ConstructibleObjectType::key_type,
- typename object_t::key_type>::value and
- std::is_same <
- typename object_t::mapped_type,
- typename ConstructibleObjectType::mapped_type >::value)) or
- (has_from_json<BasicJsonType,
- typename ConstructibleObjectType::mapped_type>::value or
- has_non_default_from_json <
- BasicJsonType,
- typename ConstructibleObjectType::mapped_type >::value);
+ (std::is_constructible<typename ConstructibleObjectType::key_type, typename object_t::key_type>::value and
+ std::is_same<typename object_t::mapped_type, typename ConstructibleObjectType::mapped_type>::value) or
+ (has_from_json<BasicJsonType, typename ConstructibleObjectType::mapped_type>::value or
+ has_non_default_from_json<BasicJsonType, typename ConstructibleObjectType::mapped_type >::value);
};
template <typename BasicJsonType, typename ConstructibleObjectType>
@@ -2724,24 +1141,20 @@
BasicJsonType, ConstructibleArrayType,
enable_if_t<not std::is_same<ConstructibleArrayType,
typename BasicJsonType::value_type>::value and
- std::is_default_constructible<ConstructibleArrayType>::value and
-(std::is_move_assignable<ConstructibleArrayType>::value or
- std::is_copy_assignable<ConstructibleArrayType>::value) and
-is_detected<value_type_t, ConstructibleArrayType>::value and
-is_detected<iterator_t, ConstructibleArrayType>::value and
-is_complete_type<
-detected_t<value_type_t, ConstructibleArrayType>>::value >>
+ is_detected<value_type_t, ConstructibleArrayType>::value and
+ is_detected<iterator_t, ConstructibleArrayType>::value and
+ is_complete_type<
+ detected_t<value_type_t, ConstructibleArrayType>>::value >>
{
static constexpr bool value =
// This is needed because json_reverse_iterator has a ::iterator type,
- // furthermore, std::back_insert_iterator (and other iterators) have a
- // base class `iterator`... Therefore it is detected as a
- // ConstructibleArrayType. The real fix would be to have an Iterable
- // concept.
- not is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value and
+ // furthermore, std::back_insert_iterator (and other iterators) have a base class `iterator`...
+ // Therefore it is detected as a ConstructibleArrayType.
+ // The real fix would be to have an Iterable concept.
+ not is_iterator_traits <
+ iterator_traits<ConstructibleArrayType >>::value and
- (std::is_same<typename ConstructibleArrayType::value_type,
- typename BasicJsonType::array_t::value_type>::value or
+ (std::is_same<typename ConstructibleArrayType::value_type, typename BasicJsonType::array_t::value_type>::value or
has_from_json<BasicJsonType,
typename ConstructibleArrayType::value_type>::value or
has_non_default_from_json <
@@ -2794,19 +1207,6 @@
template <typename BasicJsonType, typename CompatibleType>
struct is_compatible_type
: is_compatible_type_impl<BasicJsonType, CompatibleType> {};
-
-// https://en.cppreference.com/w/cpp/types/conjunction
-template<class...> struct conjunction : std::true_type { };
-template<class B1> struct conjunction<B1> : B1 { };
-template<class B1, class... Bn>
-struct conjunction<B1, Bn...>
-: std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
-
-template <typename T1, typename T2>
-struct is_constructible_tuple : std::false_type {};
-
-template <typename T1, typename... Args>
-struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
} // namespace detail
} // namespace nlohmann
@@ -2897,7 +1297,7 @@
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
+ if (JSON_UNLIKELY(not j.is_null()))
{
JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
}
@@ -2937,7 +1337,7 @@
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
+ if (JSON_UNLIKELY(not j.is_boolean()))
{
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
}
@@ -2947,7 +1347,7 @@
template<typename BasicJsonType>
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+ if (JSON_UNLIKELY(not j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
@@ -2963,7 +1363,7 @@
int > = 0 >
void from_json(const BasicJsonType& j, ConstructibleStringType& s)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+ if (JSON_UNLIKELY(not j.is_string()))
{
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
}
@@ -3003,11 +1403,10 @@
enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
- l.clear();
std::transform(j.rbegin(), j.rend(),
std::front_inserter(l), [](const BasicJsonType & i)
{
@@ -3020,22 +1419,12 @@
enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
void from_json(const BasicJsonType& j, std::valarray<T>& l)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
l.resize(j.size());
- std::copy(j.begin(), j.end(), std::begin(l));
-}
-
-template <typename BasicJsonType, typename T, std::size_t N>
-auto from_json(const BasicJsonType& j, T (&arr)[N])
--> decltype(j.template get<T>(), void())
-{
- for (std::size_t i = 0; i < N; ++i)
- {
- arr[i] = j.at(i).template get<T>();
- }
+ std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
}
template<typename BasicJsonType>
@@ -3064,16 +1453,14 @@
{
using std::end;
- ConstructibleArrayType ret;
- ret.reserve(j.size());
+ arr.reserve(j.size());
std::transform(j.begin(), j.end(),
- std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+ std::inserter(arr, end(arr)), [](const BasicJsonType & i)
{
// get<BasicJsonType>() returns *this, this won't call a from_json
// method when value_type is BasicJsonType
return i.template get<typename ConstructibleArrayType::value_type>();
});
- arr = std::move(ret);
}
template <typename BasicJsonType, typename ConstructibleArrayType>
@@ -3082,16 +1469,14 @@
{
using std::end;
- ConstructibleArrayType ret;
std::transform(
- j.begin(), j.end(), std::inserter(ret, end(ret)),
+ j.begin(), j.end(), std::inserter(arr, end(arr)),
[](const BasicJsonType & i)
{
// get<BasicJsonType>() returns *this, this won't call a from_json
// method when value_type is BasicJsonType
return i.template get<typename ConstructibleArrayType::value_type>();
});
- arr = std::move(ret);
}
template <typename BasicJsonType, typename ConstructibleArrayType,
@@ -3107,7 +1492,7 @@
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " +
std::string(j.type_name())));
@@ -3120,22 +1505,20 @@
enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+ if (JSON_UNLIKELY(not j.is_object()))
{
JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
}
- ConstructibleObjectType ret;
auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
using value_type = typename ConstructibleObjectType::value_type;
std::transform(
inner_object->begin(), inner_object->end(),
- std::inserter(ret, ret.begin()),
+ std::inserter(obj, obj.begin()),
[](typename BasicJsonType::object_t::value_type const & p)
{
return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
});
- obj = std::move(ret);
}
// overload for arithmetic types, not chosen for basic_json template arguments
@@ -3203,14 +1586,13 @@
typename BasicJsonType::string_t, Key>::value>>
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
- m.clear();
for (const auto& p : j)
{
- if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+ if (JSON_UNLIKELY(not p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
@@ -3223,14 +1605,13 @@
typename BasicJsonType::string_t, Key>::value>>
void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
{
- if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+ if (JSON_UNLIKELY(not j.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
}
- m.clear();
for (const auto& p : j)
{
- if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+ if (JSON_UNLIKELY(not p.is_array()))
{
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
}
@@ -3257,7 +1638,7 @@
{
constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
} // namespace
-} // namespace nlohmann
+} // namespace nlohmann
// #include <nlohmann/detail/conversions/to_json.hpp>
@@ -3289,11 +1670,6 @@
{
namespace detail
{
-template<typename string_type>
-void int_to_string( string_type& target, std::size_t value )
-{
- target = std::to_string(value);
-}
template <typename IteratorType> class iteration_proxy_value
{
public:
@@ -3302,7 +1678,6 @@
using pointer = value_type * ;
using reference = value_type & ;
using iterator_category = std::input_iterator_tag;
- using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
private:
/// the iterator
@@ -3312,9 +1687,9 @@
/// last stringified array index
mutable std::size_t array_index_last = 0;
/// a string representation of the array index
- mutable string_type array_index_str = "0";
+ mutable std::string array_index_str = "0";
/// an empty string (to return a reference for primitive values)
- const string_type empty_str = "";
+ const std::string empty_str = "";
public:
explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
@@ -3347,7 +1722,7 @@
}
/// return key of the iterator
- const string_type& key() const
+ const std::string& key() const
{
assert(anchor.m_object != nullptr);
@@ -3358,7 +1733,7 @@
{
if (array_index != array_index_last)
{
- int_to_string( array_index_str, array_index );
+ array_index_str = std::to_string(array_index);
array_index_last = array_index;
}
return array_index_str;
@@ -3598,10 +1973,7 @@
j.m_type = value_t::array;
j.m_value = value_t::array;
j.m_value.array->resize(arr.size());
- if (arr.size() > 0)
- {
- std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
- }
+ std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
j.assert_invariant();
}
};
@@ -3746,8 +2118,8 @@
external_constructor<value_t::array>::construct(j, arr);
}
-template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
-void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+template<typename BasicJsonType, typename... Args>
+void to_json(BasicJsonType& j, const std::pair<Args...>& p)
{
j = { p.first, p.second };
}
@@ -3766,10 +2138,10 @@
j = { std::get<Idx>(t)... };
}
-template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
-void to_json(BasicJsonType& j, const T& t)
+template<typename BasicJsonType, typename... Args>
+void to_json(BasicJsonType& j, const std::tuple<Args...>& t)
{
- to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+ to_json_tuple_impl(j, t, index_sequence_for<Args...> {});
}
struct to_json_fn
@@ -3788,7 +2160,7 @@
{
constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
} // namespace
-} // namespace nlohmann
+} // namespace nlohmann
namespace nlohmann
@@ -3918,7 +2290,6 @@
class file_input_adapter : public input_adapter_protocol
{
public:
- JSON_HEDLEY_NON_NULL(2)
explicit file_input_adapter(std::FILE* f) noexcept
: m_file(f)
{}
@@ -3995,7 +2366,7 @@
{
public:
input_buffer_adapter(const char* b, const std::size_t l) noexcept
- : cursor(b), limit(b == nullptr ? nullptr : (b + l))
+ : cursor(b), limit(b + l)
{}
// delete because of pointer members
@@ -4007,9 +2378,8 @@
std::char_traits<char>::int_type get_character() noexcept override
{
- if (JSON_HEDLEY_LIKELY(cursor < limit))
+ if (JSON_LIKELY(cursor < limit))
{
- assert(cursor != nullptr and limit != nullptr);
return std::char_traits<char>::to_int_type(*(cursor++));
}
@@ -4198,7 +2568,6 @@
{
public:
// native support
- JSON_HEDLEY_NON_NULL(2)
input_adapter(std::FILE* file)
: ia(std::make_shared<file_input_adapter>(file)) {}
/// input adapter for input stream
@@ -4267,7 +2636,7 @@
"each element in the iterator range must have the size of 1 byte");
const auto len = static_cast<size_t>(std::distance(first, last));
- if (JSON_HEDLEY_LIKELY(len > 0))
+ if (JSON_LIKELY(len > 0))
{
// there is at least one element: use the address of first
ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
@@ -4515,7 +2884,7 @@
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
- if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive object size: " + std::to_string(len)));
@@ -4541,7 +2910,7 @@
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
- if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408,
"excessive array size: " + std::to_string(len)));
@@ -4597,7 +2966,6 @@
object to which we can add elements
*/
template<typename Value>
- JSON_HEDLEY_RETURNS_NON_NULL
BasicJsonType* handle_value(Value&& v)
{
if (ref_stack.empty())
@@ -4704,7 +3072,7 @@
ref_stack.push_back(val.second);
// check object limit
- if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (ref_stack.back() and JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
}
@@ -4767,7 +3135,7 @@
ref_stack.push_back(val.second);
// check array limit
- if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+ if (ref_stack.back() and JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
}
@@ -5206,7 +3574,6 @@
@return
*/
- JSON_HEDLEY_NON_NULL(3)
bool sax_parse(const input_format_t format,
json_sax_t* sax_,
const bool strict = true)
@@ -5248,7 +3615,7 @@
get();
}
- if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char>::eof()))
+ if (JSON_UNLIKELY(current != std::char_traits<char>::eof()))
{
return sax->parse_error(chars_read, get_token_string(),
parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
@@ -5284,12 +3651,12 @@
std::int32_t document_size;
get_number<std::int32_t, true>(input_format_t::bson, document_size);
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
+ if (JSON_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
{
return false;
}
@@ -5310,7 +3677,7 @@
while (true)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
{
return false;
}
@@ -5338,7 +3705,7 @@
template<typename NumberType>
bool get_bson_string(const NumberType len, string_t& result)
{
- if (JSON_HEDLEY_UNLIKELY(len < 1))
+ if (JSON_UNLIKELY(len < 1))
{
auto last_token = get_token_string();
return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
@@ -5433,13 +3800,13 @@
string_t key;
while (int element_type = get())
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
{
return false;
}
const std::size_t element_type_parse_position = chars_read;
- if (JSON_HEDLEY_UNLIKELY(not get_bson_cstr(key)))
+ if (JSON_UNLIKELY(not get_bson_cstr(key)))
{
return false;
}
@@ -5449,7 +3816,7 @@
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
+ if (JSON_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
{
return false;
}
@@ -5470,12 +3837,12 @@
std::int32_t document_size;
get_number<std::int32_t, true>(input_format_t::bson, document_size);
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
+ if (JSON_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
{
return false;
}
@@ -5760,12 +4127,12 @@
case 0xF9: // Half-Precision Float (two-byte IEEE 754)
{
const int byte1_raw = get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
{
return false;
}
const int byte2_raw = get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
{
return false;
}
@@ -5787,7 +4154,7 @@
const int exp = (half >> 10u) & 0x1Fu;
const unsigned int mant = half & 0x3FFu;
assert(0 <= exp and exp <= 32);
- assert(mant <= 1024);
+ assert(0 <= mant and mant <= 1024);
switch (exp)
{
case 0:
@@ -5838,7 +4205,7 @@
*/
bool get_cbor_string(string_t& result)
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
{
return false;
}
@@ -5927,7 +4294,7 @@
*/
bool get_cbor_array(const std::size_t len)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
+ if (JSON_UNLIKELY(not sax->start_array(len)))
{
return false;
}
@@ -5936,7 +4303,7 @@
{
for (std::size_t i = 0; i < len; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+ if (JSON_UNLIKELY(not parse_cbor_internal()))
{
return false;
}
@@ -5946,7 +4313,7 @@
{
while (get() != 0xFF)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal(false)))
+ if (JSON_UNLIKELY(not parse_cbor_internal(false)))
{
return false;
}
@@ -5963,7 +4330,7 @@
*/
bool get_cbor_object(const std::size_t len)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
+ if (JSON_UNLIKELY(not sax->start_object(len)))
{
return false;
}
@@ -5974,12 +4341,12 @@
for (std::size_t i = 0; i < len; ++i)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+ if (JSON_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+ if (JSON_UNLIKELY(not parse_cbor_internal()))
{
return false;
}
@@ -5990,12 +4357,12 @@
{
while (get() != 0xFF)
{
- if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+ if (JSON_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+ if (JSON_UNLIKELY(not parse_cbor_internal()))
{
return false;
}
@@ -6223,9 +4590,6 @@
case 0xBD:
case 0xBE:
case 0xBF:
- case 0xD9: // str 8
- case 0xDA: // str 16
- case 0xDB: // str 32
{
string_t s;
return get_msgpack_string(s) and sax->string(s);
@@ -6300,6 +4664,14 @@
return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
}
+ case 0xD9: // str 8
+ case 0xDA: // str 16
+ case 0xDB: // str 32
+ {
+ string_t s;
+ return get_msgpack_string(s) and sax->string(s);
+ }
+
case 0xDC: // array 16
{
std::uint16_t len;
@@ -6379,7 +4751,7 @@
*/
bool get_msgpack_string(string_t& result)
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
{
return false;
}
@@ -6455,14 +4827,14 @@
*/
bool get_msgpack_array(const std::size_t len)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
+ if (JSON_UNLIKELY(not sax->start_array(len)))
{
return false;
}
for (std::size_t i = 0; i < len; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
+ if (JSON_UNLIKELY(not parse_msgpack_internal()))
{
return false;
}
@@ -6477,7 +4849,7 @@
*/
bool get_msgpack_object(const std::size_t len)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
+ if (JSON_UNLIKELY(not sax->start_object(len)))
{
return false;
}
@@ -6486,12 +4858,12 @@
for (std::size_t i = 0; i < len; ++i)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
+ if (JSON_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
+ if (JSON_UNLIKELY(not parse_msgpack_internal()))
{
return false;
}
@@ -6538,7 +4910,7 @@
get(); // TODO(niels): may we ignore N here?
}
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
{
return false;
}
@@ -6592,7 +4964,7 @@
case 'U':
{
std::uint8_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -6603,7 +4975,7 @@
case 'i':
{
std::int8_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -6614,7 +4986,7 @@
case 'I':
{
std::int16_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -6625,7 +4997,7 @@
case 'l':
{
std::int32_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -6636,7 +5008,7 @@
case 'L':
{
std::int64_t number;
- if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+ if (JSON_UNLIKELY(not get_number(input_format_t::ubjson, number)))
{
return false;
}
@@ -6672,15 +5044,15 @@
if (current == '$')
{
result.second = get(); // must not ignore 'N', because 'N' maybe the type
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
{
return false;
}
get_ignore_noop();
- if (JSON_HEDLEY_UNLIKELY(current != '#'))
+ if (JSON_UNLIKELY(current != '#'))
{
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
{
return false;
}
@@ -6763,11 +5135,11 @@
case 'C': // char
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
+ if (JSON_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(current > 127))
+ if (JSON_UNLIKELY(current > 127))
{
auto last_token = get_token_string();
return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
@@ -6802,14 +5174,14 @@
bool get_ubjson_array()
{
std::pair<std::size_t, int> size_and_type;
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+ if (JSON_UNLIKELY(not get_ubjson_size_type(size_and_type)))
{
return false;
}
if (size_and_type.first != string_t::npos)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(size_and_type.first)))
+ if (JSON_UNLIKELY(not sax->start_array(size_and_type.first)))
{
return false;
}
@@ -6820,7 +5192,7 @@
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+ if (JSON_UNLIKELY(not get_ubjson_value(size_and_type.second)))
{
return false;
}
@@ -6831,7 +5203,7 @@
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+ if (JSON_UNLIKELY(not parse_ubjson_internal()))
{
return false;
}
@@ -6840,14 +5212,14 @@
}
else
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
{
return false;
}
while (current != ']')
{
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal(false)))
+ if (JSON_UNLIKELY(not parse_ubjson_internal(false)))
{
return false;
}
@@ -6864,7 +5236,7 @@
bool get_ubjson_object()
{
std::pair<std::size_t, int> size_and_type;
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+ if (JSON_UNLIKELY(not get_ubjson_size_type(size_and_type)))
{
return false;
}
@@ -6872,7 +5244,7 @@
string_t key;
if (size_and_type.first != string_t::npos)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(size_and_type.first)))
+ if (JSON_UNLIKELY(not sax->start_object(size_and_type.first)))
{
return false;
}
@@ -6881,11 +5253,11 @@
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+ if (JSON_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+ if (JSON_UNLIKELY(not get_ubjson_value(size_and_type.second)))
{
return false;
}
@@ -6896,11 +5268,11 @@
{
for (std::size_t i = 0; i < size_and_type.first; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+ if (JSON_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+ if (JSON_UNLIKELY(not parse_ubjson_internal()))
{
return false;
}
@@ -6910,18 +5282,18 @@
}
else
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
{
return false;
}
while (current != '}')
{
- if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
+ if (JSON_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
{
return false;
}
- if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+ if (JSON_UNLIKELY(not parse_ubjson_internal()))
{
return false;
}
@@ -6987,7 +5359,7 @@
for (std::size_t i = 0; i < sizeof(NumberType); ++i)
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "number")))
+ if (JSON_UNLIKELY(not unexpect_eof(format, "number")))
{
return false;
}
@@ -7031,7 +5403,7 @@
std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
{
get();
- if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "string")))
+ if (JSON_UNLIKELY(not unexpect_eof(format, "string")))
{
success = false;
}
@@ -7045,10 +5417,9 @@
@param[in] context further context information (for diagnostics)
@return whether the last read character is not EOF
*/
- JSON_HEDLEY_NON_NULL(3)
bool unexpect_eof(const input_format_t format, const char* context) const
{
- if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char>::eof()))
+ if (JSON_UNLIKELY(current == std::char_traits<char>::eof()))
{
return sax->parse_error(chars_read, "<end of file>",
parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
@@ -7069,7 +5440,7 @@
/*!
@param[in] format the current format
@param[in] detail a detailed error message
- @param[in] context further context information
+ @param[in] context further contect information
@return a message string to use in the parse_error exceptions
*/
std::string exception_message(const input_format_t format,
@@ -7189,8 +5560,6 @@
};
/// return name of values of type token_type (only used for errors)
- JSON_HEDLEY_RETURNS_NON_NULL
- JSON_HEDLEY_CONST
static const char* token_type_name(const token_type t) noexcept
{
switch (t)
@@ -7250,7 +5619,6 @@
/////////////////////
/// return the locale-dependent decimal point
- JSON_HEDLEY_PURE
static char get_decimal_point() noexcept
{
const auto loc = localeconv();
@@ -7333,7 +5701,7 @@
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
- if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
+ if (JSON_LIKELY(*range <= current and current <= *(++range)))
{
add(current);
}
@@ -7432,7 +5800,7 @@
const int codepoint1 = get_codepoint();
int codepoint = codepoint1; // start with codepoint1
- if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+ if (JSON_UNLIKELY(codepoint1 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
@@ -7442,18 +5810,18 @@
if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
{
// expect next \uxxxx entry
- if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
+ if (JSON_LIKELY(get() == '\\' and get() == 'u'))
{
const int codepoint2 = get_codepoint();
- if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+ if (JSON_UNLIKELY(codepoint2 == -1))
{
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
return token_type::parse_error;
}
// check if codepoint2 is a low surrogate
- if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
+ if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
{
// overwrite codepoint
codepoint = static_cast<int>(
@@ -7480,7 +5848,7 @@
}
else
{
- if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
+ if (JSON_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
{
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
return token_type::parse_error;
@@ -7855,7 +6223,7 @@
case 0xDE:
case 0xDF:
{
- if (JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
+ if (JSON_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
{
return token_type::parse_error;
}
@@ -7865,7 +6233,7 @@
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
case 0xE0:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+ if (JSON_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -7889,7 +6257,7 @@
case 0xEE:
case 0xEF:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -7899,7 +6267,7 @@
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
case 0xED:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+ if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -7909,7 +6277,7 @@
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
case 0xF0:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -7921,7 +6289,7 @@
case 0xF2:
case 0xF3:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -7931,7 +6299,7 @@
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
case 0xF4:
{
- if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+ if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
{
return token_type::parse_error;
}
@@ -7948,19 +6316,16 @@
}
}
- JSON_HEDLEY_NON_NULL(2)
static void strtof(float& f, const char* str, char** endptr) noexcept
{
f = std::strtof(str, endptr);
}
- JSON_HEDLEY_NON_NULL(2)
static void strtof(double& f, const char* str, char** endptr) noexcept
{
f = std::strtod(str, endptr);
}
- JSON_HEDLEY_NON_NULL(2)
static void strtof(long double& f, const char* str, char** endptr) noexcept
{
f = std::strtold(str, endptr);
@@ -8336,14 +6701,13 @@
@param[in] length the length of the passed literal text
@param[in] return_type the token type to return on success
*/
- JSON_HEDLEY_NON_NULL(2)
token_type scan_literal(const char* literal_text, const std::size_t length,
token_type return_type)
{
assert(current == literal_text[0]);
for (std::size_t i = 1; i < length; ++i)
{
- if (JSON_HEDLEY_UNLIKELY(get() != literal_text[i]))
+ if (JSON_UNLIKELY(get() != literal_text[i]))
{
error_message = "invalid literal";
return token_type::parse_error;
@@ -8389,7 +6753,7 @@
current = ia->get_character();
}
- if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
+ if (JSON_LIKELY(current != std::char_traits<char>::eof()))
{
token_string.push_back(std::char_traits<char>::to_char_type(current));
}
@@ -8430,7 +6794,7 @@
--position.chars_read_current_line;
}
- if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
+ if (JSON_LIKELY(current != std::char_traits<char>::eof()))
{
assert(not token_string.empty());
token_string.pop_back();
@@ -8509,7 +6873,6 @@
}
/// return syntax error message
- JSON_HEDLEY_RETURNS_NON_NULL
constexpr const char* get_error_message() const noexcept
{
return error_message;
@@ -8798,7 +7161,6 @@
}
template <typename SAX>
- JSON_HEDLEY_NON_NULL(2)
bool sax_parse(SAX* sax, const bool strict = true)
{
(void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
@@ -8818,7 +7180,6 @@
private:
template <typename SAX>
- JSON_HEDLEY_NON_NULL(2)
bool sax_parse_internal(SAX* sax)
{
// stack to remember the hierarchy of structured values we are parsing
@@ -8836,7 +7197,7 @@
{
case token_type::begin_object:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+ if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
{
return false;
}
@@ -8844,7 +7205,7 @@
// closing } -> we are done
if (get_token() == token_type::end_object)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+ if (JSON_UNLIKELY(not sax->end_object()))
{
return false;
}
@@ -8852,20 +7213,20 @@
}
// parse key
- if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+ if (JSON_UNLIKELY(last_token != token_type::value_string))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::value_string, "object key")));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+ if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
{
return false;
}
// parse separator (:)
- if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+ if (JSON_UNLIKELY(get_token() != token_type::name_separator))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -8883,7 +7244,7 @@
case token_type::begin_array:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+ if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
{
return false;
}
@@ -8891,7 +7252,7 @@
// closing ] -> we are done
if (get_token() == token_type::end_array)
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+ if (JSON_UNLIKELY(not sax->end_array()))
{
return false;
}
@@ -8909,14 +7270,14 @@
{
const auto res = m_lexer.get_number_float();
- if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
+ if (JSON_UNLIKELY(not std::isfinite(res)))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
+ if (JSON_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
{
return false;
}
@@ -8926,7 +7287,7 @@
case token_type::literal_false:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
+ if (JSON_UNLIKELY(not sax->boolean(false)))
{
return false;
}
@@ -8935,7 +7296,7 @@
case token_type::literal_null:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->null()))
+ if (JSON_UNLIKELY(not sax->null()))
{
return false;
}
@@ -8944,7 +7305,7 @@
case token_type::literal_true:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
+ if (JSON_UNLIKELY(not sax->boolean(true)))
{
return false;
}
@@ -8953,7 +7314,7 @@
case token_type::value_integer:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
+ if (JSON_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
{
return false;
}
@@ -8962,7 +7323,7 @@
case token_type::value_string:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
+ if (JSON_UNLIKELY(not sax->string(m_lexer.get_string())))
{
return false;
}
@@ -8971,7 +7332,7 @@
case token_type::value_unsigned:
{
- if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
+ if (JSON_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
{
return false;
}
@@ -9019,9 +7380,9 @@
}
// closing ]
- if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+ if (JSON_LIKELY(last_token == token_type::end_array))
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+ if (JSON_UNLIKELY(not sax->end_array()))
{
return false;
}
@@ -9047,7 +7408,7 @@
if (get_token() == token_type::value_separator)
{
// parse key
- if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+ if (JSON_UNLIKELY(get_token() != token_type::value_string))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -9055,13 +7416,13 @@
exception_message(token_type::value_string, "object key")));
}
- if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+ if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
{
return false;
}
// parse separator (:)
- if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+ if (JSON_UNLIKELY(get_token() != token_type::name_separator))
{
return sax->parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
@@ -9075,9 +7436,9 @@
}
// closing }
- if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+ if (JSON_LIKELY(last_token == token_type::end_object))
{
- if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+ if (JSON_UNLIKELY(not sax->end_object()))
{
return false;
}
@@ -9425,41 +7786,16 @@
*/
/*!
- @brief const copy constructor
- @param[in] other const iterator to copy from
- @note This copy constructor had to be defined explicitly to circumvent a bug
- occurring on msvc v19.0 compiler (VS 2015) debug build. For more
- information refer to: https://github.com/nlohmann/json/issues/1608
- */
- iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
- : m_object(other.m_object), m_it(other.m_it)
- {}
-
- /*!
- @brief converting assignment
- @param[in] other const iterator to copy from
- @return const/non-const iterator
- @note It is not checked whether @a other is initialized.
- */
- iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
- {
- m_object = other.m_object;
- m_it = other.m_it;
- return *this;
- }
-
- /*!
@brief converting constructor
@param[in] other non-const iterator to copy from
@note It is not checked whether @a other is initialized.
*/
iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
- : m_object(other.m_object), m_it(other.m_it)
- {}
+ : m_object(other.m_object), m_it(other.m_it) {}
/*!
@brief converting assignment
- @param[in] other non-const iterator to copy from
+ @param[in,out] other non-const iterator to copy from
@return const/non-const iterator
@note It is not checked whether @a other is initialized.
*/
@@ -9566,7 +7902,7 @@
default:
{
- if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+ if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
{
return *m_object;
}
@@ -9600,7 +7936,7 @@
default:
{
- if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+ if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))
{
return m_object;
}
@@ -9703,7 +8039,7 @@
bool operator==(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
- if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+ if (JSON_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
@@ -9739,7 +8075,7 @@
bool operator<(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
- if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+ if (JSON_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
@@ -9899,7 +8235,7 @@
default:
{
- if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+ if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n))
{
return *m_object;
}
@@ -9917,7 +8253,7 @@
{
assert(m_object != nullptr);
- if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+ if (JSON_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
@@ -9940,7 +8276,7 @@
/// the actual iterator of the associated instance
internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
};
-} // namespace detail
+} // namespace detail
} // namespace nlohmann
// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
@@ -10073,7 +8409,6 @@
#include <algorithm> // all_of
#include <cassert> // assert
-#include <cctype> // isdigit
#include <numeric> // accumulate
#include <string> // string
#include <utility> // move
@@ -10200,7 +8535,7 @@
/*!
@brief append an array index at the end of this JSON pointer
- @param[in] array_index array index to append
+ @param[in] array_index array index ot append
@return JSON pointer with @a array_index appended
@liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
@@ -10319,7 +8654,7 @@
*/
void pop_back()
{
- if (JSON_HEDLEY_UNLIKELY(empty()))
+ if (JSON_UNLIKELY(empty()))
{
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
}
@@ -10341,9 +8676,9 @@
@since version 3.6.0
*/
- const std::string& back() const
+ const std::string& back()
{
- if (JSON_HEDLEY_UNLIKELY(empty()))
+ if (JSON_UNLIKELY(empty()))
{
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
}
@@ -10407,7 +8742,7 @@
const int res = std::stoi(s, &processed_chars);
// check if the string was completely read
- if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
+ if (JSON_UNLIKELY(processed_chars != s.size()))
{
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
}
@@ -10417,7 +8752,7 @@
json_pointer top() const
{
- if (JSON_HEDLEY_UNLIKELY(empty()))
+ if (JSON_UNLIKELY(empty()))
{
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
}
@@ -10444,7 +8779,7 @@
// j which will be overwritten by a primitive value
for (const auto& reference_token : reference_tokens)
{
- switch (result->type())
+ switch (result->m_type)
{
case detail::value_t::null:
{
@@ -10521,14 +8856,14 @@
for (const auto& reference_token : reference_tokens)
{
// convert null values to arrays or objects before continuing
- if (ptr->is_null())
+ if (ptr->m_type == detail::value_t::null)
{
// check if reference token is a number
const bool nums =
std::all_of(reference_token.begin(), reference_token.end(),
- [](const unsigned char x)
+ [](const char x)
{
- return std::isdigit(x);
+ return x >= '0' and x <= '9';
});
// change value to array for numbers or "-" or to object otherwise
@@ -10537,7 +8872,7 @@
: detail::value_t::object;
}
- switch (ptr->type())
+ switch (ptr->m_type)
{
case detail::value_t::object:
{
@@ -10549,7 +8884,7 @@
case detail::value_t::array:
{
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+ if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
@@ -10596,7 +8931,7 @@
using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
- switch (ptr->type())
+ switch (ptr->m_type)
{
case detail::value_t::object:
{
@@ -10607,7 +8942,7 @@
case detail::value_t::array:
{
- if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+ if (JSON_UNLIKELY(reference_token == "-"))
{
// "-" always fails the range check
JSON_THROW(detail::out_of_range::create(402,
@@ -10616,7 +8951,7 @@
}
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+ if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
@@ -10661,7 +8996,7 @@
using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
- switch (ptr->type())
+ switch (ptr->m_type)
{
case detail::value_t::object:
{
@@ -10672,7 +9007,7 @@
case detail::value_t::array:
{
- if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+ if (JSON_UNLIKELY(reference_token == "-"))
{
// "-" cannot be used for const access
JSON_THROW(detail::out_of_range::create(402,
@@ -10681,7 +9016,7 @@
}
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+ if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
@@ -10720,7 +9055,7 @@
using size_type = typename BasicJsonType::size_type;
for (const auto& reference_token : reference_tokens)
{
- switch (ptr->type())
+ switch (ptr->m_type)
{
case detail::value_t::object:
{
@@ -10731,7 +9066,7 @@
case detail::value_t::array:
{
- if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+ if (JSON_UNLIKELY(reference_token == "-"))
{
// "-" always fails the range check
JSON_THROW(detail::out_of_range::create(402,
@@ -10740,7 +9075,7 @@
}
// error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+ if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + reference_token +
@@ -10768,77 +9103,6 @@
}
/*!
- @throw parse_error.106 if an array index begins with '0'
- @throw parse_error.109 if an array index was not a number
- */
- bool contains(const BasicJsonType* ptr) const
- {
- using size_type = typename BasicJsonType::size_type;
- for (const auto& reference_token : reference_tokens)
- {
- switch (ptr->type())
- {
- case detail::value_t::object:
- {
- if (not ptr->contains(reference_token))
- {
- // we did not find the key in the object
- return false;
- }
-
- ptr = &ptr->operator[](reference_token);
- break;
- }
-
- case detail::value_t::array:
- {
- if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
- {
- // "-" always fails the range check
- return false;
- }
-
- // error condition (cf. RFC 6901, Sect. 4)
- if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
- {
- JSON_THROW(detail::parse_error::create(106, 0,
- "array index '" + reference_token +
- "' must not begin with '0'"));
- }
-
- JSON_TRY
- {
- const auto idx = static_cast<size_type>(array_index(reference_token));
- if (idx >= ptr->size())
- {
- // index out of range
- return false;
- }
-
- ptr = &ptr->operator[](idx);
- break;
- }
- JSON_CATCH(std::invalid_argument&)
- {
- JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
- }
- break;
- }
-
- default:
- {
- // we do not expect primitive values if there is still a
- // reference token to process
- return false;
- }
- }
- }
-
- // no reference token left means we found a primitive value
- return true;
- }
-
- /*!
@brief split the string input to reference tokens
@note This function is only called by the json_pointer constructor.
@@ -10858,7 +9122,7 @@
}
// check if nonempty reference string begins with slash
- if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+ if (JSON_UNLIKELY(reference_string[0] != '/'))
{
JSON_THROW(detail::parse_error::create(107, 1,
"JSON pointer must be empty or begin with '/' - was: '" +
@@ -10893,9 +9157,9 @@
assert(reference_token[pos] == '~');
// ~ must be followed by 0 or 1
- if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
- (reference_token[pos + 1] != '0' and
- reference_token[pos + 1] != '1')))
+ if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
+ (reference_token[pos + 1] != '0' and
+ reference_token[pos + 1] != '1')))
{
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
}
@@ -10959,7 +9223,7 @@
const BasicJsonType& value,
BasicJsonType& result)
{
- switch (value.type())
+ switch (value.m_type)
{
case detail::value_t::array:
{
@@ -11020,7 +9284,7 @@
static BasicJsonType
unflatten(const BasicJsonType& value)
{
- if (JSON_HEDLEY_UNLIKELY(not value.is_object()))
+ if (JSON_UNLIKELY(not value.is_object()))
{
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
}
@@ -11030,7 +9294,7 @@
// iterate the JSON object values
for (const auto& element : *value.m_value.object)
{
- if (JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
+ if (JSON_UNLIKELY(not element.second.is_primitive()))
{
JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
}
@@ -11174,8 +9438,6 @@
// #include <nlohmann/detail/input/binary_reader.hpp>
-// #include <nlohmann/detail/macro_scope.hpp>
-
// #include <nlohmann/detail/output/output_adapters.hpp>
@@ -11187,8 +9449,6 @@
#include <ostream> // basic_ostream
#include <string> // basic_string
#include <vector> // vector
-// #include <nlohmann/detail/macro_scope.hpp>
-
namespace nlohmann
{
@@ -11220,7 +9480,6 @@
v.push_back(c);
}
- JSON_HEDLEY_NON_NULL(2)
void write_characters(const CharType* s, std::size_t length) override
{
std::copy(s, s + length, std::back_inserter(v));
@@ -11244,7 +9503,6 @@
stream.put(c);
}
- JSON_HEDLEY_NON_NULL(2)
void write_characters(const CharType* s, std::size_t length) override
{
stream.write(s, static_cast<std::streamsize>(length));
@@ -11268,7 +9526,6 @@
str.push_back(c);
}
- JSON_HEDLEY_NON_NULL(2)
void write_characters(const CharType* s, std::size_t length) override
{
str.append(s, length);
@@ -12007,7 +10264,7 @@
static std::size_t calc_bson_entry_header_size(const string_t& name)
{
const auto it = name.find(static_cast<typename string_t::value_type>(0));
- if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+ if (JSON_UNLIKELY(it != BasicJsonType::string_t::npos))
{
JSON_THROW(out_of_range::create(409,
"BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
@@ -12153,12 +10410,13 @@
*/
static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
{
+ std::size_t embedded_document_size = 0ul;
std::size_t array_index = 0ul;
- const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), 0ul, [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+ for (const auto& el : value)
{
- return result + calc_bson_element_size(std::to_string(array_index++), el);
- });
+ embedded_document_size += calc_bson_element_size(std::to_string(array_index++), el);
+ }
return sizeof(std::int32_t) + embedded_document_size + 1ul;
}
@@ -12496,19 +10754,19 @@
case value_t::number_unsigned:
{
- if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int8_t>::max)())
{
return 'i';
}
- if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
{
return 'U';
}
- if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int16_t>::max)())
{
return 'I';
}
- if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+ if (j.m_value.number_unsigned <= (std::numeric_limits<std::int32_t>::max)())
{
return 'l';
}
@@ -12656,8 +10914,6 @@
#include <cstring> // memcpy, memmove
#include <limits> // numeric_limits
#include <type_traits> // conditional
-// #include <nlohmann/detail/macro_scope.hpp>
-
namespace nlohmann
{
@@ -12979,7 +11235,7 @@
// ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
// ==> 2^(alpha - e - 1) <= c
//
- // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+ // If c were an exakt power of ten, i.e. c = 10^k, one may determine k as
//
// k = ceil( log_10( 2^(alpha - e - 1) ) )
// = ceil( (alpha - e - 1) * log_10(2) )
@@ -13468,7 +11724,6 @@
len is the length of the buffer (number of decimal digits)
The buffer must be large enough, i.e. >= max_digits10.
*/
-JSON_HEDLEY_NON_NULL(1)
inline void grisu2(char* buf, int& len, int& decimal_exponent,
diyfp m_minus, diyfp v, diyfp m_plus)
{
@@ -13528,7 +11783,6 @@
The buffer must be large enough, i.e. >= max_digits10.
*/
template <typename FloatType>
-JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
@@ -13567,8 +11821,6 @@
@return a pointer to the element following the exponent.
@pre -1000 < e < 1000
*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
inline char* append_exponent(char* buf, int e)
{
assert(e > -1000);
@@ -13619,8 +11871,6 @@
@pre min_exp < 0
@pre max_exp > 0
*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
@@ -13704,8 +11954,6 @@
@note The result is NOT null-terminated.
*/
template <typename FloatType>
-JSON_HEDLEY_NON_NULL(1, 2)
-JSON_HEDLEY_RETURNS_NON_NULL
char* to_chars(char* first, const char* last, FloatType value)
{
static_cast<void>(last); // maybe unused - fix warning
@@ -13855,7 +12103,7 @@
// variable to hold indentation for recursive calls
const auto new_indent = current_indent + indent_step;
- if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+ if (JSON_UNLIKELY(indent_string.size() < new_indent))
{
indent_string.resize(indent_string.size() * 2, ' ');
}
@@ -13928,7 +12176,7 @@
// variable to hold indentation for recursive calls
const auto new_indent = current_indent + indent_step;
- if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+ if (JSON_UNLIKELY(indent_string.size() < new_indent))
{
indent_string.resize(indent_string.size() * 2, ' ');
}
@@ -14243,7 +12491,7 @@
}
// we finished processing the string
- if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+ if (JSON_LIKELY(state == UTF8_ACCEPT))
{
// write buffer
if (bytes > 0)
@@ -14375,7 +12623,7 @@
if (is_negative)
{
*buffer_ptr = '-';
- abs_value = remove_sign(x);
+ abs_value = static_cast<number_unsigned_t>(std::abs(static_cast<std::intmax_t>(x)));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
@@ -14556,32 +12804,6 @@
return state;
}
- /*
- * Overload to make the compiler happy while it is instantiating
- * dump_integer for number_unsigned_t.
- * Must never be called.
- */
- number_unsigned_t remove_sign(number_unsigned_t x)
- {
- assert(false); // LCOV_EXCL_LINE
- return x; // LCOV_EXCL_LINE
- }
-
- /*
- * Helper function for dump_integer
- *
- * This function takes a negative signed integer and returns its absolute
- * value as unsigned integer. The plus/minus shuffling is necessary as we can
- * not directly remove the sign of an arbitrary signed integer as the
- * absolute values of INT_MIN and INT_MAX are usually not the same. See
- * #1708 for details.
- */
- inline number_unsigned_t remove_sign(number_integer_t x) noexcept
- {
- assert(x < 0 and x < (std::numeric_limits<number_integer_t>::max)());
- return static_cast<number_unsigned_t>(-(x + 1)) + 1;
- }
-
private:
/// the output of the serializer
output_adapter_t<char> o = nullptr;
@@ -14862,7 +13084,7 @@
@since 2.1.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json meta()
{
basic_json result;
@@ -15367,7 +13589,6 @@
/// helper for exception-safe object creation
template<typename T, typename... Args>
- JSON_HEDLEY_RETURNS_NON_NULL
static T* create(Args&& ... args)
{
AllocatorType<T> alloc;
@@ -15494,9 +13715,9 @@
default:
{
object = nullptr; // silence warning, see #821
- if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+ if (JSON_UNLIKELY(t == value_t::null))
{
- JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.7.3")); // LCOV_EXCL_LINE
+ JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.6.1")); // LCOV_EXCL_LINE
}
break;
}
@@ -15541,53 +13762,6 @@
void destroy(value_t t) noexcept
{
- // flatten the current json_value to a heap-allocated stack
- std::vector<basic_json> stack;
-
- // move the top-level items to stack
- if (t == value_t::array)
- {
- stack.reserve(array->size());
- std::move(array->begin(), array->end(), std::back_inserter(stack));
- }
- else if (t == value_t::object)
- {
- stack.reserve(object->size());
- for (auto&& it : *object)
- {
- stack.push_back(std::move(it.second));
- }
- }
-
- while (not stack.empty())
- {
- // move the last item to local variable to be processed
- basic_json current_item(std::move(stack.back()));
- stack.pop_back();
-
- // if current_item is array/object, move
- // its children to the stack to be processed later
- if (current_item.is_array())
- {
- std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
- std::back_inserter(stack));
-
- current_item.m_value.array->clear();
- }
- else if (current_item.is_object())
- {
- for (auto&& it : *current_item.m_value.object)
- {
- stack.push_back(std::move(it.second));
- }
-
- current_item.m_value.object->clear();
- }
-
- // it's now safe that current_item get destructed
- // since it doesn't have any children
- }
-
switch (t)
{
case value_t::object:
@@ -16018,7 +14192,7 @@
}
// if object is wanted but impossible, throw an exception
- if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object and not is_an_object))
+ if (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
}
@@ -16085,7 +14259,7 @@
@since version 1.0.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json array(initializer_list_t init = {})
{
return basic_json(init, false, value_t::array);
@@ -16129,7 +14303,7 @@
@since version 1.0.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json object(initializer_list_t init = {})
{
return basic_json(init, false, value_t::object);
@@ -16228,7 +14402,7 @@
assert(last.m_object != nullptr);
// make sure iterator fits the current value
- if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+ if (JSON_UNLIKELY(first.m_object != last.m_object))
{
JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
}
@@ -16245,8 +14419,8 @@
case value_t::number_unsigned:
case value_t::string:
{
- if (JSON_HEDLEY_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
- or not last.m_it.primitive_iterator.is_end()))
+ if (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
+ or not last.m_it.primitive_iterator.is_end()))
{
JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
}
@@ -16959,7 +15133,7 @@
/// get a boolean (explicit)
boolean_t get_impl(boolean_t* /*unused*/) const
{
- if (JSON_HEDLEY_LIKELY(is_boolean()))
+ if (JSON_LIKELY(is_boolean()))
{
return m_value.boolean;
}
@@ -17068,7 +15242,7 @@
// delegate the call to get_ptr<>()
auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
- if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+ if (JSON_LIKELY(ptr != nullptr))
{
return *ptr;
}
@@ -17223,11 +15397,11 @@
detail::has_non_default_from_json<basic_json_t, ValueType>::value,
int> = 0>
ValueType get() const noexcept(noexcept(
- JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+ JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
{
static_assert(not std::is_reference<ValueTypeCV>::value,
"get() cannot be used with reference types, you might want to use get_ref()");
- return JSONSerializer<ValueType>::from_json(*this);
+ return JSONSerializer<ValueTypeCV>::from_json(*this);
}
/*!
@@ -17275,19 +15449,6 @@
return v;
}
- template <
- typename T, std::size_t N,
- typename Array = T (&)[N],
- detail::enable_if_t <
- detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
- Array get_to(T (&v)[N]) const
- noexcept(noexcept(JSONSerializer<Array>::from_json(
- std::declval<const basic_json_t&>(), v)))
- {
- JSONSerializer<Array>::from_json(*this, v);
- return v;
- }
-
/*!
@brief get a pointer value (implicit)
@@ -17519,7 +15680,7 @@
reference at(size_type idx)
{
// at only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
JSON_TRY
{
@@ -17566,7 +15727,7 @@
const_reference at(size_type idx) const
{
// at only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
JSON_TRY
{
@@ -17617,7 +15778,7 @@
reference at(const typename object_t::key_type& key)
{
// at only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
JSON_TRY
{
@@ -17668,7 +15829,7 @@
const_reference at(const typename object_t::key_type& key) const
{
// at only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
JSON_TRY
{
@@ -17722,7 +15883,7 @@
}
// operator[] only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
// fill up array with null values if given idx is outside range
if (idx >= m_value.array->size())
@@ -17760,7 +15921,7 @@
const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
return m_value.array->operator[](idx);
}
@@ -17806,7 +15967,7 @@
}
// operator[] only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
return m_value.object->operator[](key);
}
@@ -17847,7 +16008,7 @@
const_reference operator[](const typename object_t::key_type& key) const
{
// const operator[] only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
assert(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
@@ -17884,7 +16045,6 @@
@since version 1.1.0
*/
template<typename T>
- JSON_HEDLEY_NON_NULL(2)
reference operator[](T* key)
{
// implicitly convert null to object
@@ -17896,7 +16056,7 @@
}
// at only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
return m_value.object->operator[](key);
}
@@ -17935,11 +16095,10 @@
@since version 1.1.0
*/
template<typename T>
- JSON_HEDLEY_NON_NULL(2)
const_reference operator[](T* key) const
{
// at only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
assert(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
@@ -17981,8 +16140,6 @@
@return copy of the element at key @a key or @a default_value if @a key
is not found
- @throw type_error.302 if @a default_value does not match the type of the
- value at @a key
@throw type_error.306 if the JSON value is not an object; in that case,
using `value()` with a key makes no sense.
@@ -18003,7 +16160,7 @@
ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
{
// at only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
// if key is found, return value and given default value otherwise
const auto it = find(key);
@@ -18056,8 +16213,6 @@
@return copy of the element at key @a key or @a default_value if @a key
is not found
- @throw type_error.302 if @a default_value does not match the type of the
- value at @a ptr
@throw type_error.306 if the JSON value is not an object; in that case,
using `value()` with a key makes no sense.
@@ -18075,7 +16230,7 @@
ValueType value(const json_pointer& ptr, const ValueType& default_value) const
{
// at only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
// if pointer resolves a value, return it or use default value
JSON_TRY
@@ -18095,7 +16250,6 @@
@brief overload for a default value of type const char*
@copydoc basic_json::value(const json_pointer&, ValueType) const
*/
- JSON_HEDLEY_NON_NULL(3)
string_t value(const json_pointer& ptr, const char* default_value) const
{
return value(ptr, string_t(default_value));
@@ -18240,7 +16394,7 @@
IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
- if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+ if (JSON_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
@@ -18255,7 +16409,7 @@
case value_t::number_unsigned:
case value_t::string:
{
- if (JSON_HEDLEY_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
+ if (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
}
@@ -18345,7 +16499,7 @@
IteratorType erase(IteratorType first, IteratorType last)
{
// make sure iterator fits the current value
- if (JSON_HEDLEY_UNLIKELY(this != first.m_object or this != last.m_object))
+ if (JSON_UNLIKELY(this != first.m_object or this != last.m_object))
{
JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
}
@@ -18360,8 +16514,8 @@
case value_t::number_unsigned:
case value_t::string:
{
- if (JSON_HEDLEY_LIKELY(not first.m_it.primitive_iterator.is_begin()
- or not last.m_it.primitive_iterator.is_end()))
+ if (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin()
+ or not last.m_it.primitive_iterator.is_end()))
{
JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
}
@@ -18432,7 +16586,7 @@
size_type erase(const typename object_t::key_type& key)
{
// this erase only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
return m_value.object->erase(key);
}
@@ -18467,9 +16621,9 @@
void erase(const size_type idx)
{
// this erase only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
- if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+ if (JSON_UNLIKELY(idx >= size()))
{
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
}
@@ -18595,48 +16749,15 @@
@liveexample{The following code shows an example for `contains()`.,contains}
@sa @ref find(KeyT&&) -- returns an iterator to an object element
- @sa @ref contains(const json_pointer&) const -- checks the existence for a JSON pointer
@since version 3.6.0
*/
- template<typename KeyT, typename std::enable_if<
- not std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int>::type = 0>
- bool contains(KeyT && key) const
+ template<typename KeyT>
+ bool contains(KeyT&& key) const
{
return is_object() and m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
}
- /*!
- @brief check the existence of an element in a JSON object given a JSON pointer
-
- Check whether the given JSON pointer @a ptr can be resolved in the current
- JSON value.
-
- @note This method can be executed on any JSON value type.
-
- @param[in] ptr JSON pointer to check its existence.
-
- @return true if the JSON pointer can be resolved to a stored value, false
- otherwise.
-
- @post If `j.contains(ptr)` returns true, it is safe to call `j[ptr]`.
-
- @throw parse_error.106 if an array index begins with '0'
- @throw parse_error.109 if an array index was not a number
-
- @complexity Logarithmic in the size of the JSON object.
-
- @liveexample{The following code shows an example for `contains()`.,contains_json_pointer}
-
- @sa @ref contains(KeyT &&) const -- checks the existence of a key
-
- @since version 3.7.0
- */
- bool contains(const json_pointer& ptr) const
- {
- return ptr.contains(this);
- }
-
/// @}
@@ -18978,7 +17099,7 @@
future 4.0.0 of the library. Please use @ref items() instead;
that is, replace `json::iterator_wrapper(j)` with `j.items()`.
*/
- JSON_HEDLEY_DEPRECATED(3.1.0)
+ JSON_DEPRECATED
static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
{
return ref.items();
@@ -18987,7 +17108,7 @@
/*!
@copydoc iterator_wrapper(reference)
*/
- JSON_HEDLEY_DEPRECATED(3.1.0)
+ JSON_DEPRECATED
static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
{
return ref.items();
@@ -19406,7 +17527,7 @@
void push_back(basic_json&& val)
{
// push_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_UNLIKELY(not(is_null() or is_array())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -19443,7 +17564,7 @@
void push_back(const basic_json& val)
{
// push_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_UNLIKELY(not(is_null() or is_array())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -19493,7 +17614,7 @@
void push_back(const typename object_t::value_type& val)
{
// push_back only works for null objects or objects
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+ if (JSON_UNLIKELY(not(is_null() or is_object())))
{
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
}
@@ -19579,8 +17700,6 @@
@param[in] args arguments to forward to a constructor of @ref basic_json
@tparam Args compatible types to create a @ref basic_json object
- @return reference to the inserted element
-
@throw type_error.311 when called on a type other than JSON array or
null; example: `"cannot use emplace_back() with number"`
@@ -19590,13 +17709,13 @@
elements to a JSON array. Note how the `null` value was silently converted
to a JSON array.,emplace_back}
- @since version 2.0.8, returns reference since 3.7.0
+ @since version 2.0.8
*/
template<class... Args>
- reference emplace_back(Args&& ... args)
+ void emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+ if (JSON_UNLIKELY(not(is_null() or is_array())))
{
JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
}
@@ -19610,12 +17729,7 @@
}
// add element to array (perfect forwarding)
-#ifdef JSON_HAS_CPP_17
- return m_value.array->emplace_back(std::forward<Args>(args)...);
-#else
m_value.array->emplace_back(std::forward<Args>(args)...);
- return m_value.array->back();
-#endif
}
/*!
@@ -19649,7 +17763,7 @@
std::pair<iterator, bool> emplace(Args&& ... args)
{
// emplace only works for null objects or arrays
- if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+ if (JSON_UNLIKELY(not(is_null() or is_object())))
{
JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
}
@@ -19717,10 +17831,10 @@
iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
- if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+ if (JSON_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
@@ -19768,10 +17882,10 @@
iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
{
// insert only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
- if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+ if (JSON_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
@@ -19816,24 +17930,24 @@
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
{
// insert only works for arrays
- if (JSON_HEDLEY_UNLIKELY(not is_array()))
+ if (JSON_UNLIKELY(not is_array()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
// check if iterator pos fits to this JSON value
- if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+ if (JSON_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
// check if range iterators belong to the same JSON object
- if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+ if (JSON_UNLIKELY(first.m_object != last.m_object))
{
JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
}
- if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+ if (JSON_UNLIKELY(first.m_object == this))
{
JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
}
@@ -19869,13 +17983,13 @@
iterator insert(const_iterator pos, initializer_list_t ilist)
{
// insert only works for arrays
- if (JSON_HEDLEY_UNLIKELY(not is_array()))
+ if (JSON_UNLIKELY(not is_array()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
// check if iterator pos fits to this JSON value
- if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+ if (JSON_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
}
@@ -19910,19 +18024,19 @@
void insert(const_iterator first, const_iterator last)
{
// insert only works for objects
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_UNLIKELY(not is_object()))
{
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
}
// check if range iterators belong to the same JSON object
- if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+ if (JSON_UNLIKELY(first.m_object != last.m_object))
{
JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
}
// passed iterators must belong to objects
- if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()))
+ if (JSON_UNLIKELY(not first.m_object->is_object()))
{
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
}
@@ -19959,11 +18073,11 @@
assert_invariant();
}
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_UNLIKELY(not is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
}
- if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+ if (JSON_UNLIKELY(not j.is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
}
@@ -20010,20 +18124,20 @@
assert_invariant();
}
- if (JSON_HEDLEY_UNLIKELY(not is_object()))
+ if (JSON_UNLIKELY(not is_object()))
{
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
}
// check if range iterators belong to the same JSON object
- if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+ if (JSON_UNLIKELY(first.m_object != last.m_object))
{
JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
}
// passed iterators must belong to objects
- if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()
- or not last.m_object->is_object()))
+ if (JSON_UNLIKELY(not first.m_object->is_object()
+ or not last.m_object->is_object()))
{
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
}
@@ -20086,7 +18200,7 @@
void swap(array_t& other)
{
// swap only works for arrays
- if (JSON_HEDLEY_LIKELY(is_array()))
+ if (JSON_LIKELY(is_array()))
{
std::swap(*(m_value.array), other);
}
@@ -20119,7 +18233,7 @@
void swap(object_t& other)
{
// swap only works for objects
- if (JSON_HEDLEY_LIKELY(is_object()))
+ if (JSON_LIKELY(is_object()))
{
std::swap(*(m_value.object), other);
}
@@ -20152,7 +18266,7 @@
void swap(string_t& other)
{
// swap only works for strings
- if (JSON_HEDLEY_LIKELY(is_string()))
+ if (JSON_LIKELY(is_string()))
{
std::swap(*(m_value.string), other);
}
@@ -20384,25 +18498,25 @@
return (*lhs.m_value.array) < (*rhs.m_value.array);
case value_t::object:
- return (*lhs.m_value.object) < (*rhs.m_value.object);
+ return *lhs.m_value.object < *rhs.m_value.object;
case value_t::null:
return false;
case value_t::string:
- return (*lhs.m_value.string) < (*rhs.m_value.string);
+ return *lhs.m_value.string < *rhs.m_value.string;
case value_t::boolean:
- return (lhs.m_value.boolean) < (rhs.m_value.boolean);
+ return lhs.m_value.boolean < rhs.m_value.boolean;
case value_t::number_integer:
- return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
+ return lhs.m_value.number_integer < rhs.m_value.number_integer;
case value_t::number_unsigned:
- return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
+ return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
case value_t::number_float:
- return (lhs.m_value.number_float) < (rhs.m_value.number_float);
+ return lhs.m_value.number_float < rhs.m_value.number_float;
default:
return false;
@@ -20662,7 +18776,7 @@
instead; that is, replace calls like `j >> o;` with `o << j;`.
@since version 1.0.0; deprecated since version 3.0.0
*/
- JSON_HEDLEY_DEPRECATED(3.0.0)
+ JSON_DEPRECATED
friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
{
return o << j;
@@ -20741,7 +18855,7 @@
@since version 2.0.3 (contiguous containers)
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json parse(detail::input_adapter&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true)
@@ -20810,7 +18924,6 @@
@since version 3.2.0
*/
template <typename SAX>
- JSON_HEDLEY_NON_NULL(2)
static bool sax_parse(detail::input_adapter&& i, SAX* sax,
input_format_t format = input_format_t::json,
const bool strict = true)
@@ -20896,7 +19009,6 @@
std::is_base_of<
std::random_access_iterator_tag,
typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
- JSON_HEDLEY_NON_NULL(3)
static bool sax_parse(IteratorType first, IteratorType last, SAX* sax)
{
return parser(detail::input_adapter(first, last)).sax_parse(sax);
@@ -20910,7 +19022,7 @@
instead; that is, replace calls like `j << i;` with `i >> j;`.
@since version 1.0.0; deprecated since version 3.0.0
*/
- JSON_HEDLEY_DEPRECATED(3.0.0)
+ JSON_DEPRECATED
friend std::istream& operator<<(basic_json& j, std::istream& i)
{
return operator>>(i, j);
@@ -20983,7 +19095,6 @@
@since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
since 3.0.0
*/
- JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
{
@@ -21513,7 +19624,7 @@
@a strict parameter since 3.0.0; added @a allow_exceptions parameter
since 3.2.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_cbor(detail::input_adapter&& i,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21529,7 +19640,7 @@
*/
template<typename A1, typename A2,
detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_cbor(A1 && a1, A2 && a2,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21622,7 +19733,7 @@
@a strict parameter since 3.0.0; added @a allow_exceptions parameter
since 3.2.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_msgpack(detail::input_adapter&& i,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21638,7 +19749,7 @@
*/
template<typename A1, typename A2,
detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_msgpack(A1 && a1, A2 && a2,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21710,7 +19821,7 @@
@since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_ubjson(detail::input_adapter&& i,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21726,7 +19837,7 @@
*/
template<typename A1, typename A2,
detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_ubjson(A1 && a1, A2 && a2,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21797,7 +19908,7 @@
@sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
related UBJSON format
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_bson(detail::input_adapter&& i,
const bool strict = true,
const bool allow_exceptions = true)
@@ -21813,7 +19924,7 @@
*/
template<typename A1, typename A2,
detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json from_bson(A1 && a1, A2 && a2,
const bool strict = true,
const bool allow_exceptions = true)
@@ -22187,7 +20298,7 @@
else
{
const auto idx = json_pointer::array_index(last_path);
- if (JSON_HEDLEY_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
+ if (JSON_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
{
// avoid undefined behavior
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
@@ -22218,7 +20329,7 @@
{
// perform range check
auto it = parent.find(last_path);
- if (JSON_HEDLEY_LIKELY(it != parent.end()))
+ if (JSON_LIKELY(it != parent.end()))
{
parent.erase(it);
}
@@ -22235,7 +20346,7 @@
};
// type check: top level value must be an array
- if (JSON_HEDLEY_UNLIKELY(not json_patch.is_array()))
+ if (JSON_UNLIKELY(not json_patch.is_array()))
{
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
}
@@ -22255,13 +20366,13 @@
const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
// check if desired value is present
- if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
+ if (JSON_UNLIKELY(it == val.m_value.object->end()))
{
JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
}
// check if result is of type string
- if (JSON_HEDLEY_UNLIKELY(string_type and not it->second.is_string()))
+ if (JSON_UNLIKELY(string_type and not it->second.is_string()))
{
JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
}
@@ -22271,7 +20382,7 @@
};
// type check: every element of the array must be an object
- if (JSON_HEDLEY_UNLIKELY(not val.is_object()))
+ if (JSON_UNLIKELY(not val.is_object()))
{
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
}
@@ -22349,7 +20460,7 @@
}
// throw an exception if test fails
- if (JSON_HEDLEY_UNLIKELY(not success))
+ if (JSON_UNLIKELY(not success))
{
JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
}
@@ -22402,7 +20513,7 @@
@since version 2.0.0
*/
- JSON_HEDLEY_WARN_UNUSED_RESULT
+ JSON_NODISCARD
static basic_json diff(const basic_json& source, const basic_json& target,
const std::string& path = "")
{
@@ -22606,21 +20717,6 @@
/// @}
};
-
-/*!
-@brief user-defined to_string function for JSON values
-
-This function implements a user-defined to_string for JSON objects.
-
-@param[in] j a JSON object
-@return a std::string object
-*/
-
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
-{
- return j.dump();
-}
} // namespace nlohmann
///////////////////////
@@ -22652,7 +20748,7 @@
/// @note: do not remove the space after '<',
/// see https://github.com/nlohmann/json/pull/679
template<>
-struct less<::nlohmann::detail::value_t>
+struct less< ::nlohmann::detail::value_t>
{
/*!
@brief compare two value_t enum values
@@ -22694,7 +20790,6 @@
@since version 1.0.0
*/
-JSON_HEDLEY_NON_NULL(1)
inline nlohmann::json operator "" _json(const char* s, std::size_t n)
{
return nlohmann::json::parse(s, s + n);
@@ -22713,7 +20808,6 @@
@since version 2.0.0
*/
-JSON_HEDLEY_NON_NULL(1)
inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
{
return nlohmann::json::json_pointer(std::string(s, n));
@@ -22735,141 +20829,14 @@
#undef JSON_CATCH
#undef JSON_THROW
#undef JSON_TRY
+#undef JSON_LIKELY
+#undef JSON_UNLIKELY
+#undef JSON_DEPRECATED
+#undef JSON_NODISCARD
#undef JSON_HAS_CPP_14
#undef JSON_HAS_CPP_17
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
#undef NLOHMANN_BASIC_JSON_TPL
-// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
-#undef JSON_HEDLEY_ALWAYS_INLINE
-#undef JSON_HEDLEY_ARM_VERSION
-#undef JSON_HEDLEY_ARM_VERSION_CHECK
-#undef JSON_HEDLEY_ARRAY_PARAM
-#undef JSON_HEDLEY_ASSUME
-#undef JSON_HEDLEY_BEGIN_C_DECLS
-#undef JSON_HEDLEY_C_DECL
-#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
-#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
-#undef JSON_HEDLEY_CLANG_HAS_FEATURE
-#undef JSON_HEDLEY_CLANG_HAS_WARNING
-#undef JSON_HEDLEY_COMPCERT_VERSION
-#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
-#undef JSON_HEDLEY_CONCAT
-#undef JSON_HEDLEY_CONCAT_EX
-#undef JSON_HEDLEY_CONST
-#undef JSON_HEDLEY_CONST_CAST
-#undef JSON_HEDLEY_CONSTEXPR
-#undef JSON_HEDLEY_CPP_CAST
-#undef JSON_HEDLEY_CRAY_VERSION
-#undef JSON_HEDLEY_CRAY_VERSION_CHECK
-#undef JSON_HEDLEY_DEPRECATED
-#undef JSON_HEDLEY_DEPRECATED_FOR
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
-#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
-#undef JSON_HEDLEY_DIAGNOSTIC_POP
-#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
-#undef JSON_HEDLEY_DMC_VERSION
-#undef JSON_HEDLEY_DMC_VERSION_CHECK
-#undef JSON_HEDLEY_EMPTY_BASES
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
-#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
-#undef JSON_HEDLEY_END_C_DECLS
-#undef JSON_HEDLEY_FALL_THROUGH
-#undef JSON_HEDLEY_FLAGS
-#undef JSON_HEDLEY_FLAGS_CAST
-#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_BUILTIN
-#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_GCC_HAS_EXTENSION
-#undef JSON_HEDLEY_GCC_HAS_FEATURE
-#undef JSON_HEDLEY_GCC_HAS_WARNING
-#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
-#undef JSON_HEDLEY_GCC_VERSION
-#undef JSON_HEDLEY_GCC_VERSION_CHECK
-#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
-#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
-#undef JSON_HEDLEY_GNUC_HAS_FEATURE
-#undef JSON_HEDLEY_GNUC_HAS_WARNING
-#undef JSON_HEDLEY_GNUC_VERSION
-#undef JSON_HEDLEY_GNUC_VERSION_CHECK
-#undef JSON_HEDLEY_HAS_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_BUILTIN
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
-#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
-#undef JSON_HEDLEY_HAS_EXTENSION
-#undef JSON_HEDLEY_HAS_FEATURE
-#undef JSON_HEDLEY_HAS_WARNING
-#undef JSON_HEDLEY_IAR_VERSION
-#undef JSON_HEDLEY_IAR_VERSION_CHECK
-#undef JSON_HEDLEY_IBM_VERSION
-#undef JSON_HEDLEY_IBM_VERSION_CHECK
-#undef JSON_HEDLEY_IMPORT
-#undef JSON_HEDLEY_INLINE
-#undef JSON_HEDLEY_INTEL_VERSION
-#undef JSON_HEDLEY_INTEL_VERSION_CHECK
-#undef JSON_HEDLEY_IS_CONSTANT
-#undef JSON_HEDLEY_IS_CONSTEXPR_
-#undef JSON_HEDLEY_LIKELY
-#undef JSON_HEDLEY_MALLOC
-#undef JSON_HEDLEY_MESSAGE
-#undef JSON_HEDLEY_MSVC_VERSION
-#undef JSON_HEDLEY_MSVC_VERSION_CHECK
-#undef JSON_HEDLEY_NEVER_INLINE
-#undef JSON_HEDLEY_NO_ESCAPE
-#undef JSON_HEDLEY_NON_NULL
-#undef JSON_HEDLEY_NO_RETURN
-#undef JSON_HEDLEY_NO_THROW
-#undef JSON_HEDLEY_NULL
-#undef JSON_HEDLEY_PELLES_VERSION
-#undef JSON_HEDLEY_PELLES_VERSION_CHECK
-#undef JSON_HEDLEY_PGI_VERSION
-#undef JSON_HEDLEY_PGI_VERSION_CHECK
-#undef JSON_HEDLEY_PREDICT
-#undef JSON_HEDLEY_PRINTF_FORMAT
-#undef JSON_HEDLEY_PRIVATE
-#undef JSON_HEDLEY_PUBLIC
-#undef JSON_HEDLEY_PURE
-#undef JSON_HEDLEY_REINTERPRET_CAST
-#undef JSON_HEDLEY_REQUIRE
-#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
-#undef JSON_HEDLEY_REQUIRE_MSG
-#undef JSON_HEDLEY_RESTRICT
-#undef JSON_HEDLEY_RETURNS_NON_NULL
-#undef JSON_HEDLEY_SENTINEL
-#undef JSON_HEDLEY_STATIC_ASSERT
-#undef JSON_HEDLEY_STATIC_CAST
-#undef JSON_HEDLEY_STRINGIFY
-#undef JSON_HEDLEY_STRINGIFY_EX
-#undef JSON_HEDLEY_SUNPRO_VERSION
-#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
-#undef JSON_HEDLEY_TINYC_VERSION
-#undef JSON_HEDLEY_TINYC_VERSION_CHECK
-#undef JSON_HEDLEY_TI_VERSION
-#undef JSON_HEDLEY_TI_VERSION_CHECK
-#undef JSON_HEDLEY_UNAVAILABLE
-#undef JSON_HEDLEY_UNLIKELY
-#undef JSON_HEDLEY_UNPREDICTABLE
-#undef JSON_HEDLEY_UNREACHABLE
-#undef JSON_HEDLEY_UNREACHABLE_RETURN
-#undef JSON_HEDLEY_VERSION
-#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
-#undef JSON_HEDLEY_VERSION_DECODE_MINOR
-#undef JSON_HEDLEY_VERSION_DECODE_REVISION
-#undef JSON_HEDLEY_VERSION_ENCODE
-#undef JSON_HEDLEY_WARNING
-#undef JSON_HEDLEY_WARN_UNUSED_RESULT
-
-
#endif // INCLUDE_NLOHMANN_JSON_HPP_
