🛠️🐜 Antkeeper superbuild with dependencies included
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
22091 lines
785 KiB
22091 lines
785 KiB
/*
|
|
__ _____ _____ _____
|
|
__| | __| | | | JSON for Modern C++
|
|
| | |__ | | | | | | version 3.10.5
|
|
|_____|_____|_____|_|___| https://github.com/nlohmann/json
|
|
|
|
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
|
|
SPDX-License-Identifier: MIT
|
|
Copyright (c) 2013-2022 Niels Lohmann <http://nlohmann.me>.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
/****************************************************************************\
|
|
* Note on documentation: The source files contain links to the online *
|
|
* documentation of the public API at https://json.nlohmann.me. This URL *
|
|
* contains the most recent documentation and should also be applicable to *
|
|
* previous versions; documentation for deprecated functions is not *
|
|
* removed, but marked deprecated. See "Generate documentation" section in *
|
|
* file doc/README.md. *
|
|
\****************************************************************************/
|
|
|
|
#ifndef INCLUDE_NLOHMANN_JSON_HPP_
|
|
#define INCLUDE_NLOHMANN_JSON_HPP_
|
|
|
|
#define NLOHMANN_JSON_VERSION_MAJOR 3
|
|
#define NLOHMANN_JSON_VERSION_MINOR 10
|
|
#define NLOHMANN_JSON_VERSION_PATCH 5
|
|
|
|
#include <algorithm> // all_of, find, for_each
|
|
#include <cstddef> // nullptr_t, ptrdiff_t, size_t
|
|
#include <functional> // hash, less
|
|
#include <initializer_list> // initializer_list
|
|
#ifndef JSON_NO_IO
|
|
#include <iosfwd> // istream, ostream
|
|
#endif // JSON_NO_IO
|
|
#include <iterator> // random_access_iterator_tag
|
|
#include <memory> // unique_ptr
|
|
#include <numeric> // accumulate
|
|
#include <string> // string, stoi, to_string
|
|
#include <utility> // declval, forward, move, pair, swap
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/adl_serializer.hpp>
|
|
|
|
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
// #include <nlohmann/detail/conversions/from_json.hpp>
|
|
|
|
|
|
#include <algorithm> // transform
|
|
#include <array> // array
|
|
#include <forward_list> // forward_list
|
|
#include <iterator> // inserter, front_inserter, end
|
|
#include <map> // map
|
|
#include <string> // string
|
|
#include <tuple> // tuple, make_tuple
|
|
#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
|
|
#include <unordered_map> // unordered_map
|
|
#include <utility> // pair, declval
|
|
#include <valarray> // valarray
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
|
|
#include <exception> // exception
|
|
#include <stdexcept> // runtime_error
|
|
#include <string> // to_string
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
#include <array> // array
|
|
#include <cstddef> // size_t
|
|
#include <cstdint> // uint8_t
|
|
#include <string> // string
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
///////////////////////////
|
|
// JSON type enumeration //
|
|
///////////////////////////
|
|
|
|
/*!
|
|
@brief the JSON type enumeration
|
|
|
|
This enumeration collects the different JSON types. It is internally used to
|
|
distinguish the stored values, and the functions @ref basic_json::is_null(),
|
|
@ref basic_json::is_object(), @ref basic_json::is_array(),
|
|
@ref basic_json::is_string(), @ref basic_json::is_boolean(),
|
|
@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
|
|
@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
|
|
@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
|
|
@ref basic_json::is_structured() rely on it.
|
|
|
|
@note There are three enumeration entries (number_integer, number_unsigned, and
|
|
number_float), because the library distinguishes these three types for numbers:
|
|
@ref basic_json::number_unsigned_t is used for unsigned integers,
|
|
@ref basic_json::number_integer_t is used for signed integers, and
|
|
@ref basic_json::number_float_t is used for floating-point numbers or to
|
|
approximate integers which do not fit in the limits of their respective type.
|
|
|
|
@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
|
|
value with the default value for a given type
|
|
|
|
@since version 1.0.0
|
|
*/
|
|
enum class value_t : std::uint8_t
|
|
{
|
|
null, ///< null value
|
|
object, ///< object (unordered set of name/value pairs)
|
|
array, ///< array (ordered collection of values)
|
|
string, ///< string value
|
|
boolean, ///< boolean value
|
|
number_integer, ///< number value (signed integer)
|
|
number_unsigned, ///< number value (unsigned integer)
|
|
number_float, ///< number value (floating-point)
|
|
binary, ///< binary array (ordered collection of bytes)
|
|
discarded ///< discarded by the parser callback function
|
|
};
|
|
|
|
/*!
|
|
@brief comparison operator for JSON types
|
|
|
|
Returns an ordering that is similar to Python:
|
|
- order: null < boolean < number < object < array < string < binary
|
|
- furthermore, each type is not smaller than itself
|
|
- discarded values are not comparable
|
|
- binary is represented as a b"" string in python and directly comparable to a
|
|
string; however, making a binary array directly comparable with a string would
|
|
be surprising behavior in a JSON file.
|
|
|
|
@since version 1.0.0
|
|
*/
|
|
inline bool operator<(const value_t lhs, const value_t rhs) noexcept
|
|
{
|
|
static constexpr std::array<std::uint8_t, 9> order = {{
|
|
0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
|
|
1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
|
|
6 /* binary */
|
|
}
|
|
};
|
|
|
|
const auto l_index = static_cast<std::size_t>(lhs);
|
|
const auto r_index = static_cast<std::size_t>(rhs);
|
|
return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
|
|
}
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/string_escape.hpp>
|
|
|
|
|
|
#include <string>
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
#include <utility> // declval, 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 < 15)
|
|
#if defined(JSON_HEDLEY_VERSION)
|
|
#undef JSON_HEDLEY_VERSION
|
|
#endif
|
|
#define JSON_HEDLEY_VERSION 15
|
|
|
|
#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_CONCAT3_EX)
|
|
#undef JSON_HEDLEY_CONCAT3_EX
|
|
#endif
|
|
#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
|
|
|
|
#if defined(JSON_HEDLEY_CONCAT3)
|
|
#undef JSON_HEDLEY_CONCAT3
|
|
#endif
|
|
#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
|
|
|
|
#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) && !defined(__ICL)
|
|
#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) && !defined(__ICL)
|
|
#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) && !defined(__ICL)
|
|
#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(JSON_HEDLEY_MSVC_VERSION)
|
|
#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) && !defined(__ICL)
|
|
#define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
|
|
#elif defined(__INTEL_COMPILER) && !defined(__ICL)
|
|
#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_INTEL_CL_VERSION)
|
|
#undef JSON_HEDLEY_INTEL_CL_VERSION
|
|
#endif
|
|
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
|
|
#define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
|
|
#define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_INTEL_CL_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__) && \
|
|
( \
|
|
defined(__TMS470__) || defined(__TI_ARM__) || \
|
|
defined(__MSP430__) || \
|
|
defined(__TMS320C2000__) \
|
|
)
|
|
#if (__TI_COMPILER_VERSION__ >= 16000000)
|
|
#define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
#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_TI_CL2000_VERSION)
|
|
#undef JSON_HEDLEY_TI_CL2000_VERSION
|
|
#endif
|
|
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
|
|
#define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
|
|
#define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
|
|
#undef JSON_HEDLEY_TI_CL430_VERSION
|
|
#endif
|
|
#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
|
|
#define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_TI_CL430_VERSION)
|
|
#define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
|
|
#undef JSON_HEDLEY_TI_ARMCL_VERSION
|
|
#endif
|
|
#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
|
|
#define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
|
|
#define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
|
|
#undef JSON_HEDLEY_TI_CL6X_VERSION
|
|
#endif
|
|
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
|
|
#define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
|
|
#define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
|
|
#undef JSON_HEDLEY_TI_CL7X_VERSION
|
|
#endif
|
|
#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
|
|
#define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
|
|
#define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
|
|
#undef JSON_HEDLEY_TI_CLPRU_VERSION
|
|
#endif
|
|
#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
|
|
#define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
|
|
#define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_TI_CLPRU_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_MCST_LCC_VERSION)
|
|
#undef JSON_HEDLEY_MCST_LCC_VERSION
|
|
#endif
|
|
#if defined(__LCC__) && defined(__LCC_MINOR__)
|
|
#define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
|
|
#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
|
|
#endif
|
|
#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
|
|
#define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
|
|
#else
|
|
#define JSON_HEDLEY_MCST_LCC_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_CRAY_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_CL430_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
|
|
!defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
|
|
!defined(__COMPCERT__) && \
|
|
!defined(JSON_HEDLEY_MCST_LCC_VERSION)
|
|
#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) && \
|
|
( \
|
|
(!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
|
|
)
|
|
# 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) JSON_HEDLEY_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) JSON_HEDLEY_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_IAR_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
|
|
|
|
#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(15,12,0) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,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) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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(15,12,0) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,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
|
|
|
|
/* 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)
|
|
# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
|
|
# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
|
|
# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
|
|
# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
|
|
JSON_HEDLEY_DIAGNOSTIC_PUSH \
|
|
_Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
|
|
_Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
|
|
_Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
|
|
xpr \
|
|
JSON_HEDLEY_DIAGNOSTIC_POP
|
|
# else
|
|
# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
|
|
JSON_HEDLEY_DIAGNOSTIC_PUSH \
|
|
_Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
|
|
_Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
|
|
xpr \
|
|
JSON_HEDLEY_DIAGNOSTIC_POP
|
|
# endif
|
|
# else
|
|
# 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
|
|
# endif
|
|
# endif
|
|
#endif
|
|
#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
|
|
#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)
|
|
# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
|
|
# define JSON_HEDLEY_CPP_CAST(T, expr) \
|
|
JSON_HEDLEY_DIAGNOSTIC_PUSH \
|
|
_Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
|
|
((T) (expr)) \
|
|
JSON_HEDLEY_DIAGNOSTIC_POP
|
|
# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
|
|
# define JSON_HEDLEY_CPP_CAST(T, expr) \
|
|
JSON_HEDLEY_DIAGNOSTIC_PUSH \
|
|
_Pragma("diag_suppress=Pe137") \
|
|
JSON_HEDLEY_DIAGNOSTIC_POP
|
|
# else
|
|
# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
|
|
# endif
|
|
#else
|
|
# define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
|
|
#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_INTEL_CL_VERSION_CHECK(2021,1,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
|
|
#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
|
|
#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_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
|
|
#elif \
|
|
JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,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_INTEL_CL_VERSION_CHECK(2021,1,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(16,9,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
|
|
#elif JSON_HEDLEY_TI_CL6X_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")
|
|
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
|
|
#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_INTEL_CL_VERSION_CHECK(2021,1,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(20,7,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
|
|
#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(18,1,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
|
|
#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
|
|
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
|
|
#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_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
|
|
#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
|
|
#endif
|
|
#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
|
|
#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
|
|
#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
|
|
#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
|
|
#else
|
|
#define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
|
|
#endif
|
|
|
|
#if defined(JSON_HEDLEY_DEPRECATED)
|
|
#undef JSON_HEDLEY_DEPRECATED
|
|
#endif
|
|
#if defined(JSON_HEDLEY_DEPRECATED_FOR)
|
|
#undef JSON_HEDLEY_DEPRECATED_FOR
|
|
#endif
|
|
#if \
|
|
JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
|
|
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(18,1,0) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
|
|
#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
|
|
#elif 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_ATTRIBUTE(deprecated) || \
|
|
JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
|
|
JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
|
|
JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
|
|
JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
|
|
#define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
|
|
#define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
|
|
#elif \
|
|
JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
|
|
JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
|
|
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
|
|
#endif
|
|
#if \
|
|
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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
(JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
|
|
JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
|
|
#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
|
|
#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
|
|
#elif defined(_Check_return_) /* SAL */
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
|
|
#else
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
#define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
|
|
#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) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
|
|
#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) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
|
|
#define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
|
|
#elif JSON_HEDLEY_TI_CL6X_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 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) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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_CL2000_VERSION_CHECK(6,2,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
|
|
#if defined(__cplusplus)
|
|
#define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
|
|
#else
|
|
#define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
|
|
#endif
|
|
#endif
|
|
#if \
|
|
(JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
|
|
JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
|
|
JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
|
|
JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
|
|
JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
|
|
JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
|
|
#elif defined(JSON_HEDLEY_ASSUME)
|
|
#define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
|
|
#endif
|
|
#if !defined(JSON_HEDLEY_ASSUME)
|
|
#if defined(JSON_HEDLEY_UNREACHABLE)
|
|
#define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
|
|
#else
|
|
#define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
|
|
#endif
|
|
#endif
|
|
#if defined(JSON_HEDLEY_UNREACHABLE)
|
|
#if \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
|
|
#define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
|
|
#else
|
|
#define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
|
|
#endif
|
|
#else
|
|
#define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
|
|
#endif
|
|
#if !defined(JSON_HEDLEY_UNREACHABLE)
|
|
#define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
|
|
#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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
|
|
JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
# 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 )
|
|
#elif \
|
|
(JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
|
|
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(15,12,0) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
|
|
JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
# define JSON_HEDLEY_PREDICT(expr, expected, probability) \
|
|
(((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
|
|
# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
|
|
(__extension__ ({ \
|
|
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__ ({ \
|
|
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) (JSON_HEDLEY_STATIC_CAST(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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
# 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 defined(__cplusplus) && \
|
|
( \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
|
|
)
|
|
# 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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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_INTEL_CL_VERSION_CHECK(2021,1,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_CL430_VERSION_CHECK(4,3,0) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
(JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
|
|
JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
|
|
defined(__clang__) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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_INTEL_CL_VERSION_CHECK(2021,1,0) || \
|
|
JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
|
|
JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
|
|
# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
|
|
#elif \
|
|
JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
|
|
# define JSON_HEDLEY_ALWAYS_INLINE __forceinline
|
|
#elif defined(__cplusplus) && \
|
|
( \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
|
|
)
|
|
# 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(15,12,0) || \
|
|
(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
|
|
(JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
|
|
(JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
|
|
JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
|
|
JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
|
|
JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
|
|
#define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
|
|
#elif \
|
|
JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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_CL6X_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) || \
|
|
( \
|
|
defined(__TI_EABI__) && \
|
|
( \
|
|
(JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
|
|
JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
|
|
) \
|
|
) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
# 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) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
|
|
#elif \
|
|
JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,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_HAS_ATTRIBUTE(fallthrough) || \
|
|
JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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_CL6X_VERSION_CHECK(6,1,0) || \
|
|
(JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
|
|
JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
|
|
JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
|
|
#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) && \
|
|
!defined(JSON_HEDLEY_IAR_VERSION)) || \
|
|
(JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
|
|
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_ARMCL_VERSION) || \
|
|
JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
|
|
defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
|
|
defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
|
|
defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
|
|
defined(JSON_HEDLEY_TI_CLPRU_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) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
|
|
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) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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_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) || \
|
|
JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
|
|
# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
|
|
#elif \
|
|
JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
|
|
#define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
|
|
#else
|
|
#define JSON_HEDLEY_FLAGS
|
|
#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)) || \
|
|
JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,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) */
|
|
|
|
// #include <nlohmann/detail/meta/detected.hpp>
|
|
|
|
|
|
#include <type_traits>
|
|
|
|
// #include <nlohmann/detail/meta/void_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename ...Ts> struct make_void
|
|
{
|
|
using type = void;
|
|
};
|
|
template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
|
|
// https://en.cppreference.com/w/cpp/experimental/is_detected
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
struct nonesuch
|
|
{
|
|
nonesuch() = delete;
|
|
~nonesuch() = delete;
|
|
nonesuch(nonesuch const&) = delete;
|
|
nonesuch(nonesuch const&&) = delete;
|
|
void operator=(nonesuch const&) = delete;
|
|
void operator=(nonesuch&&) = delete;
|
|
};
|
|
|
|
template<class Default,
|
|
class AlwaysVoid,
|
|
template<class...> class Op,
|
|
class... Args>
|
|
struct detector
|
|
{
|
|
using value_t = std::false_type;
|
|
using type = Default;
|
|
};
|
|
|
|
template<class Default, template<class...> class Op, class... Args>
|
|
struct detector<Default, void_t<Op<Args...>>, Op, Args...>
|
|
{
|
|
using value_t = std::true_type;
|
|
using type = Op<Args...>;
|
|
};
|
|
|
|
template<template<class...> class Op, class... Args>
|
|
using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
|
|
|
|
template<template<class...> class Op, class... Args>
|
|
struct is_detected_lazy : is_detected<Op, Args...> { };
|
|
|
|
template<template<class...> class Op, class... Args>
|
|
using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
|
|
|
|
template<class Default, template<class...> class Op, class... Args>
|
|
using detected_or = detector<Default, void, Op, Args...>;
|
|
|
|
template<class Default, template<class...> class Op, class... Args>
|
|
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
|
|
|
|
template<class Expected, template<class...> class Op, class... Args>
|
|
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
|
|
|
|
template<class To, template<class...> class Op, class... Args>
|
|
using is_detected_convertible =
|
|
std::is_convertible<detected_t<Op, Args...>, To>;
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
|
|
// 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 the user manually specified the used c++ version this is skipped
|
|
#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
|
|
#if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
|
|
#define JSON_HAS_CPP_20
|
|
#define JSON_HAS_CPP_17
|
|
#define JSON_HAS_CPP_14
|
|
#elif (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
|
|
// the cpp 11 flag is always specified because it is the minimal required version
|
|
#define JSON_HAS_CPP_11
|
|
#endif
|
|
|
|
#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
|
|
#ifdef JSON_HAS_CPP_17
|
|
#if defined(__cpp_lib_filesystem)
|
|
#define JSON_HAS_FILESYSTEM 1
|
|
#elif defined(__cpp_lib_experimental_filesystem)
|
|
#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
|
|
#elif !defined(__has_include)
|
|
#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
|
|
#elif __has_include(<filesystem>)
|
|
#define JSON_HAS_FILESYSTEM 1
|
|
#elif __has_include(<experimental/filesystem>)
|
|
#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
|
|
#endif
|
|
|
|
// std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
|
|
#if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#endif
|
|
|
|
// no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
|
|
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#endif
|
|
|
|
// no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
|
|
#if defined(__clang_major__) && __clang_major__ < 7
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#endif
|
|
|
|
// no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
|
|
#if defined(_MSC_VER) && _MSC_VER < 1940
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#endif
|
|
|
|
// no filesystem support before iOS 13
|
|
#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#endif
|
|
|
|
// no filesystem support before macOS Catalina
|
|
#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
|
|
#endif
|
|
|
|
#ifndef JSON_HAS_FILESYSTEM
|
|
#define JSON_HAS_FILESYSTEM 0
|
|
#endif
|
|
|
|
// disable documentation warnings on clang
|
|
#if defined(__clang__)
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wdocumentation"
|
|
#pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
|
|
#endif
|
|
|
|
// allow disabling 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
|
|
|
|
// allow overriding assert
|
|
#if !defined(JSON_ASSERT)
|
|
#include <cassert> // assert
|
|
#define JSON_ASSERT(x) assert(x)
|
|
#endif
|
|
|
|
// allow to access some private functions (needed by the test suite)
|
|
#if defined(JSON_TESTS_PRIVATE)
|
|
#define JSON_PRIVATE_UNLESS_TESTED public
|
|
#else
|
|
#define JSON_PRIVATE_UNLESS_TESTED private
|
|
#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, \
|
|
class BinaryType>
|
|
|
|
#define NLOHMANN_BASIC_JSON_TPL \
|
|
basic_json<ObjectType, ArrayType, StringType, BooleanType, \
|
|
NumberIntegerType, NumberUnsignedType, NumberFloatType, \
|
|
AllocatorType, JSONSerializer, BinaryType>
|
|
|
|
// Macros to simplify conversion from/to types
|
|
|
|
#define NLOHMANN_JSON_EXPAND( x ) x
|
|
#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
|
|
#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
|
|
NLOHMANN_JSON_PASTE64, \
|
|
NLOHMANN_JSON_PASTE63, \
|
|
NLOHMANN_JSON_PASTE62, \
|
|
NLOHMANN_JSON_PASTE61, \
|
|
NLOHMANN_JSON_PASTE60, \
|
|
NLOHMANN_JSON_PASTE59, \
|
|
NLOHMANN_JSON_PASTE58, \
|
|
NLOHMANN_JSON_PASTE57, \
|
|
NLOHMANN_JSON_PASTE56, \
|
|
NLOHMANN_JSON_PASTE55, \
|
|
NLOHMANN_JSON_PASTE54, \
|
|
NLOHMANN_JSON_PASTE53, \
|
|
NLOHMANN_JSON_PASTE52, \
|
|
NLOHMANN_JSON_PASTE51, \
|
|
NLOHMANN_JSON_PASTE50, \
|
|
NLOHMANN_JSON_PASTE49, \
|
|
NLOHMANN_JSON_PASTE48, \
|
|
NLOHMANN_JSON_PASTE47, \
|
|
NLOHMANN_JSON_PASTE46, \
|
|
NLOHMANN_JSON_PASTE45, \
|
|
NLOHMANN_JSON_PASTE44, \
|
|
NLOHMANN_JSON_PASTE43, \
|
|
NLOHMANN_JSON_PASTE42, \
|
|
NLOHMANN_JSON_PASTE41, \
|
|
NLOHMANN_JSON_PASTE40, \
|
|
NLOHMANN_JSON_PASTE39, \
|
|
NLOHMANN_JSON_PASTE38, \
|
|
NLOHMANN_JSON_PASTE37, \
|
|
NLOHMANN_JSON_PASTE36, \
|
|
NLOHMANN_JSON_PASTE35, \
|
|
NLOHMANN_JSON_PASTE34, \
|
|
NLOHMANN_JSON_PASTE33, \
|
|
NLOHMANN_JSON_PASTE32, \
|
|
NLOHMANN_JSON_PASTE31, \
|
|
NLOHMANN_JSON_PASTE30, \
|
|
NLOHMANN_JSON_PASTE29, \
|
|
NLOHMANN_JSON_PASTE28, \
|
|
NLOHMANN_JSON_PASTE27, \
|
|
NLOHMANN_JSON_PASTE26, \
|
|
NLOHMANN_JSON_PASTE25, \
|
|
NLOHMANN_JSON_PASTE24, \
|
|
NLOHMANN_JSON_PASTE23, \
|
|
NLOHMANN_JSON_PASTE22, \
|
|
NLOHMANN_JSON_PASTE21, \
|
|
NLOHMANN_JSON_PASTE20, \
|
|
NLOHMANN_JSON_PASTE19, \
|
|
NLOHMANN_JSON_PASTE18, \
|
|
NLOHMANN_JSON_PASTE17, \
|
|
NLOHMANN_JSON_PASTE16, \
|
|
NLOHMANN_JSON_PASTE15, \
|
|
NLOHMANN_JSON_PASTE14, \
|
|
NLOHMANN_JSON_PASTE13, \
|
|
NLOHMANN_JSON_PASTE12, \
|
|
NLOHMANN_JSON_PASTE11, \
|
|
NLOHMANN_JSON_PASTE10, \
|
|
NLOHMANN_JSON_PASTE9, \
|
|
NLOHMANN_JSON_PASTE8, \
|
|
NLOHMANN_JSON_PASTE7, \
|
|
NLOHMANN_JSON_PASTE6, \
|
|
NLOHMANN_JSON_PASTE5, \
|
|
NLOHMANN_JSON_PASTE4, \
|
|
NLOHMANN_JSON_PASTE3, \
|
|
NLOHMANN_JSON_PASTE2, \
|
|
NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
|
|
#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
|
|
#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
|
|
#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
|
|
#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
|
|
#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
|
|
#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
|
|
#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
|
|
#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
|
|
#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
|
|
#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
|
|
#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
|
|
#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
|
|
#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
|
|
#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
|
|
#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
|
|
#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
|
|
#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
|
|
#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
|
|
#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
|
|
#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
|
|
#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
|
|
#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
|
|
#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
|
|
#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
|
|
#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
|
|
#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
|
|
#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
|
|
#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
|
|
#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
|
|
#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
|
|
#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
|
|
#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
|
|
#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
|
|
#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
|
|
#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
|
|
#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
|
|
#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
|
|
#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
|
|
#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
|
|
#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
|
|
#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
|
|
#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
|
|
#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
|
|
#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
|
|
#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
|
|
#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
|
|
#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
|
|
#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
|
|
#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
|
|
#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
|
|
#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
|
|
#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
|
|
#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
|
|
#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
|
|
#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
|
|
#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
|
|
#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
|
|
#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
|
|
#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
|
|
#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
|
|
#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
|
|
#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
|
|
#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
|
|
|
|
#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
|
|
#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
|
|
|
|
/*!
|
|
@brief macro
|
|
@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
|
|
@since version 3.9.0
|
|
*/
|
|
#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
|
|
friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
|
|
friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
|
|
|
|
/*!
|
|
@brief macro
|
|
@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
|
|
@since version 3.9.0
|
|
*/
|
|
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
|
|
inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
|
|
inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
|
|
|
|
|
|
// inspired from https://stackoverflow.com/a/26745591
|
|
// allows to call any std function as if (e.g. with begin):
|
|
// using std::begin; begin(x);
|
|
//
|
|
// it allows using the detected idiom to retrieve the return type
|
|
// of such an expression
|
|
#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \
|
|
namespace detail { \
|
|
using std::std_name; \
|
|
\
|
|
template<typename... T> \
|
|
using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
|
|
} \
|
|
\
|
|
namespace detail2 { \
|
|
struct std_name##_tag \
|
|
{ \
|
|
}; \
|
|
\
|
|
template<typename... T> \
|
|
std_name##_tag std_name(T&&...); \
|
|
\
|
|
template<typename... T> \
|
|
using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
|
|
\
|
|
template<typename... T> \
|
|
struct would_call_std_##std_name \
|
|
{ \
|
|
static constexpr auto const value = ::nlohmann::detail:: \
|
|
is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
|
|
}; \
|
|
} /* namespace detail2 */ \
|
|
\
|
|
template<typename... T> \
|
|
struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...> \
|
|
{ \
|
|
}
|
|
|
|
#ifndef JSON_USE_IMPLICIT_CONVERSIONS
|
|
#define JSON_USE_IMPLICIT_CONVERSIONS 1
|
|
#endif
|
|
|
|
#if JSON_USE_IMPLICIT_CONVERSIONS
|
|
#define JSON_EXPLICIT
|
|
#else
|
|
#define JSON_EXPLICIT explicit
|
|
#endif
|
|
|
|
#ifndef JSON_DIAGNOSTICS
|
|
#define JSON_DIAGNOSTICS 0
|
|
#endif
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
|
|
/*!
|
|
@brief replace all occurrences of a substring by another string
|
|
|
|
@param[in,out] s the string to manipulate; changed so that all
|
|
occurrences of @a f are replaced with @a t
|
|
@param[in] f the substring to replace with @a t
|
|
@param[in] t the string to replace @a f
|
|
|
|
@pre The search string @a f must not be empty. **This precondition is
|
|
enforced with an assertion.**
|
|
|
|
@since version 2.0.0
|
|
*/
|
|
inline void replace_substring(std::string& s, const std::string& f,
|
|
const std::string& t)
|
|
{
|
|
JSON_ASSERT(!f.empty());
|
|
for (auto pos = s.find(f); // find first occurrence of f
|
|
pos != std::string::npos; // make sure f was found
|
|
s.replace(pos, f.size(), t), // replace with t, and
|
|
pos = s.find(f, pos + t.size())) // find next occurrence of f
|
|
{}
|
|
}
|
|
|
|
/*!
|
|
* @brief string escaping as described in RFC 6901 (Sect. 4)
|
|
* @param[in] s string to escape
|
|
* @return escaped string
|
|
*
|
|
* Note the order of escaping "~" to "~0" and "/" to "~1" is important.
|
|
*/
|
|
inline std::string escape(std::string s)
|
|
{
|
|
replace_substring(s, "~", "~0");
|
|
replace_substring(s, "/", "~1");
|
|
return s;
|
|
}
|
|
|
|
/*!
|
|
* @brief string unescaping as described in RFC 6901 (Sect. 4)
|
|
* @param[in] s string to unescape
|
|
* @return unescaped string
|
|
*
|
|
* Note the order of escaping "~1" to "/" and "~0" to "~" is important.
|
|
*/
|
|
static void unescape(std::string& s)
|
|
{
|
|
replace_substring(s, "~1", "/");
|
|
replace_substring(s, "~0", "~");
|
|
}
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/input/position_t.hpp>
|
|
|
|
|
|
#include <cstddef> // size_t
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
/// struct to capture the start position of the current token
|
|
struct position_t
|
|
{
|
|
/// the total number of characters read
|
|
std::size_t chars_read_total = 0;
|
|
/// the number of characters read in the current line
|
|
std::size_t chars_read_current_line = 0;
|
|
/// the number of lines read
|
|
std::size_t lines_read = 0;
|
|
|
|
/// conversion to size_t to preserve SAX interface
|
|
constexpr operator size_t() const
|
|
{
|
|
return chars_read_total;
|
|
}
|
|
};
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
////////////////
|
|
// exceptions //
|
|
////////////////
|
|
|
|
/// @brief general exception of the @ref basic_json class
|
|
/// @sa https://json.nlohmann.me/api/basic_json/exception/
|
|
class exception : public std::exception
|
|
{
|
|
public:
|
|
/// returns the explanatory string
|
|
const char* what() const noexcept override
|
|
{
|
|
return m.what();
|
|
}
|
|
|
|
/// the id of the exception
|
|
const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
|
|
|
|
protected:
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
|
|
|
|
static std::string name(const std::string& ename, int id_)
|
|
{
|
|
return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static std::string diagnostics(const BasicJsonType& leaf_element)
|
|
{
|
|
#if JSON_DIAGNOSTICS
|
|
std::vector<std::string> tokens;
|
|
for (const auto* current = &leaf_element; current->m_parent != nullptr; current = current->m_parent)
|
|
{
|
|
switch (current->m_parent->type())
|
|
{
|
|
case value_t::array:
|
|
{
|
|
for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
|
|
{
|
|
if (¤t->m_parent->m_value.array->operator[](i) == current)
|
|
{
|
|
tokens.emplace_back(std::to_string(i));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
for (const auto& element : *current->m_parent->m_value.object)
|
|
{
|
|
if (&element.second == current)
|
|
{
|
|
tokens.emplace_back(element.first.c_str());
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::null: // LCOV_EXCL_LINE
|
|
case value_t::string: // LCOV_EXCL_LINE
|
|
case value_t::boolean: // LCOV_EXCL_LINE
|
|
case value_t::number_integer: // LCOV_EXCL_LINE
|
|
case value_t::number_unsigned: // LCOV_EXCL_LINE
|
|
case value_t::number_float: // LCOV_EXCL_LINE
|
|
case value_t::binary: // LCOV_EXCL_LINE
|
|
case value_t::discarded: // LCOV_EXCL_LINE
|
|
default: // LCOV_EXCL_LINE
|
|
break; // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
if (tokens.empty())
|
|
{
|
|
return "";
|
|
}
|
|
|
|
return "(" + std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
|
|
[](const std::string & a, const std::string & b)
|
|
{
|
|
return a + "/" + detail::escape(b);
|
|
}) + ") ";
|
|
#else
|
|
static_cast<void>(leaf_element);
|
|
return "";
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
/// an exception object as storage for error messages
|
|
std::runtime_error m;
|
|
};
|
|
|
|
/// @brief exception indicating a parse error
|
|
/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
|
|
class parse_error : public exception
|
|
{
|
|
public:
|
|
/*!
|
|
@brief create a parse error exception
|
|
@param[in] id_ the id of the exception
|
|
@param[in] pos the position where the error occurred (or with
|
|
chars_read_total=0 if the position cannot be
|
|
determined)
|
|
@param[in] what_arg the explanatory string
|
|
@return parse_error object
|
|
*/
|
|
template<typename BasicJsonType>
|
|
static parse_error create(int id_, const position_t& pos, const std::string& what_arg, const BasicJsonType& context)
|
|
{
|
|
std::string w = exception::name("parse_error", id_) + "parse error" +
|
|
position_string(pos) + ": " + exception::diagnostics(context) + what_arg;
|
|
return {id_, pos.chars_read_total, w.c_str()};
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, const BasicJsonType& context)
|
|
{
|
|
std::string w = exception::name("parse_error", id_) + "parse error" +
|
|
(byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
|
|
": " + exception::diagnostics(context) + what_arg;
|
|
return {id_, byte_, w.c_str()};
|
|
}
|
|
|
|
/*!
|
|
@brief byte index of the parse error
|
|
|
|
The byte index of the last read character in the input file.
|
|
|
|
@note For an input with n bytes, 1 is the index of the first character and
|
|
n+1 is the index of the terminating null byte or the end of file.
|
|
This also holds true when reading a byte vector (CBOR or MessagePack).
|
|
*/
|
|
const std::size_t byte;
|
|
|
|
private:
|
|
parse_error(int id_, std::size_t byte_, const char* what_arg)
|
|
: exception(id_, what_arg), byte(byte_) {}
|
|
|
|
static std::string position_string(const position_t& pos)
|
|
{
|
|
return " at line " + std::to_string(pos.lines_read + 1) +
|
|
", column " + std::to_string(pos.chars_read_current_line);
|
|
}
|
|
};
|
|
|
|
/// @brief exception indicating errors with iterators
|
|
/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
|
|
class invalid_iterator : public exception
|
|
{
|
|
public:
|
|
template<typename BasicJsonType>
|
|
static invalid_iterator create(int id_, const std::string& what_arg, const BasicJsonType& context)
|
|
{
|
|
std::string w = exception::name("invalid_iterator", id_) + exception::diagnostics(context) + what_arg;
|
|
return {id_, w.c_str()};
|
|
}
|
|
|
|
private:
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
invalid_iterator(int id_, const char* what_arg)
|
|
: exception(id_, what_arg) {}
|
|
};
|
|
|
|
/// @brief exception indicating executing a member function with a wrong type
|
|
/// @sa https://json.nlohmann.me/api/basic_json/type_error/
|
|
class type_error : public exception
|
|
{
|
|
public:
|
|
template<typename BasicJsonType>
|
|
static type_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
|
|
{
|
|
std::string w = exception::name("type_error", id_) + exception::diagnostics(context) + what_arg;
|
|
return {id_, w.c_str()};
|
|
}
|
|
|
|
private:
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
|
|
};
|
|
|
|
/// @brief exception indicating access out of the defined range
|
|
/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
|
|
class out_of_range : public exception
|
|
{
|
|
public:
|
|
template<typename BasicJsonType>
|
|
static out_of_range create(int id_, const std::string& what_arg, const BasicJsonType& context)
|
|
{
|
|
std::string w = exception::name("out_of_range", id_) + exception::diagnostics(context) + what_arg;
|
|
return {id_, w.c_str()};
|
|
}
|
|
|
|
private:
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
|
|
};
|
|
|
|
/// @brief exception indicating other library errors
|
|
/// @sa https://json.nlohmann.me/api/basic_json/other_error/
|
|
class other_error : public exception
|
|
{
|
|
public:
|
|
template<typename BasicJsonType>
|
|
static other_error create(int id_, const std::string& what_arg, const BasicJsonType& context)
|
|
{
|
|
std::string w = exception::name("other_error", id_) + exception::diagnostics(context) + what_arg;
|
|
return {id_, w.c_str()};
|
|
}
|
|
|
|
private:
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
|
|
};
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
|
|
#include <cstddef> // size_t
|
|
#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
|
|
#include <utility> // index_sequence, make_index_sequence, index_sequence_for
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
|
|
template<typename T>
|
|
using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
|
|
|
|
#ifdef JSON_HAS_CPP_14
|
|
|
|
// the following utilities are natively available in C++14
|
|
using std::enable_if_t;
|
|
using std::index_sequence;
|
|
using std::make_index_sequence;
|
|
using std::index_sequence_for;
|
|
|
|
#else
|
|
|
|
// alias templates to reduce boilerplate
|
|
template<bool B, typename T = void>
|
|
using enable_if_t = typename std::enable_if<B, T>::type;
|
|
|
|
// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
|
|
// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
|
|
|
|
//// START OF CODE FROM GOOGLE ABSEIL
|
|
|
|
// integer_sequence
|
|
//
|
|
// Class template representing a compile-time integer sequence. An instantiation
|
|
// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
|
|
// type through its template arguments (which is a common need when
|
|
// working with C++11 variadic templates). `absl::integer_sequence` is designed
|
|
// to be a drop-in replacement for C++14's `std::integer_sequence`.
|
|
//
|
|
// Example:
|
|
//
|
|
// template< class T, T... Ints >
|
|
// void user_function(integer_sequence<T, Ints...>);
|
|
//
|
|
// int main()
|
|
// {
|
|
// // user_function's `T` will be deduced to `int` and `Ints...`
|
|
// // will be deduced to `0, 1, 2, 3, 4`.
|
|
// user_function(make_integer_sequence<int, 5>());
|
|
// }
|
|
template <typename T, T... Ints>
|
|
struct integer_sequence
|
|
{
|
|
using value_type = T;
|
|
static constexpr std::size_t size() noexcept
|
|
{
|
|
return sizeof...(Ints);
|
|
}
|
|
};
|
|
|
|
// index_sequence
|
|
//
|
|
// A helper template for an `integer_sequence` of `size_t`,
|
|
// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
|
|
// `std::index_sequence`.
|
|
template <size_t... Ints>
|
|
using index_sequence = integer_sequence<size_t, Ints...>;
|
|
|
|
namespace utility_internal
|
|
{
|
|
|
|
template <typename Seq, size_t SeqSize, size_t Rem>
|
|
struct Extend;
|
|
|
|
// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
|
|
template <typename T, T... Ints, size_t SeqSize>
|
|
struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
|
|
{
|
|
using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
|
|
};
|
|
|
|
template <typename T, T... Ints, size_t SeqSize>
|
|
struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
|
|
{
|
|
using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
|
|
};
|
|
|
|
// Recursion helper for 'make_integer_sequence<T, N>'.
|
|
// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
|
|
template <typename T, size_t N>
|
|
struct Gen
|
|
{
|
|
using type =
|
|
typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
|
|
};
|
|
|
|
template <typename T>
|
|
struct Gen<T, 0>
|
|
{
|
|
using type = integer_sequence<T>;
|
|
};
|
|
|
|
} // namespace utility_internal
|
|
|
|
// Compile-time sequences of integers
|
|
|
|
// make_integer_sequence
|
|
//
|
|
// This template alias is equivalent to
|
|
// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
|
|
// replacement for C++14's `std::make_integer_sequence`.
|
|
template <typename T, T N>
|
|
using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
|
|
|
|
// make_index_sequence
|
|
//
|
|
// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
|
|
// and is designed to be a drop-in replacement for C++14's
|
|
// `std::make_index_sequence`.
|
|
template <size_t N>
|
|
using make_index_sequence = make_integer_sequence<size_t, N>;
|
|
|
|
// index_sequence_for
|
|
//
|
|
// Converts a typename pack into an index sequence of the same length, and
|
|
// is designed to be a drop-in replacement for C++14's
|
|
// `std::index_sequence_for()`
|
|
template <typename... Ts>
|
|
using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
|
|
|
|
//// END OF CODE FROM GOOGLE ABSEIL
|
|
|
|
#endif
|
|
|
|
// dispatch utility (taken from ranges-v3)
|
|
template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
|
|
template<> struct priority_tag<0> {};
|
|
|
|
// taken from ranges-v3
|
|
template<typename T>
|
|
struct static_const
|
|
{
|
|
static constexpr T value{};
|
|
};
|
|
|
|
template<typename T>
|
|
constexpr T static_const<T>::value; // NOLINT(readability-redundant-declaration)
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/identity_tag.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
// dispatching helper struct
|
|
template <class T> struct identity_tag {};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
|
|
#include <limits> // numeric_limits
|
|
#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
|
|
#include <utility> // declval
|
|
#include <tuple> // tuple
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
// #include <nlohmann/detail/iterators/iterator_traits.hpp>
|
|
|
|
|
|
#include <iterator> // random_access_iterator_tag
|
|
|
|
// #include <nlohmann/detail/meta/void_t.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename It, typename = void>
|
|
struct iterator_types {};
|
|
|
|
template<typename It>
|
|
struct iterator_types <
|
|
It,
|
|
void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
|
|
typename It::reference, typename It::iterator_category >>
|
|
{
|
|
using difference_type = typename It::difference_type;
|
|
using value_type = typename It::value_type;
|
|
using pointer = typename It::pointer;
|
|
using reference = typename It::reference;
|
|
using iterator_category = typename It::iterator_category;
|
|
};
|
|
|
|
// This is required as some compilers implement std::iterator_traits in a way that
|
|
// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
|
|
template<typename T, typename = void>
|
|
struct iterator_traits
|
|
{
|
|
};
|
|
|
|
template<typename T>
|
|
struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
|
|
: iterator_types<T>
|
|
{
|
|
};
|
|
|
|
template<typename T>
|
|
struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
|
|
{
|
|
using iterator_category = std::random_access_iterator_tag;
|
|
using value_type = T;
|
|
using difference_type = ptrdiff_t;
|
|
using pointer = T*;
|
|
using reference = T&;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/call_std/begin.hpp>
|
|
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/call_std/end.hpp>
|
|
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/detected.hpp>
|
|
|
|
// #include <nlohmann/json_fwd.hpp>
|
|
#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
|
|
#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
|
|
|
|
#include <cstdint> // int64_t, uint64_t
|
|
#include <map> // map
|
|
#include <memory> // allocator
|
|
#include <string> // string
|
|
#include <vector> // vector
|
|
|
|
/*!
|
|
@brief namespace for Niels Lohmann
|
|
@see https://github.com/nlohmann
|
|
@since version 1.0.0
|
|
*/
|
|
namespace nlohmann
|
|
{
|
|
/*!
|
|
@brief default JSONSerializer template argument
|
|
|
|
This serializer ignores the template arguments and uses ADL
|
|
([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
|
|
for serialization.
|
|
*/
|
|
template<typename T = void, typename SFINAE = void>
|
|
struct adl_serializer;
|
|
|
|
/// a class to store JSON values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/
|
|
template<template<typename U, typename V, typename... Args> class ObjectType =
|
|
std::map,
|
|
template<typename U, typename... Args> class ArrayType = std::vector,
|
|
class StringType = std::string, class BooleanType = bool,
|
|
class NumberIntegerType = std::int64_t,
|
|
class NumberUnsignedType = std::uint64_t,
|
|
class NumberFloatType = double,
|
|
template<typename U> class AllocatorType = std::allocator,
|
|
template<typename T, typename SFINAE = void> class JSONSerializer =
|
|
adl_serializer,
|
|
class BinaryType = std::vector<std::uint8_t>>
|
|
class basic_json;
|
|
|
|
/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/
|
|
template<typename BasicJsonType>
|
|
class json_pointer;
|
|
|
|
/*!
|
|
@brief default specialization
|
|
@sa https://json.nlohmann.me/api/json/
|
|
*/
|
|
using json = basic_json<>;
|
|
|
|
/// @brief a minimal map-like container that preserves insertion order
|
|
/// @sa https://json.nlohmann.me/api/ordered_map/
|
|
template<class Key, class T, class IgnoredLess, class Allocator>
|
|
struct ordered_map;
|
|
|
|
/// @brief specialization that maintains the insertion order of object keys
|
|
/// @sa https://json.nlohmann.me/api/ordered_json/
|
|
using ordered_json = basic_json<nlohmann::ordered_map>;
|
|
|
|
} // namespace nlohmann
|
|
|
|
#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
/*!
|
|
@brief detail namespace with internal helper functions
|
|
|
|
This namespace collects functions that should not be exposed,
|
|
implementations of some @ref basic_json methods, and meta-programming helpers.
|
|
|
|
@since version 2.1.0
|
|
*/
|
|
namespace detail
|
|
{
|
|
/////////////
|
|
// helpers //
|
|
/////////////
|
|
|
|
// Note to maintainers:
|
|
//
|
|
// Every trait in this file expects a non CV-qualified type.
|
|
// The only exceptions are in the 'aliases for detected' section
|
|
// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
|
|
//
|
|
// In this case, T has to be properly CV-qualified to constraint the function arguments
|
|
// (e.g. to_json(BasicJsonType&, const T&))
|
|
|
|
template<typename> struct is_basic_json : std::false_type {};
|
|
|
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
|
|
|
|
//////////////////////
|
|
// json_ref helpers //
|
|
//////////////////////
|
|
|
|
template<typename>
|
|
class json_ref;
|
|
|
|
template<typename>
|
|
struct is_json_ref : std::false_type {};
|
|
|
|
template<typename T>
|
|
struct is_json_ref<json_ref<T>> : std::true_type {};
|
|
|
|
//////////////////////////
|
|
// aliases for detected //
|
|
//////////////////////////
|
|
|
|
template<typename T>
|
|
using mapped_type_t = typename T::mapped_type;
|
|
|
|
template<typename T>
|
|
using key_type_t = typename T::key_type;
|
|
|
|
template<typename T>
|
|
using value_type_t = typename T::value_type;
|
|
|
|
template<typename T>
|
|
using difference_type_t = typename T::difference_type;
|
|
|
|
template<typename T>
|
|
using pointer_t = typename T::pointer;
|
|
|
|
template<typename T>
|
|
using reference_t = typename T::reference;
|
|
|
|
template<typename T>
|
|
using iterator_category_t = typename T::iterator_category;
|
|
|
|
template<typename T, typename... Args>
|
|
using to_json_function = decltype(T::to_json(std::declval<Args>()...));
|
|
|
|
template<typename T, typename... Args>
|
|
using from_json_function = decltype(T::from_json(std::declval<Args>()...));
|
|
|
|
template<typename T, typename U>
|
|
using get_template_function = decltype(std::declval<T>().template get<U>());
|
|
|
|
// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
|
|
template<typename BasicJsonType, typename T, typename = void>
|
|
struct has_from_json : std::false_type {};
|
|
|
|
// trait checking if j.get<T> is valid
|
|
// use this trait instead of std::is_constructible or std::is_convertible,
|
|
// both rely on, or make use of implicit conversions, and thus fail when T
|
|
// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
|
|
template <typename BasicJsonType, typename T>
|
|
struct is_getable
|
|
{
|
|
static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename T>
|
|
struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
|
|
{
|
|
using serializer = typename BasicJsonType::template json_serializer<T, void>;
|
|
|
|
static constexpr bool value =
|
|
is_detected_exact<void, from_json_function, serializer,
|
|
const BasicJsonType&, T&>::value;
|
|
};
|
|
|
|
// This trait checks if JSONSerializer<T>::from_json(json const&) exists
|
|
// this overload is used for non-default-constructible user-defined-types
|
|
template<typename BasicJsonType, typename T, typename = void>
|
|
struct has_non_default_from_json : std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename T>
|
|
struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
|
|
{
|
|
using serializer = typename BasicJsonType::template json_serializer<T, void>;
|
|
|
|
static constexpr bool value =
|
|
is_detected_exact<T, from_json_function, serializer,
|
|
const BasicJsonType&>::value;
|
|
};
|
|
|
|
// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
|
|
// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
|
|
template<typename BasicJsonType, typename T, typename = void>
|
|
struct has_to_json : std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename T>
|
|
struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
|
|
{
|
|
using serializer = typename BasicJsonType::template json_serializer<T, void>;
|
|
|
|
static constexpr bool value =
|
|
is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
|
|
T>::value;
|
|
};
|
|
|
|
|
|
///////////////////
|
|
// is_ functions //
|
|
///////////////////
|
|
|
|
// 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 {};
|
|
|
|
// https://en.cppreference.com/w/cpp/types/negation
|
|
template<class B> struct negation : std::integral_constant < bool, !B::value > { };
|
|
|
|
// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
|
|
// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
|
|
// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
|
|
template <typename T>
|
|
struct is_default_constructible : std::is_default_constructible<T> {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct is_default_constructible<std::pair<T1, T2>>
|
|
: conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct is_default_constructible<const std::pair<T1, T2>>
|
|
: conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
|
|
|
|
template <typename... Ts>
|
|
struct is_default_constructible<std::tuple<Ts...>>
|
|
: conjunction<is_default_constructible<Ts>...> {};
|
|
|
|
template <typename... Ts>
|
|
struct is_default_constructible<const std::tuple<Ts...>>
|
|
: conjunction<is_default_constructible<Ts>...> {};
|
|
|
|
|
|
template <typename T, typename... Args>
|
|
struct is_constructible : std::is_constructible<T, Args...> {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
|
|
|
|
template <typename T1, typename T2>
|
|
struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
|
|
|
|
template <typename... Ts>
|
|
struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
|
|
|
|
template <typename... Ts>
|
|
struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
|
|
|
|
|
|
template<typename T, typename = void>
|
|
struct is_iterator_traits : std::false_type {};
|
|
|
|
template<typename T>
|
|
struct is_iterator_traits<iterator_traits<T>>
|
|
{
|
|
private:
|
|
using traits = iterator_traits<T>;
|
|
|
|
public:
|
|
static constexpr auto value =
|
|
is_detected<value_type_t, traits>::value &&
|
|
is_detected<difference_type_t, traits>::value &&
|
|
is_detected<pointer_t, traits>::value &&
|
|
is_detected<iterator_category_t, traits>::value &&
|
|
is_detected<reference_t, traits>::value;
|
|
};
|
|
|
|
template<typename T>
|
|
struct is_range
|
|
{
|
|
private:
|
|
using t_ref = typename std::add_lvalue_reference<T>::type;
|
|
|
|
using iterator = detected_t<result_of_begin, t_ref>;
|
|
using sentinel = detected_t<result_of_end, t_ref>;
|
|
|
|
// to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
|
|
// and https://en.cppreference.com/w/cpp/iterator/sentinel_for
|
|
// but reimplementing these would be too much work, as a lot of other concepts are used underneath
|
|
static constexpr auto is_iterator_begin =
|
|
is_iterator_traits<iterator_traits<iterator>>::value;
|
|
|
|
public:
|
|
static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
|
|
};
|
|
|
|
template<typename R>
|
|
using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
|
|
|
|
template<typename T>
|
|
using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
|
|
|
|
// The following implementation of is_complete_type is taken from
|
|
// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
|
|
// and is written by Xiang Fan who agreed to using it in this library.
|
|
|
|
template<typename T, typename = void>
|
|
struct is_complete_type : std::false_type {};
|
|
|
|
template<typename T>
|
|
struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
|
|
|
|
template<typename BasicJsonType, typename CompatibleObjectType,
|
|
typename = void>
|
|
struct is_compatible_object_type_impl : std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename CompatibleObjectType>
|
|
struct is_compatible_object_type_impl <
|
|
BasicJsonType, CompatibleObjectType,
|
|
enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
|
|
is_detected<key_type_t, CompatibleObjectType>::value >>
|
|
{
|
|
using object_t = typename BasicJsonType::object_t;
|
|
|
|
// macOS's is_constructible does not play well with nonesuch...
|
|
static constexpr bool value =
|
|
is_constructible<typename object_t::key_type,
|
|
typename CompatibleObjectType::key_type>::value &&
|
|
is_constructible<typename object_t::mapped_type,
|
|
typename CompatibleObjectType::mapped_type>::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename CompatibleObjectType>
|
|
struct is_compatible_object_type
|
|
: is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleObjectType,
|
|
typename = void>
|
|
struct is_constructible_object_type_impl : std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleObjectType>
|
|
struct is_constructible_object_type_impl <
|
|
BasicJsonType, ConstructibleObjectType,
|
|
enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
|
|
is_detected<key_type_t, ConstructibleObjectType>::value >>
|
|
{
|
|
using object_t = typename BasicJsonType::object_t;
|
|
|
|
static constexpr bool value =
|
|
(is_default_constructible<ConstructibleObjectType>::value &&
|
|
(std::is_move_assignable<ConstructibleObjectType>::value ||
|
|
std::is_copy_assignable<ConstructibleObjectType>::value) &&
|
|
(is_constructible<typename ConstructibleObjectType::key_type,
|
|
typename object_t::key_type>::value &&
|
|
std::is_same <
|
|
typename object_t::mapped_type,
|
|
typename ConstructibleObjectType::mapped_type >::value)) ||
|
|
(has_from_json<BasicJsonType,
|
|
typename ConstructibleObjectType::mapped_type>::value ||
|
|
has_non_default_from_json <
|
|
BasicJsonType,
|
|
typename ConstructibleObjectType::mapped_type >::value);
|
|
};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleObjectType>
|
|
struct is_constructible_object_type
|
|
: is_constructible_object_type_impl<BasicJsonType,
|
|
ConstructibleObjectType> {};
|
|
|
|
template<typename BasicJsonType, typename CompatibleStringType>
|
|
struct is_compatible_string_type
|
|
{
|
|
static constexpr auto value =
|
|
is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleStringType>
|
|
struct is_constructible_string_type
|
|
{
|
|
static constexpr auto value =
|
|
is_constructible<ConstructibleStringType,
|
|
typename BasicJsonType::string_t>::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
|
|
struct is_compatible_array_type_impl : std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename CompatibleArrayType>
|
|
struct is_compatible_array_type_impl <
|
|
BasicJsonType, CompatibleArrayType,
|
|
enable_if_t <
|
|
is_detected<iterator_t, CompatibleArrayType>::value&&
|
|
is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
|
|
// special case for types like std::filesystem::path whose iterator's value_type are themselves
|
|
// c.f. https://github.com/nlohmann/json/pull/3073
|
|
!std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
|
|
{
|
|
static constexpr bool value =
|
|
is_constructible<BasicJsonType,
|
|
range_value_t<CompatibleArrayType>>::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename CompatibleArrayType>
|
|
struct is_compatible_array_type
|
|
: is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
|
|
struct is_constructible_array_type_impl : std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleArrayType>
|
|
struct is_constructible_array_type_impl <
|
|
BasicJsonType, ConstructibleArrayType,
|
|
enable_if_t<std::is_same<ConstructibleArrayType,
|
|
typename BasicJsonType::value_type>::value >>
|
|
: std::true_type {};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleArrayType>
|
|
struct is_constructible_array_type_impl <
|
|
BasicJsonType, ConstructibleArrayType,
|
|
enable_if_t < !std::is_same<ConstructibleArrayType,
|
|
typename BasicJsonType::value_type>::value&&
|
|
!is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
|
|
is_default_constructible<ConstructibleArrayType>::value&&
|
|
(std::is_move_assignable<ConstructibleArrayType>::value ||
|
|
std::is_copy_assignable<ConstructibleArrayType>::value)&&
|
|
is_detected<iterator_t, ConstructibleArrayType>::value&&
|
|
is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
|
|
is_detected<range_value_t, ConstructibleArrayType>::value&&
|
|
// special case for types like std::filesystem::path whose iterator's value_type are themselves
|
|
// c.f. https://github.com/nlohmann/json/pull/3073
|
|
!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
|
|
is_complete_type <
|
|
detected_t<range_value_t, ConstructibleArrayType >>::value >>
|
|
{
|
|
using value_type = range_value_t<ConstructibleArrayType>;
|
|
|
|
static constexpr bool value =
|
|
std::is_same<value_type,
|
|
typename BasicJsonType::array_t::value_type>::value ||
|
|
has_from_json<BasicJsonType,
|
|
value_type>::value ||
|
|
has_non_default_from_json <
|
|
BasicJsonType,
|
|
value_type >::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename ConstructibleArrayType>
|
|
struct is_constructible_array_type
|
|
: is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
|
|
|
|
template<typename RealIntegerType, typename CompatibleNumberIntegerType,
|
|
typename = void>
|
|
struct is_compatible_integer_type_impl : std::false_type {};
|
|
|
|
template<typename RealIntegerType, typename CompatibleNumberIntegerType>
|
|
struct is_compatible_integer_type_impl <
|
|
RealIntegerType, CompatibleNumberIntegerType,
|
|
enable_if_t < std::is_integral<RealIntegerType>::value&&
|
|
std::is_integral<CompatibleNumberIntegerType>::value&&
|
|
!std::is_same<bool, CompatibleNumberIntegerType>::value >>
|
|
{
|
|
// is there an assert somewhere on overflows?
|
|
using RealLimits = std::numeric_limits<RealIntegerType>;
|
|
using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
|
|
|
|
static constexpr auto value =
|
|
is_constructible<RealIntegerType,
|
|
CompatibleNumberIntegerType>::value &&
|
|
CompatibleLimits::is_integer &&
|
|
RealLimits::is_signed == CompatibleLimits::is_signed;
|
|
};
|
|
|
|
template<typename RealIntegerType, typename CompatibleNumberIntegerType>
|
|
struct is_compatible_integer_type
|
|
: is_compatible_integer_type_impl<RealIntegerType,
|
|
CompatibleNumberIntegerType> {};
|
|
|
|
template<typename BasicJsonType, typename CompatibleType, typename = void>
|
|
struct is_compatible_type_impl: std::false_type {};
|
|
|
|
template<typename BasicJsonType, typename CompatibleType>
|
|
struct is_compatible_type_impl <
|
|
BasicJsonType, CompatibleType,
|
|
enable_if_t<is_complete_type<CompatibleType>::value >>
|
|
{
|
|
static constexpr bool value =
|
|
has_to_json<BasicJsonType, CompatibleType>::value;
|
|
};
|
|
|
|
template<typename BasicJsonType, typename CompatibleType>
|
|
struct is_compatible_type
|
|
: is_compatible_type_impl<BasicJsonType, CompatibleType> {};
|
|
|
|
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<is_constructible<T1, Args>...> {};
|
|
|
|
// a naive helper to check if a type is an ordered_map (exploits the fact that
|
|
// ordered_map inherits capacity() from std::vector)
|
|
template <typename T>
|
|
struct is_ordered_map
|
|
{
|
|
using one = char;
|
|
|
|
struct two
|
|
{
|
|
char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
};
|
|
|
|
template <typename C> static one test( decltype(&C::capacity) ) ;
|
|
template <typename C> static two test(...);
|
|
|
|
enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
};
|
|
|
|
// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
|
|
template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
|
|
T conditional_static_cast(U value)
|
|
{
|
|
return static_cast<T>(value);
|
|
}
|
|
|
|
template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
|
|
T conditional_static_cast(U value)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#include <experimental/filesystem>
|
|
namespace nlohmann::detail
|
|
{
|
|
namespace std_fs = std::experimental::filesystem;
|
|
} // namespace nlohmann::detail
|
|
#elif JSON_HAS_FILESYSTEM
|
|
#include <filesystem>
|
|
namespace nlohmann::detail
|
|
{
|
|
namespace std_fs = std::filesystem;
|
|
} // namespace nlohmann::detail
|
|
#endif
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name()), j));
|
|
}
|
|
n = nullptr;
|
|
}
|
|
|
|
// overloads for basic_json template parameters
|
|
template < typename BasicJsonType, typename ArithmeticType,
|
|
enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
|
|
!std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
|
|
int > = 0 >
|
|
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
|
|
{
|
|
switch (static_cast<value_t>(j))
|
|
{
|
|
case value_t::number_unsigned:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
|
|
break;
|
|
}
|
|
case value_t::number_integer:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
|
|
break;
|
|
}
|
|
case value_t::number_float:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::object:
|
|
case value_t::array:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
|
|
}
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name()), j));
|
|
}
|
|
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
|
|
}
|
|
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
|
|
}
|
|
|
|
template <
|
|
typename BasicJsonType, typename ConstructibleStringType,
|
|
enable_if_t <
|
|
is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
|
|
!std::is_same<typename BasicJsonType::string_t,
|
|
ConstructibleStringType>::value,
|
|
int > = 0 >
|
|
void from_json(const BasicJsonType& j, ConstructibleStringType& s)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
|
|
}
|
|
|
|
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
|
|
{
|
|
get_arithmetic_value(j, val);
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
|
|
{
|
|
get_arithmetic_value(j, val);
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
|
|
{
|
|
get_arithmetic_value(j, val);
|
|
}
|
|
|
|
template<typename BasicJsonType, typename EnumType,
|
|
enable_if_t<std::is_enum<EnumType>::value, int> = 0>
|
|
void from_json(const BasicJsonType& j, EnumType& e)
|
|
{
|
|
typename std::underlying_type<EnumType>::type val;
|
|
get_arithmetic_value(j, val);
|
|
e = static_cast<EnumType>(val);
|
|
}
|
|
|
|
// forward_list doesn't have an insert method
|
|
template<typename BasicJsonType, typename T, typename Allocator,
|
|
enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
|
|
void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
l.clear();
|
|
std::transform(j.rbegin(), j.rend(),
|
|
std::front_inserter(l), [](const BasicJsonType & i)
|
|
{
|
|
return i.template get<T>();
|
|
});
|
|
}
|
|
|
|
// valarray doesn't have an insert method
|
|
template<typename BasicJsonType, typename T,
|
|
enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
|
|
void from_json(const BasicJsonType& j, std::valarray<T>& l)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
l.resize(j.size());
|
|
std::transform(j.begin(), j.end(), std::begin(l),
|
|
[](const BasicJsonType & elem)
|
|
{
|
|
return elem.template get<T>();
|
|
});
|
|
}
|
|
|
|
template<typename BasicJsonType, typename T, std::size_t N>
|
|
auto from_json(const BasicJsonType& j, T (&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
-> decltype(j.template get<T>(), void())
|
|
{
|
|
for (std::size_t i = 0; i < N; ++i)
|
|
{
|
|
arr[i] = j.at(i).template get<T>();
|
|
}
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
|
|
{
|
|
arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
|
|
}
|
|
|
|
template<typename BasicJsonType, typename T, std::size_t N>
|
|
auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
|
|
priority_tag<2> /*unused*/)
|
|
-> decltype(j.template get<T>(), void())
|
|
{
|
|
for (std::size_t i = 0; i < N; ++i)
|
|
{
|
|
arr[i] = j.at(i).template get<T>();
|
|
}
|
|
}
|
|
|
|
template<typename BasicJsonType, typename ConstructibleArrayType,
|
|
enable_if_t<
|
|
std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
|
|
int> = 0>
|
|
auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
|
|
-> decltype(
|
|
arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
|
|
j.template get<typename ConstructibleArrayType::value_type>(),
|
|
void())
|
|
{
|
|
using std::end;
|
|
|
|
ConstructibleArrayType ret;
|
|
ret.reserve(j.size());
|
|
std::transform(j.begin(), j.end(),
|
|
std::inserter(ret, end(ret)), [](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,
|
|
enable_if_t<
|
|
std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
|
|
int> = 0>
|
|
void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
|
|
priority_tag<0> /*unused*/)
|
|
{
|
|
using std::end;
|
|
|
|
ConstructibleArrayType ret;
|
|
std::transform(
|
|
j.begin(), j.end(), std::inserter(ret, end(ret)),
|
|
[](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,
|
|
enable_if_t <
|
|
is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
|
|
!is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
|
|
!is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
|
|
!std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
|
|
!is_basic_json<ConstructibleArrayType>::value,
|
|
int > = 0 >
|
|
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
|
|
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
|
|
j.template get<typename ConstructibleArrayType::value_type>(),
|
|
void())
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
|
|
from_json_array_impl(j, arr, priority_tag<3> {});
|
|
}
|
|
|
|
template < typename BasicJsonType, typename T, std::size_t... Idx >
|
|
std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
|
|
identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
|
|
{
|
|
return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
|
|
}
|
|
|
|
template < typename BasicJsonType, typename T, std::size_t N >
|
|
auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
|
|
-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
|
|
return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name()), j));
|
|
}
|
|
|
|
bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
|
|
}
|
|
|
|
template<typename BasicJsonType, typename ConstructibleObjectType,
|
|
enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
|
|
void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name()), j));
|
|
}
|
|
|
|
ConstructibleObjectType ret;
|
|
const 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()),
|
|
[](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
|
|
// (BooleanType, etc..); note: Is it really necessary to provide explicit
|
|
// overloads for boolean_t etc. in case of a custom BooleanType which is not
|
|
// an arithmetic type?
|
|
template < typename BasicJsonType, typename ArithmeticType,
|
|
enable_if_t <
|
|
std::is_arithmetic<ArithmeticType>::value&&
|
|
!std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
|
|
!std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
|
|
!std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
|
|
!std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
|
|
int > = 0 >
|
|
void from_json(const BasicJsonType& j, ArithmeticType& val)
|
|
{
|
|
switch (static_cast<value_t>(j))
|
|
{
|
|
case value_t::number_unsigned:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
|
|
break;
|
|
}
|
|
case value_t::number_integer:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
|
|
break;
|
|
}
|
|
case value_t::number_float:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
|
|
break;
|
|
}
|
|
case value_t::boolean:
|
|
{
|
|
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::object:
|
|
case value_t::array:
|
|
case value_t::string:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name()), j));
|
|
}
|
|
}
|
|
|
|
template<typename BasicJsonType, typename... Args, std::size_t... Idx>
|
|
std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
|
|
{
|
|
return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
|
|
}
|
|
|
|
template < typename BasicJsonType, class A1, class A2 >
|
|
std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
|
|
{
|
|
return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
|
|
std::forward<BasicJsonType>(j).at(1).template get<A2>()};
|
|
}
|
|
|
|
template<typename BasicJsonType, typename A1, typename A2>
|
|
void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
|
|
{
|
|
p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
|
|
}
|
|
|
|
template<typename BasicJsonType, typename... Args>
|
|
std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
|
|
{
|
|
return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
|
|
}
|
|
|
|
template<typename BasicJsonType, typename... Args>
|
|
void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
|
|
{
|
|
t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
|
|
}
|
|
|
|
template<typename BasicJsonType, typename TupleRelated>
|
|
auto from_json(BasicJsonType&& j, TupleRelated&& t)
|
|
-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
|
|
return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
|
|
}
|
|
|
|
template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
|
|
typename = enable_if_t < !std::is_constructible <
|
|
typename BasicJsonType::string_t, Key >::value >>
|
|
void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
m.clear();
|
|
for (const auto& p : j)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
|
|
}
|
|
m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
|
|
}
|
|
}
|
|
|
|
template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
|
|
typename = enable_if_t < !std::is_constructible <
|
|
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(!j.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name()), j));
|
|
}
|
|
m.clear();
|
|
for (const auto& p : j)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name()), j));
|
|
}
|
|
m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
|
|
}
|
|
}
|
|
|
|
#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
template<typename BasicJsonType>
|
|
void from_json(const BasicJsonType& j, std_fs::path& p)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name()), j));
|
|
}
|
|
p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
|
|
}
|
|
#endif
|
|
|
|
struct from_json_fn
|
|
{
|
|
template<typename BasicJsonType, typename T>
|
|
auto operator()(const BasicJsonType& j, T&& val) const
|
|
noexcept(noexcept(from_json(j, std::forward<T>(val))))
|
|
-> decltype(from_json(j, std::forward<T>(val)))
|
|
{
|
|
return from_json(j, std::forward<T>(val));
|
|
}
|
|
};
|
|
} // namespace detail
|
|
|
|
/// namespace to hold default `from_json` function
|
|
/// to see why this is required:
|
|
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
|
|
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
|
|
{
|
|
constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value; // NOLINT(misc-definitions-in-headers)
|
|
} // namespace
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/conversions/to_json.hpp>
|
|
|
|
|
|
#include <algorithm> // copy
|
|
#include <iterator> // begin, end
|
|
#include <string> // string
|
|
#include <tuple> // tuple, get
|
|
#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
|
|
#include <utility> // move, forward, declval, pair
|
|
#include <valarray> // valarray
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
|
|
|
|
|
|
#include <cstddef> // size_t
|
|
#include <iterator> // input_iterator_tag
|
|
#include <string> // string, to_string
|
|
#include <tuple> // tuple_size, get, tuple_element
|
|
#include <utility> // move
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename string_type>
|
|
void int_to_string( string_type& target, std::size_t value )
|
|
{
|
|
// For ADL
|
|
using std::to_string;
|
|
target = to_string(value);
|
|
}
|
|
template<typename IteratorType> class iteration_proxy_value
|
|
{
|
|
public:
|
|
using difference_type = std::ptrdiff_t;
|
|
using value_type = iteration_proxy_value;
|
|
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
|
|
IteratorType anchor;
|
|
/// an index for arrays (used to create key names)
|
|
std::size_t array_index = 0;
|
|
/// 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";
|
|
/// an empty string (to return a reference for primitive values)
|
|
const string_type empty_str{};
|
|
|
|
public:
|
|
explicit iteration_proxy_value(IteratorType it) noexcept
|
|
: anchor(std::move(it))
|
|
{}
|
|
|
|
/// dereference operator (needed for range-based for)
|
|
iteration_proxy_value& operator*()
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
/// increment operator (needed for range-based for)
|
|
iteration_proxy_value& operator++()
|
|
{
|
|
++anchor;
|
|
++array_index;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// equality operator (needed for InputIterator)
|
|
bool operator==(const iteration_proxy_value& o) const
|
|
{
|
|
return anchor == o.anchor;
|
|
}
|
|
|
|
/// inequality operator (needed for range-based for)
|
|
bool operator!=(const iteration_proxy_value& o) const
|
|
{
|
|
return anchor != o.anchor;
|
|
}
|
|
|
|
/// return key of the iterator
|
|
const string_type& key() const
|
|
{
|
|
JSON_ASSERT(anchor.m_object != nullptr);
|
|
|
|
switch (anchor.m_object->type())
|
|
{
|
|
// use integer array index as key
|
|
case value_t::array:
|
|
{
|
|
if (array_index != array_index_last)
|
|
{
|
|
int_to_string( array_index_str, array_index );
|
|
array_index_last = array_index;
|
|
}
|
|
return array_index_str;
|
|
}
|
|
|
|
// use key from the object
|
|
case value_t::object:
|
|
return anchor.key();
|
|
|
|
// use an empty key for all primitive types
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
return empty_str;
|
|
}
|
|
}
|
|
|
|
/// return value of the iterator
|
|
typename IteratorType::reference value() const
|
|
{
|
|
return anchor.value();
|
|
}
|
|
};
|
|
|
|
/// proxy class for the items() function
|
|
template<typename IteratorType> class iteration_proxy
|
|
{
|
|
private:
|
|
/// the container to iterate
|
|
typename IteratorType::reference container;
|
|
|
|
public:
|
|
/// construct iteration proxy from a container
|
|
explicit iteration_proxy(typename IteratorType::reference cont) noexcept
|
|
: container(cont) {}
|
|
|
|
/// return iterator begin (needed for range-based for)
|
|
iteration_proxy_value<IteratorType> begin() noexcept
|
|
{
|
|
return iteration_proxy_value<IteratorType>(container.begin());
|
|
}
|
|
|
|
/// return iterator end (needed for range-based for)
|
|
iteration_proxy_value<IteratorType> end() noexcept
|
|
{
|
|
return iteration_proxy_value<IteratorType>(container.end());
|
|
}
|
|
};
|
|
// Structured Bindings Support
|
|
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
|
|
// And see https://github.com/nlohmann/json/pull/1391
|
|
template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
|
|
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
|
|
{
|
|
return i.key();
|
|
}
|
|
// Structured Bindings Support
|
|
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
|
|
// And see https://github.com/nlohmann/json/pull/1391
|
|
template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
|
|
auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
|
|
{
|
|
return i.value();
|
|
}
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// The Addition to the STD Namespace is required to add
|
|
// Structured Bindings Support to the iteration_proxy_value class
|
|
// For further reference see https://blog.tartanllama.xyz/structured-bindings/
|
|
// And see https://github.com/nlohmann/json/pull/1391
|
|
namespace std
|
|
{
|
|
#if defined(__clang__)
|
|
// Fix: https://github.com/nlohmann/json/issues/1401
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wmismatched-tags"
|
|
#endif
|
|
template<typename IteratorType>
|
|
class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
|
|
: public std::integral_constant<std::size_t, 2> {};
|
|
|
|
template<std::size_t N, typename IteratorType>
|
|
class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
|
|
{
|
|
public:
|
|
using type = decltype(
|
|
get<N>(std::declval <
|
|
::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
|
|
};
|
|
#if defined(__clang__)
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
} // namespace std
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#include <experimental/filesystem>
|
|
namespace nlohmann::detail
|
|
{
|
|
namespace std_fs = std::experimental::filesystem;
|
|
} // namespace nlohmann::detail
|
|
#elif JSON_HAS_FILESYSTEM
|
|
#include <filesystem>
|
|
namespace nlohmann::detail
|
|
{
|
|
namespace std_fs = std::filesystem;
|
|
} // namespace nlohmann::detail
|
|
#endif
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
//////////////////
|
|
// constructors //
|
|
//////////////////
|
|
|
|
/*
|
|
* Note all external_constructor<>::construct functions need to call
|
|
* j.m_value.destroy(j.m_type) to avoid a memory leak in case j contains an
|
|
* allocated value (e.g., a string). See bug issue
|
|
* https://github.com/nlohmann/json/issues/2865 for more information.
|
|
*/
|
|
|
|
template<value_t> struct external_constructor;
|
|
|
|
template<>
|
|
struct external_constructor<value_t::boolean>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::boolean;
|
|
j.m_value = b;
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::string>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::string;
|
|
j.m_value = s;
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::string;
|
|
j.m_value = std::move(s);
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template < typename BasicJsonType, typename CompatibleStringType,
|
|
enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
|
|
int > = 0 >
|
|
static void construct(BasicJsonType& j, const CompatibleStringType& str)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::string;
|
|
j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::binary>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::binary;
|
|
j.m_value = typename BasicJsonType::binary_t(b);
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::binary;
|
|
j.m_value = typename BasicJsonType::binary_t(std::move(b));
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::number_float>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::number_float;
|
|
j.m_value = val;
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::number_unsigned>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::number_unsigned;
|
|
j.m_value = val;
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::number_integer>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::number_integer;
|
|
j.m_value = val;
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::array>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::array;
|
|
j.m_value = arr;
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::array;
|
|
j.m_value = std::move(arr);
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template < typename BasicJsonType, typename CompatibleArrayType,
|
|
enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
|
|
int > = 0 >
|
|
static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
|
|
{
|
|
using std::begin;
|
|
using std::end;
|
|
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::array;
|
|
j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, const std::vector<bool>& arr)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::array;
|
|
j.m_value = value_t::array;
|
|
j.m_value.array->reserve(arr.size());
|
|
for (const bool x : arr)
|
|
{
|
|
j.m_value.array->push_back(x);
|
|
j.set_parent(j.m_value.array->back());
|
|
}
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template<typename BasicJsonType, typename T,
|
|
enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
|
|
static void construct(BasicJsonType& j, const std::valarray<T>& arr)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
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());
|
|
}
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct external_constructor<value_t::object>
|
|
{
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::object;
|
|
j.m_value = obj;
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
|
|
{
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::object;
|
|
j.m_value = std::move(obj);
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
|
|
template < typename BasicJsonType, typename CompatibleObjectType,
|
|
enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
|
|
static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
|
|
{
|
|
using std::begin;
|
|
using std::end;
|
|
|
|
j.m_value.destroy(j.m_type);
|
|
j.m_type = value_t::object;
|
|
j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
|
|
j.set_parents();
|
|
j.assert_invariant();
|
|
}
|
|
};
|
|
|
|
/////////////
|
|
// to_json //
|
|
/////////////
|
|
|
|
template<typename BasicJsonType, typename T,
|
|
enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, T b) noexcept
|
|
{
|
|
external_constructor<value_t::boolean>::construct(j, b);
|
|
}
|
|
|
|
template<typename BasicJsonType, typename CompatibleString,
|
|
enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, const CompatibleString& s)
|
|
{
|
|
external_constructor<value_t::string>::construct(j, s);
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
|
|
{
|
|
external_constructor<value_t::string>::construct(j, std::move(s));
|
|
}
|
|
|
|
template<typename BasicJsonType, typename FloatType,
|
|
enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, FloatType val) noexcept
|
|
{
|
|
external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
|
|
}
|
|
|
|
template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
|
|
enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
|
|
{
|
|
external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
|
|
}
|
|
|
|
template<typename BasicJsonType, typename CompatibleNumberIntegerType,
|
|
enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
|
|
{
|
|
external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
|
|
}
|
|
|
|
template<typename BasicJsonType, typename EnumType,
|
|
enable_if_t<std::is_enum<EnumType>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, EnumType e) noexcept
|
|
{
|
|
using underlying_type = typename std::underlying_type<EnumType>::type;
|
|
external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void to_json(BasicJsonType& j, const std::vector<bool>& e)
|
|
{
|
|
external_constructor<value_t::array>::construct(j, e);
|
|
}
|
|
|
|
template < typename BasicJsonType, typename CompatibleArrayType,
|
|
enable_if_t < is_compatible_array_type<BasicJsonType,
|
|
CompatibleArrayType>::value&&
|
|
!is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
|
|
!is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
|
|
!std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
|
|
!is_basic_json<CompatibleArrayType>::value,
|
|
int > = 0 >
|
|
void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
|
|
{
|
|
external_constructor<value_t::array>::construct(j, arr);
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
|
|
{
|
|
external_constructor<value_t::binary>::construct(j, bin);
|
|
}
|
|
|
|
template<typename BasicJsonType, typename T,
|
|
enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, const std::valarray<T>& arr)
|
|
{
|
|
external_constructor<value_t::array>::construct(j, std::move(arr));
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
|
|
{
|
|
external_constructor<value_t::array>::construct(j, std::move(arr));
|
|
}
|
|
|
|
template < typename BasicJsonType, typename CompatibleObjectType,
|
|
enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
|
|
void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
|
|
{
|
|
external_constructor<value_t::object>::construct(j, obj);
|
|
}
|
|
|
|
template<typename BasicJsonType>
|
|
void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
|
|
{
|
|
external_constructor<value_t::object>::construct(j, std::move(obj));
|
|
}
|
|
|
|
template <
|
|
typename BasicJsonType, typename T, std::size_t N,
|
|
enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
|
|
const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
int > = 0 >
|
|
void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
{
|
|
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)
|
|
{
|
|
j = { p.first, p.second };
|
|
}
|
|
|
|
// for https://github.com/nlohmann/json/pull/1134
|
|
template<typename BasicJsonType, typename T,
|
|
enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
|
|
void to_json(BasicJsonType& j, const T& b)
|
|
{
|
|
j = { {b.key(), b.value()} };
|
|
}
|
|
|
|
template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
|
|
void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
|
|
{
|
|
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)
|
|
{
|
|
to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
|
|
}
|
|
|
|
#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
template<typename BasicJsonType>
|
|
void to_json(BasicJsonType& j, const std_fs::path& p)
|
|
{
|
|
j = p.string();
|
|
}
|
|
#endif
|
|
|
|
struct to_json_fn
|
|
{
|
|
template<typename BasicJsonType, typename T>
|
|
auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
|
|
-> decltype(to_json(j, std::forward<T>(val)), void())
|
|
{
|
|
return to_json(j, std::forward<T>(val));
|
|
}
|
|
};
|
|
} // namespace detail
|
|
|
|
/// namespace to hold default `to_json` function
|
|
/// to see why this is required:
|
|
/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
|
|
namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
|
|
{
|
|
constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value; // NOLINT(misc-definitions-in-headers)
|
|
} // namespace
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/identity_tag.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
|
|
/// @sa https://json.nlohmann.me/api/adl_serializer/
|
|
template<typename ValueType, typename>
|
|
struct adl_serializer
|
|
{
|
|
/// @brief convert a JSON value to any value type
|
|
/// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
|
|
template<typename BasicJsonType, typename TargetType = ValueType>
|
|
static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
|
|
noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
|
|
-> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
|
|
{
|
|
::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
|
|
}
|
|
|
|
/// @brief convert a JSON value to any value type
|
|
/// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
|
|
template<typename BasicJsonType, typename TargetType = ValueType>
|
|
static auto from_json(BasicJsonType && j) noexcept(
|
|
noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
|
|
-> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
|
|
{
|
|
return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
|
|
}
|
|
|
|
/// @brief convert any value type to a JSON value
|
|
/// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
|
|
template<typename BasicJsonType, typename TargetType = ValueType>
|
|
static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
|
|
noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
|
|
-> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
|
|
{
|
|
::nlohmann::to_json(j, std::forward<TargetType>(val));
|
|
}
|
|
};
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/byte_container_with_subtype.hpp>
|
|
|
|
|
|
#include <cstdint> // uint8_t, uint64_t
|
|
#include <tuple> // tie
|
|
#include <utility> // move
|
|
|
|
namespace nlohmann
|
|
{
|
|
|
|
/// @brief an internal type for a backed binary type
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
|
|
template<typename BinaryType>
|
|
class byte_container_with_subtype : public BinaryType
|
|
{
|
|
public:
|
|
using container_type = BinaryType;
|
|
using subtype_type = std::uint64_t;
|
|
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
|
|
byte_container_with_subtype() noexcept(noexcept(container_type()))
|
|
: container_type()
|
|
{}
|
|
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
|
|
byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
|
|
: container_type(b)
|
|
{}
|
|
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
|
|
byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
|
|
: container_type(std::move(b))
|
|
{}
|
|
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
|
|
byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
|
|
: container_type(b)
|
|
, m_subtype(subtype_)
|
|
, m_has_subtype(true)
|
|
{}
|
|
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
|
|
byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
|
|
: container_type(std::move(b))
|
|
, m_subtype(subtype_)
|
|
, m_has_subtype(true)
|
|
{}
|
|
|
|
bool operator==(const byte_container_with_subtype& rhs) const
|
|
{
|
|
return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
|
|
std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
|
|
}
|
|
|
|
bool operator!=(const byte_container_with_subtype& rhs) const
|
|
{
|
|
return !(rhs == *this);
|
|
}
|
|
|
|
/// @brief sets the binary subtype
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
|
|
void set_subtype(subtype_type subtype_) noexcept
|
|
{
|
|
m_subtype = subtype_;
|
|
m_has_subtype = true;
|
|
}
|
|
|
|
/// @brief return the binary subtype
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
|
|
constexpr subtype_type subtype() const noexcept
|
|
{
|
|
return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
|
|
}
|
|
|
|
/// @brief return whether the value has a subtype
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
|
|
constexpr bool has_subtype() const noexcept
|
|
{
|
|
return m_has_subtype;
|
|
}
|
|
|
|
/// @brief clears the binary subtype
|
|
/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
|
|
void clear_subtype() noexcept
|
|
{
|
|
m_subtype = 0;
|
|
m_has_subtype = false;
|
|
}
|
|
|
|
private:
|
|
subtype_type m_subtype = 0;
|
|
bool m_has_subtype = false;
|
|
};
|
|
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/conversions/from_json.hpp>
|
|
|
|
// #include <nlohmann/detail/conversions/to_json.hpp>
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/hash.hpp>
|
|
|
|
|
|
#include <cstdint> // uint8_t
|
|
#include <cstddef> // size_t
|
|
#include <functional> // hash
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
|
|
// boost::hash_combine
|
|
inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
|
|
{
|
|
seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
|
|
return seed;
|
|
}
|
|
|
|
/*!
|
|
@brief hash a JSON value
|
|
|
|
The hash function tries to rely on std::hash where possible. Furthermore, the
|
|
type of the JSON value is taken into account to have different hash values for
|
|
null, 0, 0U, and false, etc.
|
|
|
|
@tparam BasicJsonType basic_json specialization
|
|
@param j JSON value to hash
|
|
@return hash value of j
|
|
*/
|
|
template<typename BasicJsonType>
|
|
std::size_t hash(const BasicJsonType& j)
|
|
{
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
|
|
const auto type = static_cast<std::size_t>(j.type());
|
|
switch (j.type())
|
|
{
|
|
case BasicJsonType::value_t::null:
|
|
case BasicJsonType::value_t::discarded:
|
|
{
|
|
return combine(type, 0);
|
|
}
|
|
|
|
case BasicJsonType::value_t::object:
|
|
{
|
|
auto seed = combine(type, j.size());
|
|
for (const auto& element : j.items())
|
|
{
|
|
const auto h = std::hash<string_t> {}(element.key());
|
|
seed = combine(seed, h);
|
|
seed = combine(seed, hash(element.value()));
|
|
}
|
|
return seed;
|
|
}
|
|
|
|
case BasicJsonType::value_t::array:
|
|
{
|
|
auto seed = combine(type, j.size());
|
|
for (const auto& element : j)
|
|
{
|
|
seed = combine(seed, hash(element));
|
|
}
|
|
return seed;
|
|
}
|
|
|
|
case BasicJsonType::value_t::string:
|
|
{
|
|
const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
|
|
return combine(type, h);
|
|
}
|
|
|
|
case BasicJsonType::value_t::boolean:
|
|
{
|
|
const auto h = std::hash<bool> {}(j.template get<bool>());
|
|
return combine(type, h);
|
|
}
|
|
|
|
case BasicJsonType::value_t::number_integer:
|
|
{
|
|
const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
|
|
return combine(type, h);
|
|
}
|
|
|
|
case BasicJsonType::value_t::number_unsigned:
|
|
{
|
|
const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
|
|
return combine(type, h);
|
|
}
|
|
|
|
case BasicJsonType::value_t::number_float:
|
|
{
|
|
const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
|
|
return combine(type, h);
|
|
}
|
|
|
|
case BasicJsonType::value_t::binary:
|
|
{
|
|
auto seed = combine(type, j.get_binary().size());
|
|
const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
|
|
seed = combine(seed, h);
|
|
seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
|
|
for (const auto byte : j.get_binary())
|
|
{
|
|
seed = combine(seed, std::hash<std::uint8_t> {}(byte));
|
|
}
|
|
return seed;
|
|
}
|
|
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
return 0; // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/input/binary_reader.hpp>
|
|
|
|
|
|
#include <algorithm> // generate_n
|
|
#include <array> // array
|
|
#include <cmath> // ldexp
|
|
#include <cstddef> // size_t
|
|
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
|
|
#include <cstdio> // snprintf
|
|
#include <cstring> // memcpy
|
|
#include <iterator> // back_inserter
|
|
#include <limits> // numeric_limits
|
|
#include <string> // char_traits, string
|
|
#include <utility> // make_pair, move
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/input/input_adapters.hpp>
|
|
|
|
|
|
#include <array> // array
|
|
#include <cstddef> // size_t
|
|
#include <cstring> // strlen
|
|
#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
|
|
#include <memory> // shared_ptr, make_shared, addressof
|
|
#include <numeric> // accumulate
|
|
#include <string> // string, char_traits
|
|
#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
|
|
#include <utility> // pair, declval
|
|
|
|
#ifndef JSON_NO_IO
|
|
#include <cstdio> // FILE *
|
|
#include <istream> // istream
|
|
#endif // JSON_NO_IO
|
|
|
|
// #include <nlohmann/detail/iterators/iterator_traits.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
/// the supported input formats
|
|
enum class input_format_t { json, cbor, msgpack, ubjson, bson };
|
|
|
|
////////////////////
|
|
// input adapters //
|
|
////////////////////
|
|
|
|
#ifndef JSON_NO_IO
|
|
/*!
|
|
Input adapter for stdio file access. This adapter read only 1 byte and do not use any
|
|
buffer. This adapter is a very low level adapter.
|
|
*/
|
|
class file_input_adapter
|
|
{
|
|
public:
|
|
using char_type = char;
|
|
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
explicit file_input_adapter(std::FILE* f) noexcept
|
|
: m_file(f)
|
|
{}
|
|
|
|
// make class move-only
|
|
file_input_adapter(const file_input_adapter&) = delete;
|
|
file_input_adapter(file_input_adapter&&) noexcept = default;
|
|
file_input_adapter& operator=(const file_input_adapter&) = delete;
|
|
file_input_adapter& operator=(file_input_adapter&&) = delete;
|
|
~file_input_adapter() = default;
|
|
|
|
std::char_traits<char>::int_type get_character() noexcept
|
|
{
|
|
return std::fgetc(m_file);
|
|
}
|
|
|
|
private:
|
|
/// the file pointer to read from
|
|
std::FILE* m_file;
|
|
};
|
|
|
|
|
|
/*!
|
|
Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
|
|
beginning of input. Does not support changing the underlying std::streambuf
|
|
in mid-input. Maintains underlying std::istream and std::streambuf to support
|
|
subsequent use of standard std::istream operations to process any input
|
|
characters following those used in parsing the JSON input. Clears the
|
|
std::istream flags; any input errors (e.g., EOF) will be detected by the first
|
|
subsequent call for input from the std::istream.
|
|
*/
|
|
class input_stream_adapter
|
|
{
|
|
public:
|
|
using char_type = char;
|
|
|
|
~input_stream_adapter()
|
|
{
|
|
// clear stream flags; we use underlying streambuf I/O, do not
|
|
// maintain ifstream flags, except eof
|
|
if (is != nullptr)
|
|
{
|
|
is->clear(is->rdstate() & std::ios::eofbit);
|
|
}
|
|
}
|
|
|
|
explicit input_stream_adapter(std::istream& i)
|
|
: is(&i), sb(i.rdbuf())
|
|
{}
|
|
|
|
// delete because of pointer members
|
|
input_stream_adapter(const input_stream_adapter&) = delete;
|
|
input_stream_adapter& operator=(input_stream_adapter&) = delete;
|
|
input_stream_adapter& operator=(input_stream_adapter&&) = delete;
|
|
|
|
input_stream_adapter(input_stream_adapter&& rhs) noexcept
|
|
: is(rhs.is), sb(rhs.sb)
|
|
{
|
|
rhs.is = nullptr;
|
|
rhs.sb = nullptr;
|
|
}
|
|
|
|
// std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
|
|
// ensure that std::char_traits<char>::eof() and the character 0xFF do not
|
|
// end up as the same value, e.g. 0xFFFFFFFF.
|
|
std::char_traits<char>::int_type get_character()
|
|
{
|
|
auto res = sb->sbumpc();
|
|
// set eof manually, as we don't use the istream interface.
|
|
if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
|
|
{
|
|
is->clear(is->rdstate() | std::ios::eofbit);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
private:
|
|
/// the associated input stream
|
|
std::istream* is = nullptr;
|
|
std::streambuf* sb = nullptr;
|
|
};
|
|
#endif // JSON_NO_IO
|
|
|
|
// General-purpose iterator-based adapter. It might not be as fast as
|
|
// theoretically possible for some containers, but it is extremely versatile.
|
|
template<typename IteratorType>
|
|
class iterator_input_adapter
|
|
{
|
|
public:
|
|
using char_type = typename std::iterator_traits<IteratorType>::value_type;
|
|
|
|
iterator_input_adapter(IteratorType first, IteratorType last)
|
|
: current(std::move(first)), end(std::move(last))
|
|
{}
|
|
|
|
typename std::char_traits<char_type>::int_type get_character()
|
|
{
|
|
if (JSON_HEDLEY_LIKELY(current != end))
|
|
{
|
|
auto result = std::char_traits<char_type>::to_int_type(*current);
|
|
std::advance(current, 1);
|
|
return result;
|
|
}
|
|
|
|
return std::char_traits<char_type>::eof();
|
|
}
|
|
|
|
private:
|
|
IteratorType current;
|
|
IteratorType end;
|
|
|
|
template<typename BaseInputAdapter, size_t T>
|
|
friend struct wide_string_input_helper;
|
|
|
|
bool empty() const
|
|
{
|
|
return current == end;
|
|
}
|
|
};
|
|
|
|
|
|
template<typename BaseInputAdapter, size_t T>
|
|
struct wide_string_input_helper;
|
|
|
|
template<typename BaseInputAdapter>
|
|
struct wide_string_input_helper<BaseInputAdapter, 4>
|
|
{
|
|
// UTF-32
|
|
static void fill_buffer(BaseInputAdapter& input,
|
|
std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
|
|
size_t& utf8_bytes_index,
|
|
size_t& utf8_bytes_filled)
|
|
{
|
|
utf8_bytes_index = 0;
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(input.empty()))
|
|
{
|
|
utf8_bytes[0] = std::char_traits<char>::eof();
|
|
utf8_bytes_filled = 1;
|
|
}
|
|
else
|
|
{
|
|
// get the current character
|
|
const auto wc = input.get_character();
|
|
|
|
// UTF-32 to UTF-8 encoding
|
|
if (wc < 0x80)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
|
|
utf8_bytes_filled = 1;
|
|
}
|
|
else if (wc <= 0x7FF)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
|
|
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
|
|
utf8_bytes_filled = 2;
|
|
}
|
|
else if (wc <= 0xFFFF)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
|
|
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
|
|
utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
|
|
utf8_bytes_filled = 3;
|
|
}
|
|
else if (wc <= 0x10FFFF)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
|
|
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
|
|
utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
|
|
utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
|
|
utf8_bytes_filled = 4;
|
|
}
|
|
else
|
|
{
|
|
// unknown character
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
|
|
utf8_bytes_filled = 1;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
template<typename BaseInputAdapter>
|
|
struct wide_string_input_helper<BaseInputAdapter, 2>
|
|
{
|
|
// UTF-16
|
|
static void fill_buffer(BaseInputAdapter& input,
|
|
std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
|
|
size_t& utf8_bytes_index,
|
|
size_t& utf8_bytes_filled)
|
|
{
|
|
utf8_bytes_index = 0;
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(input.empty()))
|
|
{
|
|
utf8_bytes[0] = std::char_traits<char>::eof();
|
|
utf8_bytes_filled = 1;
|
|
}
|
|
else
|
|
{
|
|
// get the current character
|
|
const auto wc = input.get_character();
|
|
|
|
// UTF-16 to UTF-8 encoding
|
|
if (wc < 0x80)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
|
|
utf8_bytes_filled = 1;
|
|
}
|
|
else if (wc <= 0x7FF)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
|
|
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
|
|
utf8_bytes_filled = 2;
|
|
}
|
|
else if (0xD800 > wc || wc >= 0xE000)
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
|
|
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
|
|
utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
|
|
utf8_bytes_filled = 3;
|
|
}
|
|
else
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!input.empty()))
|
|
{
|
|
const auto wc2 = static_cast<unsigned int>(input.get_character());
|
|
const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
|
|
utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
|
|
utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
|
|
utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
|
|
utf8_bytes_filled = 4;
|
|
}
|
|
else
|
|
{
|
|
utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
|
|
utf8_bytes_filled = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Wraps another input apdater to convert wide character types into individual bytes.
|
|
template<typename BaseInputAdapter, typename WideCharType>
|
|
class wide_string_input_adapter
|
|
{
|
|
public:
|
|
using char_type = char;
|
|
|
|
wide_string_input_adapter(BaseInputAdapter base)
|
|
: base_adapter(base) {}
|
|
|
|
typename std::char_traits<char>::int_type get_character() noexcept
|
|
{
|
|
// check if buffer needs to be filled
|
|
if (utf8_bytes_index == utf8_bytes_filled)
|
|
{
|
|
fill_buffer<sizeof(WideCharType)>();
|
|
|
|
JSON_ASSERT(utf8_bytes_filled > 0);
|
|
JSON_ASSERT(utf8_bytes_index == 0);
|
|
}
|
|
|
|
// use buffer
|
|
JSON_ASSERT(utf8_bytes_filled > 0);
|
|
JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
|
|
return utf8_bytes[utf8_bytes_index++];
|
|
}
|
|
|
|
private:
|
|
BaseInputAdapter base_adapter;
|
|
|
|
template<size_t T>
|
|
void fill_buffer()
|
|
{
|
|
wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
|
|
}
|
|
|
|
/// a buffer for UTF-8 bytes
|
|
std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
|
|
|
|
/// index to the utf8_codes array for the next valid byte
|
|
std::size_t utf8_bytes_index = 0;
|
|
/// number of valid bytes in the utf8_codes array
|
|
std::size_t utf8_bytes_filled = 0;
|
|
};
|
|
|
|
|
|
template<typename IteratorType, typename Enable = void>
|
|
struct iterator_input_adapter_factory
|
|
{
|
|
using iterator_type = IteratorType;
|
|
using char_type = typename std::iterator_traits<iterator_type>::value_type;
|
|
using adapter_type = iterator_input_adapter<iterator_type>;
|
|
|
|
static adapter_type create(IteratorType first, IteratorType last)
|
|
{
|
|
return adapter_type(std::move(first), std::move(last));
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct is_iterator_of_multibyte
|
|
{
|
|
using value_type = typename std::iterator_traits<T>::value_type;
|
|
enum
|
|
{
|
|
value = sizeof(value_type) > 1
|
|
};
|
|
};
|
|
|
|
template<typename IteratorType>
|
|
struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
|
|
{
|
|
using iterator_type = IteratorType;
|
|
using char_type = typename std::iterator_traits<iterator_type>::value_type;
|
|
using base_adapter_type = iterator_input_adapter<iterator_type>;
|
|
using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
|
|
|
|
static adapter_type create(IteratorType first, IteratorType last)
|
|
{
|
|
return adapter_type(base_adapter_type(std::move(first), std::move(last)));
|
|
}
|
|
};
|
|
|
|
// General purpose iterator-based input
|
|
template<typename IteratorType>
|
|
typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
|
|
{
|
|
using factory_type = iterator_input_adapter_factory<IteratorType>;
|
|
return factory_type::create(first, last);
|
|
}
|
|
|
|
// Convenience shorthand from container to iterator
|
|
// Enables ADL on begin(container) and end(container)
|
|
// Encloses the using declarations in namespace for not to leak them to outside scope
|
|
|
|
namespace container_input_adapter_factory_impl
|
|
{
|
|
|
|
using std::begin;
|
|
using std::end;
|
|
|
|
template<typename ContainerType, typename Enable = void>
|
|
struct container_input_adapter_factory {};
|
|
|
|
template<typename ContainerType>
|
|
struct container_input_adapter_factory< ContainerType,
|
|
void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
|
|
{
|
|
using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
|
|
|
|
static adapter_type create(const ContainerType& container)
|
|
{
|
|
return input_adapter(begin(container), end(container));
|
|
}
|
|
};
|
|
|
|
} // namespace container_input_adapter_factory_impl
|
|
|
|
template<typename ContainerType>
|
|
typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
|
|
{
|
|
return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
|
|
}
|
|
|
|
#ifndef JSON_NO_IO
|
|
// Special cases with fast paths
|
|
inline file_input_adapter input_adapter(std::FILE* file)
|
|
{
|
|
return file_input_adapter(file);
|
|
}
|
|
|
|
inline input_stream_adapter input_adapter(std::istream& stream)
|
|
{
|
|
return input_stream_adapter(stream);
|
|
}
|
|
|
|
inline input_stream_adapter input_adapter(std::istream&& stream)
|
|
{
|
|
return input_stream_adapter(stream);
|
|
}
|
|
#endif // JSON_NO_IO
|
|
|
|
using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
|
|
|
|
// Null-delimited strings, and the like.
|
|
template < typename CharT,
|
|
typename std::enable_if <
|
|
std::is_pointer<CharT>::value&&
|
|
!std::is_array<CharT>::value&&
|
|
std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
|
|
sizeof(typename std::remove_pointer<CharT>::type) == 1,
|
|
int >::type = 0 >
|
|
contiguous_bytes_input_adapter input_adapter(CharT b)
|
|
{
|
|
auto length = std::strlen(reinterpret_cast<const char*>(b));
|
|
const auto* ptr = reinterpret_cast<const char*>(b);
|
|
return input_adapter(ptr, ptr + length);
|
|
}
|
|
|
|
template<typename T, std::size_t N>
|
|
auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
{
|
|
return input_adapter(array, array + N);
|
|
}
|
|
|
|
// This class only handles inputs of input_buffer_adapter type.
|
|
// It's required so that expressions like {ptr, len} can be implicitly cast
|
|
// to the correct adapter.
|
|
class span_input_adapter
|
|
{
|
|
public:
|
|
template < typename CharT,
|
|
typename std::enable_if <
|
|
std::is_pointer<CharT>::value&&
|
|
std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
|
|
sizeof(typename std::remove_pointer<CharT>::type) == 1,
|
|
int >::type = 0 >
|
|
span_input_adapter(CharT b, std::size_t l)
|
|
: ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
|
|
|
|
template<class IteratorType,
|
|
typename std::enable_if<
|
|
std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
|
|
int>::type = 0>
|
|
span_input_adapter(IteratorType first, IteratorType last)
|
|
: ia(input_adapter(first, last)) {}
|
|
|
|
contiguous_bytes_input_adapter&& get()
|
|
{
|
|
return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
|
|
}
|
|
|
|
private:
|
|
contiguous_bytes_input_adapter ia;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/input/json_sax.hpp>
|
|
|
|
|
|
#include <cstddef>
|
|
#include <string> // string
|
|
#include <utility> // move
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
|
|
/*!
|
|
@brief SAX interface
|
|
|
|
This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
|
|
Each function is called in different situations while the input is parsed. The
|
|
boolean return value informs the parser whether to continue processing the
|
|
input.
|
|
*/
|
|
template<typename BasicJsonType>
|
|
struct json_sax
|
|
{
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
|
|
/*!
|
|
@brief a null value was read
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool null() = 0;
|
|
|
|
/*!
|
|
@brief a boolean value was read
|
|
@param[in] val boolean value
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool boolean(bool val) = 0;
|
|
|
|
/*!
|
|
@brief an integer number was read
|
|
@param[in] val integer value
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool number_integer(number_integer_t val) = 0;
|
|
|
|
/*!
|
|
@brief an unsigned integer number was read
|
|
@param[in] val unsigned integer value
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool number_unsigned(number_unsigned_t val) = 0;
|
|
|
|
/*!
|
|
@brief a floating-point number was read
|
|
@param[in] val floating-point value
|
|
@param[in] s raw token value
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool number_float(number_float_t val, const string_t& s) = 0;
|
|
|
|
/*!
|
|
@brief a string value was read
|
|
@param[in] val string value
|
|
@return whether parsing should proceed
|
|
@note It is safe to move the passed string value.
|
|
*/
|
|
virtual bool string(string_t& val) = 0;
|
|
|
|
/*!
|
|
@brief a binary value was read
|
|
@param[in] val binary value
|
|
@return whether parsing should proceed
|
|
@note It is safe to move the passed binary value.
|
|
*/
|
|
virtual bool binary(binary_t& val) = 0;
|
|
|
|
/*!
|
|
@brief the beginning of an object was read
|
|
@param[in] elements number of object elements or -1 if unknown
|
|
@return whether parsing should proceed
|
|
@note binary formats may report the number of elements
|
|
*/
|
|
virtual bool start_object(std::size_t elements) = 0;
|
|
|
|
/*!
|
|
@brief an object key was read
|
|
@param[in] val object key
|
|
@return whether parsing should proceed
|
|
@note It is safe to move the passed string.
|
|
*/
|
|
virtual bool key(string_t& val) = 0;
|
|
|
|
/*!
|
|
@brief the end of an object was read
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool end_object() = 0;
|
|
|
|
/*!
|
|
@brief the beginning of an array was read
|
|
@param[in] elements number of array elements or -1 if unknown
|
|
@return whether parsing should proceed
|
|
@note binary formats may report the number of elements
|
|
*/
|
|
virtual bool start_array(std::size_t elements) = 0;
|
|
|
|
/*!
|
|
@brief the end of an array was read
|
|
@return whether parsing should proceed
|
|
*/
|
|
virtual bool end_array() = 0;
|
|
|
|
/*!
|
|
@brief a parse error occurred
|
|
@param[in] position the position in the input where the error occurs
|
|
@param[in] last_token the last read token
|
|
@param[in] ex an exception object describing the error
|
|
@return whether parsing should proceed (must return false)
|
|
*/
|
|
virtual bool parse_error(std::size_t position,
|
|
const std::string& last_token,
|
|
const detail::exception& ex) = 0;
|
|
|
|
json_sax() = default;
|
|
json_sax(const json_sax&) = default;
|
|
json_sax(json_sax&&) noexcept = default;
|
|
json_sax& operator=(const json_sax&) = default;
|
|
json_sax& operator=(json_sax&&) noexcept = default;
|
|
virtual ~json_sax() = default;
|
|
};
|
|
|
|
|
|
namespace detail
|
|
{
|
|
/*!
|
|
@brief SAX implementation to create a JSON value from SAX events
|
|
|
|
This class implements the @ref json_sax interface and processes the SAX events
|
|
to create a JSON value which makes it basically a DOM parser. The structure or
|
|
hierarchy of the JSON value is managed by the stack `ref_stack` which contains
|
|
a pointer to the respective array or object for each recursion depth.
|
|
|
|
After successful parsing, the value that is passed by reference to the
|
|
constructor contains the parsed value.
|
|
|
|
@tparam BasicJsonType the JSON type
|
|
*/
|
|
template<typename BasicJsonType>
|
|
class json_sax_dom_parser
|
|
{
|
|
public:
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
|
|
/*!
|
|
@param[in,out] r reference to a JSON value that is manipulated while
|
|
parsing
|
|
@param[in] allow_exceptions_ whether parse errors yield exceptions
|
|
*/
|
|
explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
|
|
: root(r), allow_exceptions(allow_exceptions_)
|
|
{}
|
|
|
|
// make class move-only
|
|
json_sax_dom_parser(const json_sax_dom_parser&) = delete;
|
|
json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
|
|
json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
~json_sax_dom_parser() = default;
|
|
|
|
bool null()
|
|
{
|
|
handle_value(nullptr);
|
|
return true;
|
|
}
|
|
|
|
bool boolean(bool val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool number_integer(number_integer_t val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool number_unsigned(number_unsigned_t val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool number_float(number_float_t val, const string_t& /*unused*/)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool string(string_t& val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool binary(binary_t& val)
|
|
{
|
|
handle_value(std::move(val));
|
|
return true;
|
|
}
|
|
|
|
bool start_object(std::size_t len)
|
|
{
|
|
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
|
|
{
|
|
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool key(string_t& val)
|
|
{
|
|
// add null at given key and store the reference for later
|
|
object_element = &(ref_stack.back()->m_value.object->operator[](val));
|
|
return true;
|
|
}
|
|
|
|
bool end_object()
|
|
{
|
|
ref_stack.back()->set_parents();
|
|
ref_stack.pop_back();
|
|
return true;
|
|
}
|
|
|
|
bool start_array(std::size_t len)
|
|
{
|
|
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
|
|
{
|
|
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool end_array()
|
|
{
|
|
ref_stack.back()->set_parents();
|
|
ref_stack.pop_back();
|
|
return true;
|
|
}
|
|
|
|
template<class Exception>
|
|
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
|
|
const Exception& ex)
|
|
{
|
|
errored = true;
|
|
static_cast<void>(ex);
|
|
if (allow_exceptions)
|
|
{
|
|
JSON_THROW(ex);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
constexpr bool is_errored() const
|
|
{
|
|
return errored;
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@invariant If the ref stack is empty, then the passed value will be the new
|
|
root.
|
|
@invariant If the ref stack contains a value, then it is an array or an
|
|
object to which we can add elements
|
|
*/
|
|
template<typename Value>
|
|
JSON_HEDLEY_RETURNS_NON_NULL
|
|
BasicJsonType* handle_value(Value&& v)
|
|
{
|
|
if (ref_stack.empty())
|
|
{
|
|
root = BasicJsonType(std::forward<Value>(v));
|
|
return &root;
|
|
}
|
|
|
|
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
|
|
|
|
if (ref_stack.back()->is_array())
|
|
{
|
|
ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
|
|
return &(ref_stack.back()->m_value.array->back());
|
|
}
|
|
|
|
JSON_ASSERT(ref_stack.back()->is_object());
|
|
JSON_ASSERT(object_element);
|
|
*object_element = BasicJsonType(std::forward<Value>(v));
|
|
return object_element;
|
|
}
|
|
|
|
/// the parsed JSON value
|
|
BasicJsonType& root;
|
|
/// stack to model hierarchy of values
|
|
std::vector<BasicJsonType*> ref_stack {};
|
|
/// helper to hold the reference for the next object element
|
|
BasicJsonType* object_element = nullptr;
|
|
/// whether a syntax error occurred
|
|
bool errored = false;
|
|
/// whether to throw exceptions in case of errors
|
|
const bool allow_exceptions = true;
|
|
};
|
|
|
|
template<typename BasicJsonType>
|
|
class json_sax_dom_callback_parser
|
|
{
|
|
public:
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
using parser_callback_t = typename BasicJsonType::parser_callback_t;
|
|
using parse_event_t = typename BasicJsonType::parse_event_t;
|
|
|
|
json_sax_dom_callback_parser(BasicJsonType& r,
|
|
const parser_callback_t cb,
|
|
const bool allow_exceptions_ = true)
|
|
: root(r), callback(cb), allow_exceptions(allow_exceptions_)
|
|
{
|
|
keep_stack.push_back(true);
|
|
}
|
|
|
|
// make class move-only
|
|
json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
|
|
json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
|
|
json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
~json_sax_dom_callback_parser() = default;
|
|
|
|
bool null()
|
|
{
|
|
handle_value(nullptr);
|
|
return true;
|
|
}
|
|
|
|
bool boolean(bool val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool number_integer(number_integer_t val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool number_unsigned(number_unsigned_t val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool number_float(number_float_t val, const string_t& /*unused*/)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool string(string_t& val)
|
|
{
|
|
handle_value(val);
|
|
return true;
|
|
}
|
|
|
|
bool binary(binary_t& val)
|
|
{
|
|
handle_value(std::move(val));
|
|
return true;
|
|
}
|
|
|
|
bool start_object(std::size_t len)
|
|
{
|
|
// check callback for object start
|
|
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
|
|
keep_stack.push_back(keep);
|
|
|
|
auto val = handle_value(BasicJsonType::value_t::object, true);
|
|
ref_stack.push_back(val.second);
|
|
|
|
// check object limit
|
|
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
|
|
{
|
|
JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len), *ref_stack.back()));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool key(string_t& val)
|
|
{
|
|
BasicJsonType k = BasicJsonType(val);
|
|
|
|
// check callback for key
|
|
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
|
|
key_keep_stack.push_back(keep);
|
|
|
|
// add discarded value at given key and store the reference for later
|
|
if (keep && ref_stack.back())
|
|
{
|
|
object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool end_object()
|
|
{
|
|
if (ref_stack.back())
|
|
{
|
|
if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
|
|
{
|
|
// discard object
|
|
*ref_stack.back() = discarded;
|
|
}
|
|
else
|
|
{
|
|
ref_stack.back()->set_parents();
|
|
}
|
|
}
|
|
|
|
JSON_ASSERT(!ref_stack.empty());
|
|
JSON_ASSERT(!keep_stack.empty());
|
|
ref_stack.pop_back();
|
|
keep_stack.pop_back();
|
|
|
|
if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
|
|
{
|
|
// remove discarded value
|
|
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
|
|
{
|
|
if (it->is_discarded())
|
|
{
|
|
ref_stack.back()->erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool start_array(std::size_t len)
|
|
{
|
|
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
|
|
keep_stack.push_back(keep);
|
|
|
|
auto val = handle_value(BasicJsonType::value_t::array, true);
|
|
ref_stack.push_back(val.second);
|
|
|
|
// check array limit
|
|
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
|
|
{
|
|
JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len), *ref_stack.back()));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool end_array()
|
|
{
|
|
bool keep = true;
|
|
|
|
if (ref_stack.back())
|
|
{
|
|
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
|
|
if (keep)
|
|
{
|
|
ref_stack.back()->set_parents();
|
|
}
|
|
else
|
|
{
|
|
// discard array
|
|
*ref_stack.back() = discarded;
|
|
}
|
|
}
|
|
|
|
JSON_ASSERT(!ref_stack.empty());
|
|
JSON_ASSERT(!keep_stack.empty());
|
|
ref_stack.pop_back();
|
|
keep_stack.pop_back();
|
|
|
|
// remove discarded value
|
|
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
|
|
{
|
|
ref_stack.back()->m_value.array->pop_back();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template<class Exception>
|
|
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
|
|
const Exception& ex)
|
|
{
|
|
errored = true;
|
|
static_cast<void>(ex);
|
|
if (allow_exceptions)
|
|
{
|
|
JSON_THROW(ex);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
constexpr bool is_errored() const
|
|
{
|
|
return errored;
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@param[in] v value to add to the JSON value we build during parsing
|
|
@param[in] skip_callback whether we should skip calling the callback
|
|
function; this is required after start_array() and
|
|
start_object() SAX events, because otherwise we would call the
|
|
callback function with an empty array or object, respectively.
|
|
|
|
@invariant If the ref stack is empty, then the passed value will be the new
|
|
root.
|
|
@invariant If the ref stack contains a value, then it is an array or an
|
|
object to which we can add elements
|
|
|
|
@return pair of boolean (whether value should be kept) and pointer (to the
|
|
passed value in the ref_stack hierarchy; nullptr if not kept)
|
|
*/
|
|
template<typename Value>
|
|
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
|
|
{
|
|
JSON_ASSERT(!keep_stack.empty());
|
|
|
|
// do not handle this value if we know it would be added to a discarded
|
|
// container
|
|
if (!keep_stack.back())
|
|
{
|
|
return {false, nullptr};
|
|
}
|
|
|
|
// create value
|
|
auto value = BasicJsonType(std::forward<Value>(v));
|
|
|
|
// check callback
|
|
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
|
|
|
|
// do not handle this value if we just learnt it shall be discarded
|
|
if (!keep)
|
|
{
|
|
return {false, nullptr};
|
|
}
|
|
|
|
if (ref_stack.empty())
|
|
{
|
|
root = std::move(value);
|
|
return {true, &root};
|
|
}
|
|
|
|
// skip this value if we already decided to skip the parent
|
|
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
|
|
if (!ref_stack.back())
|
|
{
|
|
return {false, nullptr};
|
|
}
|
|
|
|
// we now only expect arrays and objects
|
|
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
|
|
|
|
// array
|
|
if (ref_stack.back()->is_array())
|
|
{
|
|
ref_stack.back()->m_value.array->emplace_back(std::move(value));
|
|
return {true, &(ref_stack.back()->m_value.array->back())};
|
|
}
|
|
|
|
// object
|
|
JSON_ASSERT(ref_stack.back()->is_object());
|
|
// check if we should store an element for the current key
|
|
JSON_ASSERT(!key_keep_stack.empty());
|
|
const bool store_element = key_keep_stack.back();
|
|
key_keep_stack.pop_back();
|
|
|
|
if (!store_element)
|
|
{
|
|
return {false, nullptr};
|
|
}
|
|
|
|
JSON_ASSERT(object_element);
|
|
*object_element = std::move(value);
|
|
return {true, object_element};
|
|
}
|
|
|
|
/// the parsed JSON value
|
|
BasicJsonType& root;
|
|
/// stack to model hierarchy of values
|
|
std::vector<BasicJsonType*> ref_stack {};
|
|
/// stack to manage which values to keep
|
|
std::vector<bool> keep_stack {};
|
|
/// stack to manage which object keys to keep
|
|
std::vector<bool> key_keep_stack {};
|
|
/// helper to hold the reference for the next object element
|
|
BasicJsonType* object_element = nullptr;
|
|
/// whether a syntax error occurred
|
|
bool errored = false;
|
|
/// callback function
|
|
const parser_callback_t callback = nullptr;
|
|
/// whether to throw exceptions in case of errors
|
|
const bool allow_exceptions = true;
|
|
/// a discarded value for the callback
|
|
BasicJsonType discarded = BasicJsonType::value_t::discarded;
|
|
};
|
|
|
|
template<typename BasicJsonType>
|
|
class json_sax_acceptor
|
|
{
|
|
public:
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
|
|
bool null()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool boolean(bool /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool number_integer(number_integer_t /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool number_unsigned(number_unsigned_t /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool string(string_t& /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool binary(binary_t& /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool key(string_t& /*unused*/)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool end_object()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool end_array()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
|
|
{
|
|
return false;
|
|
}
|
|
};
|
|
} // namespace detail
|
|
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/input/lexer.hpp>
|
|
|
|
|
|
#include <array> // array
|
|
#include <clocale> // localeconv
|
|
#include <cstddef> // size_t
|
|
#include <cstdio> // snprintf
|
|
#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
|
|
#include <initializer_list> // initializer_list
|
|
#include <string> // char_traits, string
|
|
#include <utility> // move
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/input/input_adapters.hpp>
|
|
|
|
// #include <nlohmann/detail/input/position_t.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
///////////
|
|
// lexer //
|
|
///////////
|
|
|
|
template<typename BasicJsonType>
|
|
class lexer_base
|
|
{
|
|
public:
|
|
/// token types for the parser
|
|
enum class token_type
|
|
{
|
|
uninitialized, ///< indicating the scanner is uninitialized
|
|
literal_true, ///< the `true` literal
|
|
literal_false, ///< the `false` literal
|
|
literal_null, ///< the `null` literal
|
|
value_string, ///< a string -- use get_string() for actual value
|
|
value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for actual value
|
|
value_integer, ///< a signed integer -- use get_number_integer() for actual value
|
|
value_float, ///< an floating point number -- use get_number_float() for actual value
|
|
begin_array, ///< the character for array begin `[`
|
|
begin_object, ///< the character for object begin `{`
|
|
end_array, ///< the character for array end `]`
|
|
end_object, ///< the character for object end `}`
|
|
name_separator, ///< the name separator `:`
|
|
value_separator, ///< the value separator `,`
|
|
parse_error, ///< indicating a parse error
|
|
end_of_input, ///< indicating the end of the input buffer
|
|
literal_or_value ///< a literal or the begin of a value (only for diagnostics)
|
|
};
|
|
|
|
/// 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)
|
|
{
|
|
case token_type::uninitialized:
|
|
return "<uninitialized>";
|
|
case token_type::literal_true:
|
|
return "true literal";
|
|
case token_type::literal_false:
|
|
return "false literal";
|
|
case token_type::literal_null:
|
|
return "null literal";
|
|
case token_type::value_string:
|
|
return "string literal";
|
|
case token_type::value_unsigned:
|
|
case token_type::value_integer:
|
|
case token_type::value_float:
|
|
return "number literal";
|
|
case token_type::begin_array:
|
|
return "'['";
|
|
case token_type::begin_object:
|
|
return "'{'";
|
|
case token_type::end_array:
|
|
return "']'";
|
|
case token_type::end_object:
|
|
return "'}'";
|
|
case token_type::name_separator:
|
|
return "':'";
|
|
case token_type::value_separator:
|
|
return "','";
|
|
case token_type::parse_error:
|
|
return "<parse error>";
|
|
case token_type::end_of_input:
|
|
return "end of input";
|
|
case token_type::literal_or_value:
|
|
return "'[', '{', or a literal";
|
|
// LCOV_EXCL_START
|
|
default: // catch non-enum values
|
|
return "unknown token";
|
|
// LCOV_EXCL_STOP
|
|
}
|
|
}
|
|
};
|
|
/*!
|
|
@brief lexical analysis
|
|
|
|
This class organizes the lexical analysis during JSON deserialization.
|
|
*/
|
|
template<typename BasicJsonType, typename InputAdapterType>
|
|
class lexer : public lexer_base<BasicJsonType>
|
|
{
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using char_type = typename InputAdapterType::char_type;
|
|
using char_int_type = typename std::char_traits<char_type>::int_type;
|
|
|
|
public:
|
|
using token_type = typename lexer_base<BasicJsonType>::token_type;
|
|
|
|
explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
|
|
: ia(std::move(adapter))
|
|
, ignore_comments(ignore_comments_)
|
|
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
|
|
{}
|
|
|
|
// delete because of pointer members
|
|
lexer(const lexer&) = delete;
|
|
lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
lexer& operator=(lexer&) = delete;
|
|
lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
~lexer() = default;
|
|
|
|
private:
|
|
/////////////////////
|
|
// locales
|
|
/////////////////////
|
|
|
|
/// return the locale-dependent decimal point
|
|
JSON_HEDLEY_PURE
|
|
static char get_decimal_point() noexcept
|
|
{
|
|
const auto* loc = localeconv();
|
|
JSON_ASSERT(loc != nullptr);
|
|
return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
|
|
}
|
|
|
|
/////////////////////
|
|
// scan functions
|
|
/////////////////////
|
|
|
|
/*!
|
|
@brief get codepoint from 4 hex characters following `\u`
|
|
|
|
For input "\u c1 c2 c3 c4" the codepoint is:
|
|
(c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
|
|
= (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
|
|
|
|
Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
|
|
must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
|
|
conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
|
|
between the ASCII value of the character and the desired integer value.
|
|
|
|
@return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
|
|
non-hex character)
|
|
*/
|
|
int get_codepoint()
|
|
{
|
|
// this function only makes sense after reading `\u`
|
|
JSON_ASSERT(current == 'u');
|
|
int codepoint = 0;
|
|
|
|
const auto factors = { 12u, 8u, 4u, 0u };
|
|
for (const auto factor : factors)
|
|
{
|
|
get();
|
|
|
|
if (current >= '0' && current <= '9')
|
|
{
|
|
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
|
|
}
|
|
else if (current >= 'A' && current <= 'F')
|
|
{
|
|
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
|
|
}
|
|
else if (current >= 'a' && current <= 'f')
|
|
{
|
|
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
|
|
return codepoint;
|
|
}
|
|
|
|
/*!
|
|
@brief check if the next byte(s) are inside a given range
|
|
|
|
Adds the current byte and, for each passed range, reads a new byte and
|
|
checks if it is inside the range. If a violation was detected, set up an
|
|
error message and return false. Otherwise, return true.
|
|
|
|
@param[in] ranges list of integers; interpreted as list of pairs of
|
|
inclusive lower and upper bound, respectively
|
|
|
|
@pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
|
|
1, 2, or 3 pairs. This precondition is enforced by an assertion.
|
|
|
|
@return true if and only if no range violation was detected
|
|
*/
|
|
bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
|
|
{
|
|
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
|
|
add(current);
|
|
|
|
for (auto range = ranges.begin(); range != ranges.end(); ++range)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
|
|
{
|
|
add(current);
|
|
}
|
|
else
|
|
{
|
|
error_message = "invalid string: ill-formed UTF-8 byte";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
@brief scan a string literal
|
|
|
|
This function scans a string according to Sect. 7 of RFC 8259. While
|
|
scanning, bytes are escaped and copied into buffer token_buffer. Then the
|
|
function returns successfully, token_buffer is *not* null-terminated (as it
|
|
may contain \0 bytes), and token_buffer.size() is the number of bytes in the
|
|
string.
|
|
|
|
@return token_type::value_string if string could be successfully scanned,
|
|
token_type::parse_error otherwise
|
|
|
|
@note In case of errors, variable error_message contains a textual
|
|
description.
|
|
*/
|
|
token_type scan_string()
|
|
{
|
|
// reset token_buffer (ignore opening quote)
|
|
reset();
|
|
|
|
// we entered the function by reading an open quote
|
|
JSON_ASSERT(current == '\"');
|
|
|
|
while (true)
|
|
{
|
|
// get next character
|
|
switch (get())
|
|
{
|
|
// end of file while parsing string
|
|
case std::char_traits<char_type>::eof():
|
|
{
|
|
error_message = "invalid string: missing closing quote";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
// closing quote
|
|
case '\"':
|
|
{
|
|
return token_type::value_string;
|
|
}
|
|
|
|
// escapes
|
|
case '\\':
|
|
{
|
|
switch (get())
|
|
{
|
|
// quotation mark
|
|
case '\"':
|
|
add('\"');
|
|
break;
|
|
// reverse solidus
|
|
case '\\':
|
|
add('\\');
|
|
break;
|
|
// solidus
|
|
case '/':
|
|
add('/');
|
|
break;
|
|
// backspace
|
|
case 'b':
|
|
add('\b');
|
|
break;
|
|
// form feed
|
|
case 'f':
|
|
add('\f');
|
|
break;
|
|
// line feed
|
|
case 'n':
|
|
add('\n');
|
|
break;
|
|
// carriage return
|
|
case 'r':
|
|
add('\r');
|
|
break;
|
|
// tab
|
|
case 't':
|
|
add('\t');
|
|
break;
|
|
|
|
// unicode escapes
|
|
case 'u':
|
|
{
|
|
const int codepoint1 = get_codepoint();
|
|
int codepoint = codepoint1; // start with codepoint1
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
|
|
{
|
|
error_message = "invalid string: '\\u' must be followed by 4 hex digits";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
// check if code point is a high surrogate
|
|
if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
|
|
{
|
|
// expect next \uxxxx entry
|
|
if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
|
|
{
|
|
const int codepoint2 = get_codepoint();
|
|
|
|
if (JSON_HEDLEY_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 && codepoint2 <= 0xDFFF))
|
|
{
|
|
// overwrite codepoint
|
|
codepoint = static_cast<int>(
|
|
// high surrogate occupies the most significant 22 bits
|
|
(static_cast<unsigned int>(codepoint1) << 10u)
|
|
// low surrogate occupies the least significant 15 bits
|
|
+ static_cast<unsigned int>(codepoint2)
|
|
// there is still the 0xD800, 0xDC00 and 0x10000 noise
|
|
// in the result, so we have to subtract with:
|
|
// (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
|
|
- 0x35FDC00u);
|
|
}
|
|
else
|
|
{
|
|
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
|
|
{
|
|
error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
|
|
// result of the above calculation yields a proper codepoint
|
|
JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
|
|
|
|
// translate codepoint into bytes
|
|
if (codepoint < 0x80)
|
|
{
|
|
// 1-byte characters: 0xxxxxxx (ASCII)
|
|
add(static_cast<char_int_type>(codepoint));
|
|
}
|
|
else if (codepoint <= 0x7FF)
|
|
{
|
|
// 2-byte characters: 110xxxxx 10xxxxxx
|
|
add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
|
|
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
|
|
}
|
|
else if (codepoint <= 0xFFFF)
|
|
{
|
|
// 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
|
|
add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
|
|
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
|
|
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
|
|
}
|
|
else
|
|
{
|
|
// 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
|
add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
|
|
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
|
|
add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
|
|
add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// other characters after escape
|
|
default:
|
|
error_message = "invalid string: forbidden character after backslash";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// invalid control characters
|
|
case 0x00:
|
|
{
|
|
error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x01:
|
|
{
|
|
error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x02:
|
|
{
|
|
error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x03:
|
|
{
|
|
error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x04:
|
|
{
|
|
error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x05:
|
|
{
|
|
error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x06:
|
|
{
|
|
error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x07:
|
|
{
|
|
error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x08:
|
|
{
|
|
error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x09:
|
|
{
|
|
error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x0A:
|
|
{
|
|
error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x0B:
|
|
{
|
|
error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x0C:
|
|
{
|
|
error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x0D:
|
|
{
|
|
error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x0E:
|
|
{
|
|
error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x0F:
|
|
{
|
|
error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x10:
|
|
{
|
|
error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x11:
|
|
{
|
|
error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x12:
|
|
{
|
|
error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x13:
|
|
{
|
|
error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x14:
|
|
{
|
|
error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x15:
|
|
{
|
|
error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x16:
|
|
{
|
|
error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x17:
|
|
{
|
|
error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x18:
|
|
{
|
|
error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x19:
|
|
{
|
|
error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x1A:
|
|
{
|
|
error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x1B:
|
|
{
|
|
error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x1C:
|
|
{
|
|
error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x1D:
|
|
{
|
|
error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x1E:
|
|
{
|
|
error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
case 0x1F:
|
|
{
|
|
error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
// U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2A:
|
|
case 0x2B:
|
|
case 0x2C:
|
|
case 0x2D:
|
|
case 0x2E:
|
|
case 0x2F:
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39:
|
|
case 0x3A:
|
|
case 0x3B:
|
|
case 0x3C:
|
|
case 0x3D:
|
|
case 0x3E:
|
|
case 0x3F:
|
|
case 0x40:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4A:
|
|
case 0x4B:
|
|
case 0x4C:
|
|
case 0x4D:
|
|
case 0x4E:
|
|
case 0x4F:
|
|
case 0x50:
|
|
case 0x51:
|
|
case 0x52:
|
|
case 0x53:
|
|
case 0x54:
|
|
case 0x55:
|
|
case 0x56:
|
|
case 0x57:
|
|
case 0x58:
|
|
case 0x59:
|
|
case 0x5A:
|
|
case 0x5B:
|
|
case 0x5D:
|
|
case 0x5E:
|
|
case 0x5F:
|
|
case 0x60:
|
|
case 0x61:
|
|
case 0x62:
|
|
case 0x63:
|
|
case 0x64:
|
|
case 0x65:
|
|
case 0x66:
|
|
case 0x67:
|
|
case 0x68:
|
|
case 0x69:
|
|
case 0x6A:
|
|
case 0x6B:
|
|
case 0x6C:
|
|
case 0x6D:
|
|
case 0x6E:
|
|
case 0x6F:
|
|
case 0x70:
|
|
case 0x71:
|
|
case 0x72:
|
|
case 0x73:
|
|
case 0x74:
|
|
case 0x75:
|
|
case 0x76:
|
|
case 0x77:
|
|
case 0x78:
|
|
case 0x79:
|
|
case 0x7A:
|
|
case 0x7B:
|
|
case 0x7C:
|
|
case 0x7D:
|
|
case 0x7E:
|
|
case 0x7F:
|
|
{
|
|
add(current);
|
|
break;
|
|
}
|
|
|
|
// U+0080..U+07FF: bytes C2..DF 80..BF
|
|
case 0xC2:
|
|
case 0xC3:
|
|
case 0xC4:
|
|
case 0xC5:
|
|
case 0xC6:
|
|
case 0xC7:
|
|
case 0xC8:
|
|
case 0xC9:
|
|
case 0xCA:
|
|
case 0xCB:
|
|
case 0xCC:
|
|
case 0xCD:
|
|
case 0xCE:
|
|
case 0xCF:
|
|
case 0xD0:
|
|
case 0xD1:
|
|
case 0xD2:
|
|
case 0xD3:
|
|
case 0xD4:
|
|
case 0xD5:
|
|
case 0xD6:
|
|
case 0xD7:
|
|
case 0xD8:
|
|
case 0xD9:
|
|
case 0xDA:
|
|
case 0xDB:
|
|
case 0xDC:
|
|
case 0xDD:
|
|
case 0xDE:
|
|
case 0xDF:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// U+0800..U+0FFF: bytes E0 A0..BF 80..BF
|
|
case 0xE0:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
|
|
// U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
|
|
case 0xE1:
|
|
case 0xE2:
|
|
case 0xE3:
|
|
case 0xE4:
|
|
case 0xE5:
|
|
case 0xE6:
|
|
case 0xE7:
|
|
case 0xE8:
|
|
case 0xE9:
|
|
case 0xEA:
|
|
case 0xEB:
|
|
case 0xEC:
|
|
case 0xEE:
|
|
case 0xEF:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// U+D000..U+D7FF: bytes ED 80..9F 80..BF
|
|
case 0xED:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
|
|
case 0xF0:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
|
|
case 0xF1:
|
|
case 0xF2:
|
|
case 0xF3:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
|
|
case 0xF4:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// remaining bytes (80..C1 and F5..FF) are ill-formed
|
|
default:
|
|
{
|
|
error_message = "invalid string: ill-formed UTF-8 byte";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief scan a comment
|
|
* @return whether comment could be scanned successfully
|
|
*/
|
|
bool scan_comment()
|
|
{
|
|
switch (get())
|
|
{
|
|
// single-line comments skip input until a newline or EOF is read
|
|
case '/':
|
|
{
|
|
while (true)
|
|
{
|
|
switch (get())
|
|
{
|
|
case '\n':
|
|
case '\r':
|
|
case std::char_traits<char_type>::eof():
|
|
case '\0':
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// multi-line comments skip input until */ is read
|
|
case '*':
|
|
{
|
|
while (true)
|
|
{
|
|
switch (get())
|
|
{
|
|
case std::char_traits<char_type>::eof():
|
|
case '\0':
|
|
{
|
|
error_message = "invalid comment; missing closing '*/'";
|
|
return false;
|
|
}
|
|
|
|
case '*':
|
|
{
|
|
switch (get())
|
|
{
|
|
case '/':
|
|
return true;
|
|
|
|
default:
|
|
{
|
|
unget();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
default:
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// unexpected character after reading '/'
|
|
default:
|
|
{
|
|
error_message = "invalid comment; expecting '/' or '*' after '/'";
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
@brief scan a number literal
|
|
|
|
This function scans a string according to Sect. 6 of RFC 8259.
|
|
|
|
The function is realized with a deterministic finite state machine derived
|
|
from the grammar described in RFC 8259. Starting in state "init", the
|
|
input is read and used to determined the next state. Only state "done"
|
|
accepts the number. State "error" is a trap state to model errors. In the
|
|
table below, "anything" means any character but the ones listed before.
|
|
|
|
state | 0 | 1-9 | e E | + | - | . | anything
|
|
---------|----------|----------|----------|---------|---------|----------|-----------
|
|
init | zero | any1 | [error] | [error] | minus | [error] | [error]
|
|
minus | zero | any1 | [error] | [error] | [error] | [error] | [error]
|
|
zero | done | done | exponent | done | done | decimal1 | done
|
|
any1 | any1 | any1 | exponent | done | done | decimal1 | done
|
|
decimal1 | decimal2 | decimal2 | [error] | [error] | [error] | [error] | [error]
|
|
decimal2 | decimal2 | decimal2 | exponent | done | done | done | done
|
|
exponent | any2 | any2 | [error] | sign | sign | [error] | [error]
|
|
sign | any2 | any2 | [error] | [error] | [error] | [error] | [error]
|
|
any2 | any2 | any2 | done | done | done | done | done
|
|
|
|
The state machine is realized with one label per state (prefixed with
|
|
"scan_number_") and `goto` statements between them. The state machine
|
|
contains cycles, but any cycle can be left when EOF is read. Therefore,
|
|
the function is guaranteed to terminate.
|
|
|
|
During scanning, the read bytes are stored in token_buffer. This string is
|
|
then converted to a signed integer, an unsigned integer, or a
|
|
floating-point number.
|
|
|
|
@return token_type::value_unsigned, token_type::value_integer, or
|
|
token_type::value_float if number could be successfully scanned,
|
|
token_type::parse_error otherwise
|
|
|
|
@note The scanner is independent of the current locale. Internally, the
|
|
locale's decimal point is used instead of `.` to work with the
|
|
locale-dependent converters.
|
|
*/
|
|
token_type scan_number() // lgtm [cpp/use-of-goto]
|
|
{
|
|
// reset token_buffer to store the number's bytes
|
|
reset();
|
|
|
|
// the type of the parsed number; initially set to unsigned; will be
|
|
// changed if minus sign, decimal point or exponent is read
|
|
token_type number_type = token_type::value_unsigned;
|
|
|
|
// state (init): we just found out we need to scan a number
|
|
switch (current)
|
|
{
|
|
case '-':
|
|
{
|
|
add(current);
|
|
goto scan_number_minus;
|
|
}
|
|
|
|
case '0':
|
|
{
|
|
add(current);
|
|
goto scan_number_zero;
|
|
}
|
|
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_any1;
|
|
}
|
|
|
|
// all other characters are rejected outside scan_number()
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
|
|
scan_number_minus:
|
|
// state: we just parsed a leading minus sign
|
|
number_type = token_type::value_integer;
|
|
switch (get())
|
|
{
|
|
case '0':
|
|
{
|
|
add(current);
|
|
goto scan_number_zero;
|
|
}
|
|
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_any1;
|
|
}
|
|
|
|
default:
|
|
{
|
|
error_message = "invalid number; expected digit after '-'";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
|
|
scan_number_zero:
|
|
// state: we just parse a zero (maybe with a leading minus sign)
|
|
switch (get())
|
|
{
|
|
case '.':
|
|
{
|
|
add(decimal_point_char);
|
|
goto scan_number_decimal1;
|
|
}
|
|
|
|
case 'e':
|
|
case 'E':
|
|
{
|
|
add(current);
|
|
goto scan_number_exponent;
|
|
}
|
|
|
|
default:
|
|
goto scan_number_done;
|
|
}
|
|
|
|
scan_number_any1:
|
|
// state: we just parsed a number 0-9 (maybe with a leading minus sign)
|
|
switch (get())
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_any1;
|
|
}
|
|
|
|
case '.':
|
|
{
|
|
add(decimal_point_char);
|
|
goto scan_number_decimal1;
|
|
}
|
|
|
|
case 'e':
|
|
case 'E':
|
|
{
|
|
add(current);
|
|
goto scan_number_exponent;
|
|
}
|
|
|
|
default:
|
|
goto scan_number_done;
|
|
}
|
|
|
|
scan_number_decimal1:
|
|
// state: we just parsed a decimal point
|
|
number_type = token_type::value_float;
|
|
switch (get())
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_decimal2;
|
|
}
|
|
|
|
default:
|
|
{
|
|
error_message = "invalid number; expected digit after '.'";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
|
|
scan_number_decimal2:
|
|
// we just parsed at least one number after a decimal point
|
|
switch (get())
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_decimal2;
|
|
}
|
|
|
|
case 'e':
|
|
case 'E':
|
|
{
|
|
add(current);
|
|
goto scan_number_exponent;
|
|
}
|
|
|
|
default:
|
|
goto scan_number_done;
|
|
}
|
|
|
|
scan_number_exponent:
|
|
// we just parsed an exponent
|
|
number_type = token_type::value_float;
|
|
switch (get())
|
|
{
|
|
case '+':
|
|
case '-':
|
|
{
|
|
add(current);
|
|
goto scan_number_sign;
|
|
}
|
|
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_any2;
|
|
}
|
|
|
|
default:
|
|
{
|
|
error_message =
|
|
"invalid number; expected '+', '-', or digit after exponent";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
|
|
scan_number_sign:
|
|
// we just parsed an exponent sign
|
|
switch (get())
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_any2;
|
|
}
|
|
|
|
default:
|
|
{
|
|
error_message = "invalid number; expected digit after exponent sign";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
|
|
scan_number_any2:
|
|
// we just parsed a number after the exponent or exponent sign
|
|
switch (get())
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
{
|
|
add(current);
|
|
goto scan_number_any2;
|
|
}
|
|
|
|
default:
|
|
goto scan_number_done;
|
|
}
|
|
|
|
scan_number_done:
|
|
// unget the character after the number (we only read it to know that
|
|
// we are done scanning a number)
|
|
unget();
|
|
|
|
char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
errno = 0;
|
|
|
|
// try to parse integers first and fall back to floats
|
|
if (number_type == token_type::value_unsigned)
|
|
{
|
|
const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
|
|
|
|
// we checked the number format before
|
|
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
|
|
|
|
if (errno == 0)
|
|
{
|
|
value_unsigned = static_cast<number_unsigned_t>(x);
|
|
if (value_unsigned == x)
|
|
{
|
|
return token_type::value_unsigned;
|
|
}
|
|
}
|
|
}
|
|
else if (number_type == token_type::value_integer)
|
|
{
|
|
const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
|
|
|
|
// we checked the number format before
|
|
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
|
|
|
|
if (errno == 0)
|
|
{
|
|
value_integer = static_cast<number_integer_t>(x);
|
|
if (value_integer == x)
|
|
{
|
|
return token_type::value_integer;
|
|
}
|
|
}
|
|
}
|
|
|
|
// this code is reached if we parse a floating-point number or if an
|
|
// integer conversion above failed
|
|
strtof(value_float, token_buffer.data(), &endptr);
|
|
|
|
// we checked the number format before
|
|
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
|
|
|
|
return token_type::value_float;
|
|
}
|
|
|
|
/*!
|
|
@param[in] literal_text the literal text to expect
|
|
@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_type* literal_text, const std::size_t length,
|
|
token_type return_type)
|
|
{
|
|
JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
|
|
for (std::size_t i = 1; i < length; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
|
|
{
|
|
error_message = "invalid literal";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
return return_type;
|
|
}
|
|
|
|
/////////////////////
|
|
// input management
|
|
/////////////////////
|
|
|
|
/// reset token_buffer; current character is beginning of token
|
|
void reset() noexcept
|
|
{
|
|
token_buffer.clear();
|
|
token_string.clear();
|
|
token_string.push_back(std::char_traits<char_type>::to_char_type(current));
|
|
}
|
|
|
|
/*
|
|
@brief get next character from the input
|
|
|
|
This function provides the interface to the used input adapter. It does
|
|
not throw in case the input reached EOF, but returns a
|
|
`std::char_traits<char>::eof()` in that case. Stores the scanned characters
|
|
for use in error messages.
|
|
|
|
@return character read from the input
|
|
*/
|
|
char_int_type get()
|
|
{
|
|
++position.chars_read_total;
|
|
++position.chars_read_current_line;
|
|
|
|
if (next_unget)
|
|
{
|
|
// just reset the next_unget variable and work with current
|
|
next_unget = false;
|
|
}
|
|
else
|
|
{
|
|
current = ia.get_character();
|
|
}
|
|
|
|
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
|
|
{
|
|
token_string.push_back(std::char_traits<char_type>::to_char_type(current));
|
|
}
|
|
|
|
if (current == '\n')
|
|
{
|
|
++position.lines_read;
|
|
position.chars_read_current_line = 0;
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
/*!
|
|
@brief unget current character (read it again on next get)
|
|
|
|
We implement unget by setting variable next_unget to true. The input is not
|
|
changed - we just simulate ungetting by modifying chars_read_total,
|
|
chars_read_current_line, and token_string. The next call to get() will
|
|
behave as if the unget character is read again.
|
|
*/
|
|
void unget()
|
|
{
|
|
next_unget = true;
|
|
|
|
--position.chars_read_total;
|
|
|
|
// in case we "unget" a newline, we have to also decrement the lines_read
|
|
if (position.chars_read_current_line == 0)
|
|
{
|
|
if (position.lines_read > 0)
|
|
{
|
|
--position.lines_read;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--position.chars_read_current_line;
|
|
}
|
|
|
|
if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
|
|
{
|
|
JSON_ASSERT(!token_string.empty());
|
|
token_string.pop_back();
|
|
}
|
|
}
|
|
|
|
/// add a character to token_buffer
|
|
void add(char_int_type c)
|
|
{
|
|
token_buffer.push_back(static_cast<typename string_t::value_type>(c));
|
|
}
|
|
|
|
public:
|
|
/////////////////////
|
|
// value getters
|
|
/////////////////////
|
|
|
|
/// return integer value
|
|
constexpr number_integer_t get_number_integer() const noexcept
|
|
{
|
|
return value_integer;
|
|
}
|
|
|
|
/// return unsigned integer value
|
|
constexpr number_unsigned_t get_number_unsigned() const noexcept
|
|
{
|
|
return value_unsigned;
|
|
}
|
|
|
|
/// return floating-point value
|
|
constexpr number_float_t get_number_float() const noexcept
|
|
{
|
|
return value_float;
|
|
}
|
|
|
|
/// return current string value (implicitly resets the token; useful only once)
|
|
string_t& get_string()
|
|
{
|
|
return token_buffer;
|
|
}
|
|
|
|
/////////////////////
|
|
// diagnostics
|
|
/////////////////////
|
|
|
|
/// return position of last read token
|
|
constexpr position_t get_position() const noexcept
|
|
{
|
|
return position;
|
|
}
|
|
|
|
/// return the last read token (for errors only). Will never contain EOF
|
|
/// (an arbitrary value that is not a valid char value, often -1), because
|
|
/// 255 may legitimately occur. May contain NUL, which should be escaped.
|
|
std::string get_token_string() const
|
|
{
|
|
// escape control characters
|
|
std::string result;
|
|
for (const auto c : token_string)
|
|
{
|
|
if (static_cast<unsigned char>(c) <= '\x1F')
|
|
{
|
|
// escape control characters
|
|
std::array<char, 9> cs{{}};
|
|
static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
result += cs.data();
|
|
}
|
|
else
|
|
{
|
|
// add character as is
|
|
result.push_back(static_cast<std::string::value_type>(c));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// return syntax error message
|
|
JSON_HEDLEY_RETURNS_NON_NULL
|
|
constexpr const char* get_error_message() const noexcept
|
|
{
|
|
return error_message;
|
|
}
|
|
|
|
/////////////////////
|
|
// actual scanner
|
|
/////////////////////
|
|
|
|
/*!
|
|
@brief skip the UTF-8 byte order mark
|
|
@return true iff there is no BOM or the correct BOM has been skipped
|
|
*/
|
|
bool skip_bom()
|
|
{
|
|
if (get() == 0xEF)
|
|
{
|
|
// check if we completely parse the BOM
|
|
return get() == 0xBB && get() == 0xBF;
|
|
}
|
|
|
|
// the first character is not the beginning of the BOM; unget it to
|
|
// process is later
|
|
unget();
|
|
return true;
|
|
}
|
|
|
|
void skip_whitespace()
|
|
{
|
|
do
|
|
{
|
|
get();
|
|
}
|
|
while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
|
|
}
|
|
|
|
token_type scan()
|
|
{
|
|
// initially, skip the BOM
|
|
if (position.chars_read_total == 0 && !skip_bom())
|
|
{
|
|
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
// read next character and ignore whitespace
|
|
skip_whitespace();
|
|
|
|
// ignore comments
|
|
while (ignore_comments && current == '/')
|
|
{
|
|
if (!scan_comment())
|
|
{
|
|
return token_type::parse_error;
|
|
}
|
|
|
|
// skip following whitespace
|
|
skip_whitespace();
|
|
}
|
|
|
|
switch (current)
|
|
{
|
|
// structural characters
|
|
case '[':
|
|
return token_type::begin_array;
|
|
case ']':
|
|
return token_type::end_array;
|
|
case '{':
|
|
return token_type::begin_object;
|
|
case '}':
|
|
return token_type::end_object;
|
|
case ':':
|
|
return token_type::name_separator;
|
|
case ',':
|
|
return token_type::value_separator;
|
|
|
|
// literals
|
|
case 't':
|
|
{
|
|
std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
|
|
return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
|
|
}
|
|
case 'f':
|
|
{
|
|
std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
|
|
return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
|
|
}
|
|
case 'n':
|
|
{
|
|
std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
|
|
return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
|
|
}
|
|
|
|
// string
|
|
case '\"':
|
|
return scan_string();
|
|
|
|
// number
|
|
case '-':
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
return scan_number();
|
|
|
|
// end of input (the null byte is needed when parsing from
|
|
// string literals)
|
|
case '\0':
|
|
case std::char_traits<char_type>::eof():
|
|
return token_type::end_of_input;
|
|
|
|
// error
|
|
default:
|
|
error_message = "invalid literal";
|
|
return token_type::parse_error;
|
|
}
|
|
}
|
|
|
|
private:
|
|
/// input adapter
|
|
InputAdapterType ia;
|
|
|
|
/// whether comments should be ignored (true) or signaled as errors (false)
|
|
const bool ignore_comments = false;
|
|
|
|
/// the current character
|
|
char_int_type current = std::char_traits<char_type>::eof();
|
|
|
|
/// whether the next get() call should just return current
|
|
bool next_unget = false;
|
|
|
|
/// the start position of the current token
|
|
position_t position {};
|
|
|
|
/// raw input token string (for error messages)
|
|
std::vector<char_type> token_string {};
|
|
|
|
/// buffer for variable-length tokens (numbers, strings)
|
|
string_t token_buffer {};
|
|
|
|
/// a description of occurred lexer errors
|
|
const char* error_message = "";
|
|
|
|
// number values
|
|
number_integer_t value_integer = 0;
|
|
number_unsigned_t value_unsigned = 0;
|
|
number_float_t value_float = 0;
|
|
|
|
/// the decimal point
|
|
const char_int_type decimal_point_char = '.';
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/is_sax.hpp>
|
|
|
|
|
|
#include <cstdint> // size_t
|
|
#include <utility> // declval
|
|
#include <string> // string
|
|
|
|
// #include <nlohmann/detail/meta/detected.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename T>
|
|
using null_function_t = decltype(std::declval<T&>().null());
|
|
|
|
template<typename T>
|
|
using boolean_function_t =
|
|
decltype(std::declval<T&>().boolean(std::declval<bool>()));
|
|
|
|
template<typename T, typename Integer>
|
|
using number_integer_function_t =
|
|
decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
|
|
|
|
template<typename T, typename Unsigned>
|
|
using number_unsigned_function_t =
|
|
decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
|
|
|
|
template<typename T, typename Float, typename String>
|
|
using number_float_function_t = decltype(std::declval<T&>().number_float(
|
|
std::declval<Float>(), std::declval<const String&>()));
|
|
|
|
template<typename T, typename String>
|
|
using string_function_t =
|
|
decltype(std::declval<T&>().string(std::declval<String&>()));
|
|
|
|
template<typename T, typename Binary>
|
|
using binary_function_t =
|
|
decltype(std::declval<T&>().binary(std::declval<Binary&>()));
|
|
|
|
template<typename T>
|
|
using start_object_function_t =
|
|
decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
|
|
|
|
template<typename T, typename String>
|
|
using key_function_t =
|
|
decltype(std::declval<T&>().key(std::declval<String&>()));
|
|
|
|
template<typename T>
|
|
using end_object_function_t = decltype(std::declval<T&>().end_object());
|
|
|
|
template<typename T>
|
|
using start_array_function_t =
|
|
decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
|
|
|
|
template<typename T>
|
|
using end_array_function_t = decltype(std::declval<T&>().end_array());
|
|
|
|
template<typename T, typename Exception>
|
|
using parse_error_function_t = decltype(std::declval<T&>().parse_error(
|
|
std::declval<std::size_t>(), std::declval<const std::string&>(),
|
|
std::declval<const Exception&>()));
|
|
|
|
template<typename SAX, typename BasicJsonType>
|
|
struct is_sax
|
|
{
|
|
private:
|
|
static_assert(is_basic_json<BasicJsonType>::value,
|
|
"BasicJsonType must be of type basic_json<...>");
|
|
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
using exception_t = typename BasicJsonType::exception;
|
|
|
|
public:
|
|
static constexpr bool value =
|
|
is_detected_exact<bool, null_function_t, SAX>::value &&
|
|
is_detected_exact<bool, boolean_function_t, SAX>::value &&
|
|
is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
|
|
is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
|
|
is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
|
|
is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
|
|
is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
|
|
is_detected_exact<bool, start_object_function_t, SAX>::value &&
|
|
is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
|
|
is_detected_exact<bool, end_object_function_t, SAX>::value &&
|
|
is_detected_exact<bool, start_array_function_t, SAX>::value &&
|
|
is_detected_exact<bool, end_array_function_t, SAX>::value &&
|
|
is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
|
|
};
|
|
|
|
template<typename SAX, typename BasicJsonType>
|
|
struct is_sax_static_asserts
|
|
{
|
|
private:
|
|
static_assert(is_basic_json<BasicJsonType>::value,
|
|
"BasicJsonType must be of type basic_json<...>");
|
|
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
using exception_t = typename BasicJsonType::exception;
|
|
|
|
public:
|
|
static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
|
|
"Missing/invalid function: bool null()");
|
|
static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
|
|
"Missing/invalid function: bool boolean(bool)");
|
|
static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
|
|
"Missing/invalid function: bool boolean(bool)");
|
|
static_assert(
|
|
is_detected_exact<bool, number_integer_function_t, SAX,
|
|
number_integer_t>::value,
|
|
"Missing/invalid function: bool number_integer(number_integer_t)");
|
|
static_assert(
|
|
is_detected_exact<bool, number_unsigned_function_t, SAX,
|
|
number_unsigned_t>::value,
|
|
"Missing/invalid function: bool number_unsigned(number_unsigned_t)");
|
|
static_assert(is_detected_exact<bool, number_float_function_t, SAX,
|
|
number_float_t, string_t>::value,
|
|
"Missing/invalid function: bool number_float(number_float_t, const string_t&)");
|
|
static_assert(
|
|
is_detected_exact<bool, string_function_t, SAX, string_t>::value,
|
|
"Missing/invalid function: bool string(string_t&)");
|
|
static_assert(
|
|
is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
|
|
"Missing/invalid function: bool binary(binary_t&)");
|
|
static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
|
|
"Missing/invalid function: bool start_object(std::size_t)");
|
|
static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
|
|
"Missing/invalid function: bool key(string_t&)");
|
|
static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
|
|
"Missing/invalid function: bool end_object()");
|
|
static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
|
|
"Missing/invalid function: bool start_array(std::size_t)");
|
|
static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
|
|
"Missing/invalid function: bool end_array()");
|
|
static_assert(
|
|
is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
|
|
"Missing/invalid function: bool parse_error(std::size_t, const "
|
|
"std::string&, const exception&)");
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
|
|
/// how to treat CBOR tags
|
|
enum class cbor_tag_handler_t
|
|
{
|
|
error, ///< throw a parse_error exception in case of a tag
|
|
ignore, ///< ignore tags
|
|
store ///< store tags as binary type
|
|
};
|
|
|
|
/*!
|
|
@brief determine system byte order
|
|
|
|
@return true if and only if system's byte order is little endian
|
|
|
|
@note from https://stackoverflow.com/a/1001328/266378
|
|
*/
|
|
static inline bool little_endianness(int num = 1) noexcept
|
|
{
|
|
return *reinterpret_cast<char*>(&num) == 1;
|
|
}
|
|
|
|
|
|
///////////////////
|
|
// binary reader //
|
|
///////////////////
|
|
|
|
/*!
|
|
@brief deserialization of CBOR, MessagePack, and UBJSON values
|
|
*/
|
|
template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
|
|
class binary_reader
|
|
{
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
using json_sax_t = SAX;
|
|
using char_type = typename InputAdapterType::char_type;
|
|
using char_int_type = typename std::char_traits<char_type>::int_type;
|
|
|
|
public:
|
|
/*!
|
|
@brief create a binary reader
|
|
|
|
@param[in] adapter input adapter to read from
|
|
*/
|
|
explicit binary_reader(InputAdapterType&& adapter) noexcept : ia(std::move(adapter))
|
|
{
|
|
(void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
|
|
}
|
|
|
|
// make class move-only
|
|
binary_reader(const binary_reader&) = delete;
|
|
binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
binary_reader& operator=(const binary_reader&) = delete;
|
|
binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
|
|
~binary_reader() = default;
|
|
|
|
/*!
|
|
@param[in] format the binary format to parse
|
|
@param[in] sax_ a SAX event processor
|
|
@param[in] strict whether to expect the input to be consumed completed
|
|
@param[in] tag_handler how to treat CBOR tags
|
|
|
|
@return whether parsing was successful
|
|
*/
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
bool sax_parse(const input_format_t format,
|
|
json_sax_t* sax_,
|
|
const bool strict = true,
|
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
|
{
|
|
sax = sax_;
|
|
bool result = false;
|
|
|
|
switch (format)
|
|
{
|
|
case input_format_t::bson:
|
|
result = parse_bson_internal();
|
|
break;
|
|
|
|
case input_format_t::cbor:
|
|
result = parse_cbor_internal(true, tag_handler);
|
|
break;
|
|
|
|
case input_format_t::msgpack:
|
|
result = parse_msgpack_internal();
|
|
break;
|
|
|
|
case input_format_t::ubjson:
|
|
result = parse_ubjson_internal();
|
|
break;
|
|
|
|
case input_format_t::json: // LCOV_EXCL_LINE
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
|
|
// strict mode: next byte must be EOF
|
|
if (result && strict)
|
|
{
|
|
if (format == input_format_t::ubjson)
|
|
{
|
|
get_ignore_noop();
|
|
}
|
|
else
|
|
{
|
|
get();
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::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"), BasicJsonType()));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
//////////
|
|
// BSON //
|
|
//////////
|
|
|
|
/*!
|
|
@brief Reads in a BSON-object and passes it to the SAX-parser.
|
|
@return whether a valid BSON-value was passed to the SAX parser
|
|
*/
|
|
bool parse_bson_internal()
|
|
{
|
|
std::int32_t document_size{};
|
|
get_number<std::int32_t, true>(input_format_t::bson, document_size);
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return sax->end_object();
|
|
}
|
|
|
|
/*!
|
|
@brief Parses a C-style string from the BSON input.
|
|
@param[in,out] result A reference to the string variable where the read
|
|
string is to be stored.
|
|
@return `true` if the \x00-byte indicating the end of the string was
|
|
encountered before the EOF; false` indicates an unexpected EOF.
|
|
*/
|
|
bool get_bson_cstr(string_t& result)
|
|
{
|
|
auto out = std::back_inserter(result);
|
|
while (true)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
|
|
{
|
|
return false;
|
|
}
|
|
if (current == 0x00)
|
|
{
|
|
return true;
|
|
}
|
|
*out++ = static_cast<typename string_t::value_type>(current);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief Parses a zero-terminated string of length @a len from the BSON
|
|
input.
|
|
@param[in] len The length (including the zero-byte at the end) of the
|
|
string to be read.
|
|
@param[in,out] result A reference to the string variable where the read
|
|
string is to be stored.
|
|
@tparam NumberType The type of the length @a len
|
|
@pre len >= 1
|
|
@return `true` if the string was successfully parsed
|
|
*/
|
|
template<typename NumberType>
|
|
bool get_bson_string(const NumberType len, string_t& result)
|
|
{
|
|
if (JSON_HEDLEY_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"), BasicJsonType()));
|
|
}
|
|
|
|
return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
|
|
}
|
|
|
|
/*!
|
|
@brief Parses a byte array input of length @a len from the BSON input.
|
|
@param[in] len The length of the byte array to be read.
|
|
@param[in,out] result A reference to the binary variable where the read
|
|
array is to be stored.
|
|
@tparam NumberType The type of the length @a len
|
|
@pre len >= 0
|
|
@return `true` if the byte array was successfully parsed
|
|
*/
|
|
template<typename NumberType>
|
|
bool get_bson_binary(const NumberType len, binary_t& result)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(len < 0))
|
|
{
|
|
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, "byte array length cannot be negative, is " + std::to_string(len), "binary"), BasicJsonType()));
|
|
}
|
|
|
|
// All BSON binary values have a subtype
|
|
std::uint8_t subtype{};
|
|
get_number<std::uint8_t>(input_format_t::bson, subtype);
|
|
result.set_subtype(subtype);
|
|
|
|
return get_binary(input_format_t::bson, len, result);
|
|
}
|
|
|
|
/*!
|
|
@brief Read a BSON document element of the given @a element_type.
|
|
@param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
|
|
@param[in] element_type_parse_position The position in the input stream,
|
|
where the `element_type` was read.
|
|
@warning Not all BSON element types are supported yet. An unsupported
|
|
@a element_type will give rise to a parse_error.114:
|
|
Unsupported BSON record type 0x...
|
|
@return whether a valid BSON-object/array was passed to the SAX parser
|
|
*/
|
|
bool parse_bson_element_internal(const char_int_type element_type,
|
|
const std::size_t element_type_parse_position)
|
|
{
|
|
switch (element_type)
|
|
{
|
|
case 0x01: // double
|
|
{
|
|
double number{};
|
|
return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
case 0x02: // string
|
|
{
|
|
std::int32_t len{};
|
|
string_t value;
|
|
return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
|
|
}
|
|
|
|
case 0x03: // object
|
|
{
|
|
return parse_bson_internal();
|
|
}
|
|
|
|
case 0x04: // array
|
|
{
|
|
return parse_bson_array();
|
|
}
|
|
|
|
case 0x05: // binary
|
|
{
|
|
std::int32_t len{};
|
|
binary_t value;
|
|
return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
|
|
}
|
|
|
|
case 0x08: // boolean
|
|
{
|
|
return sax->boolean(get() != 0);
|
|
}
|
|
|
|
case 0x0A: // null
|
|
{
|
|
return sax->null();
|
|
}
|
|
|
|
case 0x10: // int32
|
|
{
|
|
std::int32_t value{};
|
|
return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
|
|
}
|
|
|
|
case 0x12: // int64
|
|
{
|
|
std::int64_t value{};
|
|
return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
|
|
}
|
|
|
|
default: // anything else not supported (yet)
|
|
{
|
|
std::array<char, 3> cr{{}};
|
|
static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data()), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief Read a BSON element list (as specified in the BSON-spec)
|
|
|
|
The same binary layout is used for objects and arrays, hence it must be
|
|
indicated with the argument @a is_array which one is expected
|
|
(true --> array, false --> object).
|
|
|
|
@param[in] is_array Determines if the element list being read is to be
|
|
treated as an object (@a is_array == false), or as an
|
|
array (@a is_array == true).
|
|
@return whether a valid BSON-object/array was passed to the SAX parser
|
|
*/
|
|
bool parse_bson_element_list(const bool is_array)
|
|
{
|
|
string_t key;
|
|
|
|
while (auto element_type = get())
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const std::size_t element_type_parse_position = chars_read;
|
|
if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!is_array && !sax->key(key))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// get_bson_cstr only appends
|
|
key.clear();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
@brief Reads an array from the BSON input and passes it to the SAX-parser.
|
|
@return whether a valid BSON-array was passed to the SAX parser
|
|
*/
|
|
bool parse_bson_array()
|
|
{
|
|
std::int32_t document_size{};
|
|
get_number<std::int32_t, true>(input_format_t::bson, document_size);
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return sax->end_array();
|
|
}
|
|
|
|
//////////
|
|
// CBOR //
|
|
//////////
|
|
|
|
/*!
|
|
@param[in] get_char whether a new character should be retrieved from the
|
|
input (true) or whether the last read character should
|
|
be considered instead (false)
|
|
@param[in] tag_handler how CBOR tags should be treated
|
|
|
|
@return whether a valid CBOR value was passed to the SAX parser
|
|
*/
|
|
bool parse_cbor_internal(const bool get_char,
|
|
const cbor_tag_handler_t tag_handler)
|
|
{
|
|
switch (get_char ? get() : current)
|
|
{
|
|
// EOF
|
|
case std::char_traits<char_type>::eof():
|
|
return unexpect_eof(input_format_t::cbor, "value");
|
|
|
|
// Integer 0x00..0x17 (0..23)
|
|
case 0x00:
|
|
case 0x01:
|
|
case 0x02:
|
|
case 0x03:
|
|
case 0x04:
|
|
case 0x05:
|
|
case 0x06:
|
|
case 0x07:
|
|
case 0x08:
|
|
case 0x09:
|
|
case 0x0A:
|
|
case 0x0B:
|
|
case 0x0C:
|
|
case 0x0D:
|
|
case 0x0E:
|
|
case 0x0F:
|
|
case 0x10:
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
case 0x17:
|
|
return sax->number_unsigned(static_cast<number_unsigned_t>(current));
|
|
|
|
case 0x18: // Unsigned integer (one-byte uint8_t follows)
|
|
{
|
|
std::uint8_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0x19: // Unsigned integer (two-byte uint16_t follows)
|
|
{
|
|
std::uint16_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0x1A: // Unsigned integer (four-byte uint32_t follows)
|
|
{
|
|
std::uint32_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
|
|
{
|
|
std::uint64_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
// Negative integer -1-0x00..-1-0x17 (-1..-24)
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2A:
|
|
case 0x2B:
|
|
case 0x2C:
|
|
case 0x2D:
|
|
case 0x2E:
|
|
case 0x2F:
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
|
|
|
|
case 0x38: // Negative integer (one-byte uint8_t follows)
|
|
{
|
|
std::uint8_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
|
|
}
|
|
|
|
case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
|
|
{
|
|
std::uint16_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
|
|
}
|
|
|
|
case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
|
|
{
|
|
std::uint32_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
|
|
}
|
|
|
|
case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
|
|
{
|
|
std::uint64_t number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
|
|
- static_cast<number_integer_t>(number));
|
|
}
|
|
|
|
// Binary data (0x00..0x17 bytes follow)
|
|
case 0x40:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4A:
|
|
case 0x4B:
|
|
case 0x4C:
|
|
case 0x4D:
|
|
case 0x4E:
|
|
case 0x4F:
|
|
case 0x50:
|
|
case 0x51:
|
|
case 0x52:
|
|
case 0x53:
|
|
case 0x54:
|
|
case 0x55:
|
|
case 0x56:
|
|
case 0x57:
|
|
case 0x58: // Binary data (one-byte uint8_t for n follows)
|
|
case 0x59: // Binary data (two-byte uint16_t for n follow)
|
|
case 0x5A: // Binary data (four-byte uint32_t for n follow)
|
|
case 0x5B: // Binary data (eight-byte uint64_t for n follow)
|
|
case 0x5F: // Binary data (indefinite length)
|
|
{
|
|
binary_t b;
|
|
return get_cbor_binary(b) && sax->binary(b);
|
|
}
|
|
|
|
// UTF-8 string (0x00..0x17 bytes follow)
|
|
case 0x60:
|
|
case 0x61:
|
|
case 0x62:
|
|
case 0x63:
|
|
case 0x64:
|
|
case 0x65:
|
|
case 0x66:
|
|
case 0x67:
|
|
case 0x68:
|
|
case 0x69:
|
|
case 0x6A:
|
|
case 0x6B:
|
|
case 0x6C:
|
|
case 0x6D:
|
|
case 0x6E:
|
|
case 0x6F:
|
|
case 0x70:
|
|
case 0x71:
|
|
case 0x72:
|
|
case 0x73:
|
|
case 0x74:
|
|
case 0x75:
|
|
case 0x76:
|
|
case 0x77:
|
|
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
|
|
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
|
|
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
|
|
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
|
|
case 0x7F: // UTF-8 string (indefinite length)
|
|
{
|
|
string_t s;
|
|
return get_cbor_string(s) && sax->string(s);
|
|
}
|
|
|
|
// array (0x00..0x17 data items follow)
|
|
case 0x80:
|
|
case 0x81:
|
|
case 0x82:
|
|
case 0x83:
|
|
case 0x84:
|
|
case 0x85:
|
|
case 0x86:
|
|
case 0x87:
|
|
case 0x88:
|
|
case 0x89:
|
|
case 0x8A:
|
|
case 0x8B:
|
|
case 0x8C:
|
|
case 0x8D:
|
|
case 0x8E:
|
|
case 0x8F:
|
|
case 0x90:
|
|
case 0x91:
|
|
case 0x92:
|
|
case 0x93:
|
|
case 0x94:
|
|
case 0x95:
|
|
case 0x96:
|
|
case 0x97:
|
|
return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
|
|
|
|
case 0x98: // array (one-byte uint8_t for n follows)
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0x99: // array (two-byte uint16_t for n follow)
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0x9A: // array (four-byte uint32_t for n follow)
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0x9B: // array (eight-byte uint64_t for n follow)
|
|
{
|
|
std::uint64_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_array(detail::conditional_static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0x9F: // array (indefinite length)
|
|
return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
|
|
|
|
// map (0x00..0x17 pairs of data items follow)
|
|
case 0xA0:
|
|
case 0xA1:
|
|
case 0xA2:
|
|
case 0xA3:
|
|
case 0xA4:
|
|
case 0xA5:
|
|
case 0xA6:
|
|
case 0xA7:
|
|
case 0xA8:
|
|
case 0xA9:
|
|
case 0xAA:
|
|
case 0xAB:
|
|
case 0xAC:
|
|
case 0xAD:
|
|
case 0xAE:
|
|
case 0xAF:
|
|
case 0xB0:
|
|
case 0xB1:
|
|
case 0xB2:
|
|
case 0xB3:
|
|
case 0xB4:
|
|
case 0xB5:
|
|
case 0xB6:
|
|
case 0xB7:
|
|
return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
|
|
|
|
case 0xB8: // map (one-byte uint8_t for n follows)
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0xB9: // map (two-byte uint16_t for n follow)
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0xBA: // map (four-byte uint32_t for n follow)
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0xBB: // map (eight-byte uint64_t for n follow)
|
|
{
|
|
std::uint64_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_cbor_object(detail::conditional_static_cast<std::size_t>(len), tag_handler);
|
|
}
|
|
|
|
case 0xBF: // map (indefinite length)
|
|
return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
|
|
|
|
case 0xC6: // tagged item
|
|
case 0xC7:
|
|
case 0xC8:
|
|
case 0xC9:
|
|
case 0xCA:
|
|
case 0xCB:
|
|
case 0xCC:
|
|
case 0xCD:
|
|
case 0xCE:
|
|
case 0xCF:
|
|
case 0xD0:
|
|
case 0xD1:
|
|
case 0xD2:
|
|
case 0xD3:
|
|
case 0xD4:
|
|
case 0xD8: // tagged item (1 bytes follow)
|
|
case 0xD9: // tagged item (2 bytes follow)
|
|
case 0xDA: // tagged item (4 bytes follow)
|
|
case 0xDB: // tagged item (8 bytes follow)
|
|
{
|
|
switch (tag_handler)
|
|
{
|
|
case cbor_tag_handler_t::error:
|
|
{
|
|
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::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
|
|
}
|
|
|
|
case cbor_tag_handler_t::ignore:
|
|
{
|
|
// ignore binary subtype
|
|
switch (current)
|
|
{
|
|
case 0xD8:
|
|
{
|
|
std::uint8_t subtype_to_ignore{};
|
|
get_number(input_format_t::cbor, subtype_to_ignore);
|
|
break;
|
|
}
|
|
case 0xD9:
|
|
{
|
|
std::uint16_t subtype_to_ignore{};
|
|
get_number(input_format_t::cbor, subtype_to_ignore);
|
|
break;
|
|
}
|
|
case 0xDA:
|
|
{
|
|
std::uint32_t subtype_to_ignore{};
|
|
get_number(input_format_t::cbor, subtype_to_ignore);
|
|
break;
|
|
}
|
|
case 0xDB:
|
|
{
|
|
std::uint64_t subtype_to_ignore{};
|
|
get_number(input_format_t::cbor, subtype_to_ignore);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return parse_cbor_internal(true, tag_handler);
|
|
}
|
|
|
|
case cbor_tag_handler_t::store:
|
|
{
|
|
binary_t b;
|
|
// use binary subtype and store in binary container
|
|
switch (current)
|
|
{
|
|
case 0xD8:
|
|
{
|
|
std::uint8_t subtype{};
|
|
get_number(input_format_t::cbor, subtype);
|
|
b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
|
|
break;
|
|
}
|
|
case 0xD9:
|
|
{
|
|
std::uint16_t subtype{};
|
|
get_number(input_format_t::cbor, subtype);
|
|
b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
|
|
break;
|
|
}
|
|
case 0xDA:
|
|
{
|
|
std::uint32_t subtype{};
|
|
get_number(input_format_t::cbor, subtype);
|
|
b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
|
|
break;
|
|
}
|
|
case 0xDB:
|
|
{
|
|
std::uint64_t subtype{};
|
|
get_number(input_format_t::cbor, subtype);
|
|
b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
|
|
break;
|
|
}
|
|
default:
|
|
return parse_cbor_internal(true, tag_handler);
|
|
}
|
|
get();
|
|
return get_cbor_binary(b) && sax->binary(b);
|
|
}
|
|
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
return false; // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
case 0xF4: // false
|
|
return sax->boolean(false);
|
|
|
|
case 0xF5: // true
|
|
return sax->boolean(true);
|
|
|
|
case 0xF6: // null
|
|
return sax->null();
|
|
|
|
case 0xF9: // Half-Precision Float (two-byte IEEE 754)
|
|
{
|
|
const auto byte1_raw = get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
|
|
{
|
|
return false;
|
|
}
|
|
const auto byte2_raw = get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const auto byte1 = static_cast<unsigned char>(byte1_raw);
|
|
const auto byte2 = static_cast<unsigned char>(byte2_raw);
|
|
|
|
// code from RFC 7049, Appendix D, Figure 3:
|
|
// As half-precision floating-point numbers were only added
|
|
// to IEEE 754 in 2008, today's programming platforms often
|
|
// still only have limited support for them. It is very
|
|
// easy to include at least decoding support for them even
|
|
// without such support. An example of a small decoder for
|
|
// half-precision floating-point numbers in the C language
|
|
// is shown in Fig. 3.
|
|
const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
|
|
const double val = [&half]
|
|
{
|
|
const int exp = (half >> 10u) & 0x1Fu;
|
|
const unsigned int mant = half & 0x3FFu;
|
|
JSON_ASSERT(0 <= exp&& exp <= 32);
|
|
JSON_ASSERT(mant <= 1024);
|
|
switch (exp)
|
|
{
|
|
case 0:
|
|
return std::ldexp(mant, -24);
|
|
case 31:
|
|
return (mant == 0)
|
|
? std::numeric_limits<double>::infinity()
|
|
: std::numeric_limits<double>::quiet_NaN();
|
|
default:
|
|
return std::ldexp(mant + 1024, exp - 25);
|
|
}
|
|
}();
|
|
return sax->number_float((half & 0x8000u) != 0
|
|
? static_cast<number_float_t>(-val)
|
|
: static_cast<number_float_t>(val), "");
|
|
}
|
|
|
|
case 0xFA: // Single-Precision Float (four-byte IEEE 754)
|
|
{
|
|
float number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
|
|
{
|
|
double number{};
|
|
return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
default: // anything else (0xFF is handled inside the other types)
|
|
{
|
|
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::cbor, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief reads a CBOR string
|
|
|
|
This function first reads starting bytes to determine the expected
|
|
string length and then copies this number of bytes into a string.
|
|
Additionally, CBOR's strings with indefinite lengths are supported.
|
|
|
|
@param[out] result created string
|
|
|
|
@return whether string creation completed
|
|
*/
|
|
bool get_cbor_string(string_t& result)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (current)
|
|
{
|
|
// UTF-8 string (0x00..0x17 bytes follow)
|
|
case 0x60:
|
|
case 0x61:
|
|
case 0x62:
|
|
case 0x63:
|
|
case 0x64:
|
|
case 0x65:
|
|
case 0x66:
|
|
case 0x67:
|
|
case 0x68:
|
|
case 0x69:
|
|
case 0x6A:
|
|
case 0x6B:
|
|
case 0x6C:
|
|
case 0x6D:
|
|
case 0x6E:
|
|
case 0x6F:
|
|
case 0x70:
|
|
case 0x71:
|
|
case 0x72:
|
|
case 0x73:
|
|
case 0x74:
|
|
case 0x75:
|
|
case 0x76:
|
|
case 0x77:
|
|
{
|
|
return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
|
|
}
|
|
|
|
case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
|
|
{
|
|
std::uint64_t len{};
|
|
return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x7F: // UTF-8 string (indefinite length)
|
|
{
|
|
while (get() != 0xFF)
|
|
{
|
|
string_t chunk;
|
|
if (!get_cbor_string(chunk))
|
|
{
|
|
return false;
|
|
}
|
|
result.append(chunk);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
default:
|
|
{
|
|
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::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief reads a CBOR byte array
|
|
|
|
This function first reads starting bytes to determine the expected
|
|
byte array length and then copies this number of bytes into the byte array.
|
|
Additionally, CBOR's byte arrays with indefinite lengths are supported.
|
|
|
|
@param[out] result created byte array
|
|
|
|
@return whether byte array creation completed
|
|
*/
|
|
bool get_cbor_binary(binary_t& result)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (current)
|
|
{
|
|
// Binary data (0x00..0x17 bytes follow)
|
|
case 0x40:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4A:
|
|
case 0x4B:
|
|
case 0x4C:
|
|
case 0x4D:
|
|
case 0x4E:
|
|
case 0x4F:
|
|
case 0x50:
|
|
case 0x51:
|
|
case 0x52:
|
|
case 0x53:
|
|
case 0x54:
|
|
case 0x55:
|
|
case 0x56:
|
|
case 0x57:
|
|
{
|
|
return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
|
|
}
|
|
|
|
case 0x58: // Binary data (one-byte uint8_t for n follows)
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::cbor, len) &&
|
|
get_binary(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x59: // Binary data (two-byte uint16_t for n follow)
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::cbor, len) &&
|
|
get_binary(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x5A: // Binary data (four-byte uint32_t for n follow)
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::cbor, len) &&
|
|
get_binary(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x5B: // Binary data (eight-byte uint64_t for n follow)
|
|
{
|
|
std::uint64_t len{};
|
|
return get_number(input_format_t::cbor, len) &&
|
|
get_binary(input_format_t::cbor, len, result);
|
|
}
|
|
|
|
case 0x5F: // Binary data (indefinite length)
|
|
{
|
|
while (get() != 0xFF)
|
|
{
|
|
binary_t chunk;
|
|
if (!get_cbor_binary(chunk))
|
|
{
|
|
return false;
|
|
}
|
|
result.insert(result.end(), chunk.begin(), chunk.end());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
default:
|
|
{
|
|
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::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[in] len the length of the array or static_cast<std::size_t>(-1) for an
|
|
array of indefinite size
|
|
@param[in] tag_handler how CBOR tags should be treated
|
|
@return whether array creation completed
|
|
*/
|
|
bool get_cbor_array(const std::size_t len,
|
|
const cbor_tag_handler_t tag_handler)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (len != static_cast<std::size_t>(-1))
|
|
{
|
|
for (std::size_t i = 0; i < len; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (get() != 0xFF)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return sax->end_array();
|
|
}
|
|
|
|
/*!
|
|
@param[in] len the length of the object or static_cast<std::size_t>(-1) for an
|
|
object of indefinite size
|
|
@param[in] tag_handler how CBOR tags should be treated
|
|
@return whether object creation completed
|
|
*/
|
|
bool get_cbor_object(const std::size_t len,
|
|
const cbor_tag_handler_t tag_handler)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (len != 0)
|
|
{
|
|
string_t key;
|
|
if (len != static_cast<std::size_t>(-1))
|
|
{
|
|
for (std::size_t i = 0; i < len; ++i)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
|
|
{
|
|
return false;
|
|
}
|
|
key.clear();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (get() != 0xFF)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
|
|
{
|
|
return false;
|
|
}
|
|
key.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
return sax->end_object();
|
|
}
|
|
|
|
/////////////
|
|
// MsgPack //
|
|
/////////////
|
|
|
|
/*!
|
|
@return whether a valid MessagePack value was passed to the SAX parser
|
|
*/
|
|
bool parse_msgpack_internal()
|
|
{
|
|
switch (get())
|
|
{
|
|
// EOF
|
|
case std::char_traits<char_type>::eof():
|
|
return unexpect_eof(input_format_t::msgpack, "value");
|
|
|
|
// positive fixint
|
|
case 0x00:
|
|
case 0x01:
|
|
case 0x02:
|
|
case 0x03:
|
|
case 0x04:
|
|
case 0x05:
|
|
case 0x06:
|
|
case 0x07:
|
|
case 0x08:
|
|
case 0x09:
|
|
case 0x0A:
|
|
case 0x0B:
|
|
case 0x0C:
|
|
case 0x0D:
|
|
case 0x0E:
|
|
case 0x0F:
|
|
case 0x10:
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
case 0x16:
|
|
case 0x17:
|
|
case 0x18:
|
|
case 0x19:
|
|
case 0x1A:
|
|
case 0x1B:
|
|
case 0x1C:
|
|
case 0x1D:
|
|
case 0x1E:
|
|
case 0x1F:
|
|
case 0x20:
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2A:
|
|
case 0x2B:
|
|
case 0x2C:
|
|
case 0x2D:
|
|
case 0x2E:
|
|
case 0x2F:
|
|
case 0x30:
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
case 0x36:
|
|
case 0x37:
|
|
case 0x38:
|
|
case 0x39:
|
|
case 0x3A:
|
|
case 0x3B:
|
|
case 0x3C:
|
|
case 0x3D:
|
|
case 0x3E:
|
|
case 0x3F:
|
|
case 0x40:
|
|
case 0x41:
|
|
case 0x42:
|
|
case 0x43:
|
|
case 0x44:
|
|
case 0x45:
|
|
case 0x46:
|
|
case 0x47:
|
|
case 0x48:
|
|
case 0x49:
|
|
case 0x4A:
|
|
case 0x4B:
|
|
case 0x4C:
|
|
case 0x4D:
|
|
case 0x4E:
|
|
case 0x4F:
|
|
case 0x50:
|
|
case 0x51:
|
|
case 0x52:
|
|
case 0x53:
|
|
case 0x54:
|
|
case 0x55:
|
|
case 0x56:
|
|
case 0x57:
|
|
case 0x58:
|
|
case 0x59:
|
|
case 0x5A:
|
|
case 0x5B:
|
|
case 0x5C:
|
|
case 0x5D:
|
|
case 0x5E:
|
|
case 0x5F:
|
|
case 0x60:
|
|
case 0x61:
|
|
case 0x62:
|
|
case 0x63:
|
|
case 0x64:
|
|
case 0x65:
|
|
case 0x66:
|
|
case 0x67:
|
|
case 0x68:
|
|
case 0x69:
|
|
case 0x6A:
|
|
case 0x6B:
|
|
case 0x6C:
|
|
case 0x6D:
|
|
case 0x6E:
|
|
case 0x6F:
|
|
case 0x70:
|
|
case 0x71:
|
|
case 0x72:
|
|
case 0x73:
|
|
case 0x74:
|
|
case 0x75:
|
|
case 0x76:
|
|
case 0x77:
|
|
case 0x78:
|
|
case 0x79:
|
|
case 0x7A:
|
|
case 0x7B:
|
|
case 0x7C:
|
|
case 0x7D:
|
|
case 0x7E:
|
|
case 0x7F:
|
|
return sax->number_unsigned(static_cast<number_unsigned_t>(current));
|
|
|
|
// fixmap
|
|
case 0x80:
|
|
case 0x81:
|
|
case 0x82:
|
|
case 0x83:
|
|
case 0x84:
|
|
case 0x85:
|
|
case 0x86:
|
|
case 0x87:
|
|
case 0x88:
|
|
case 0x89:
|
|
case 0x8A:
|
|
case 0x8B:
|
|
case 0x8C:
|
|
case 0x8D:
|
|
case 0x8E:
|
|
case 0x8F:
|
|
return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
|
|
|
|
// fixarray
|
|
case 0x90:
|
|
case 0x91:
|
|
case 0x92:
|
|
case 0x93:
|
|
case 0x94:
|
|
case 0x95:
|
|
case 0x96:
|
|
case 0x97:
|
|
case 0x98:
|
|
case 0x99:
|
|
case 0x9A:
|
|
case 0x9B:
|
|
case 0x9C:
|
|
case 0x9D:
|
|
case 0x9E:
|
|
case 0x9F:
|
|
return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
|
|
|
|
// fixstr
|
|
case 0xA0:
|
|
case 0xA1:
|
|
case 0xA2:
|
|
case 0xA3:
|
|
case 0xA4:
|
|
case 0xA5:
|
|
case 0xA6:
|
|
case 0xA7:
|
|
case 0xA8:
|
|
case 0xA9:
|
|
case 0xAA:
|
|
case 0xAB:
|
|
case 0xAC:
|
|
case 0xAD:
|
|
case 0xAE:
|
|
case 0xAF:
|
|
case 0xB0:
|
|
case 0xB1:
|
|
case 0xB2:
|
|
case 0xB3:
|
|
case 0xB4:
|
|
case 0xB5:
|
|
case 0xB6:
|
|
case 0xB7:
|
|
case 0xB8:
|
|
case 0xB9:
|
|
case 0xBA:
|
|
case 0xBB:
|
|
case 0xBC:
|
|
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) && sax->string(s);
|
|
}
|
|
|
|
case 0xC0: // nil
|
|
return sax->null();
|
|
|
|
case 0xC2: // false
|
|
return sax->boolean(false);
|
|
|
|
case 0xC3: // true
|
|
return sax->boolean(true);
|
|
|
|
case 0xC4: // bin 8
|
|
case 0xC5: // bin 16
|
|
case 0xC6: // bin 32
|
|
case 0xC7: // ext 8
|
|
case 0xC8: // ext 16
|
|
case 0xC9: // ext 32
|
|
case 0xD4: // fixext 1
|
|
case 0xD5: // fixext 2
|
|
case 0xD6: // fixext 4
|
|
case 0xD7: // fixext 8
|
|
case 0xD8: // fixext 16
|
|
{
|
|
binary_t b;
|
|
return get_msgpack_binary(b) && sax->binary(b);
|
|
}
|
|
|
|
case 0xCA: // float 32
|
|
{
|
|
float number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
case 0xCB: // float 64
|
|
{
|
|
double number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
case 0xCC: // uint 8
|
|
{
|
|
std::uint8_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0xCD: // uint 16
|
|
{
|
|
std::uint16_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0xCE: // uint 32
|
|
{
|
|
std::uint32_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0xCF: // uint 64
|
|
{
|
|
std::uint64_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 0xD0: // int 8
|
|
{
|
|
std::int8_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 0xD1: // int 16
|
|
{
|
|
std::int16_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 0xD2: // int 32
|
|
{
|
|
std::int32_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 0xD3: // int 64
|
|
{
|
|
std::int64_t number{};
|
|
return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 0xDC: // array 16
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
|
|
}
|
|
|
|
case 0xDD: // array 32
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
|
|
}
|
|
|
|
case 0xDE: // map 16
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
|
|
}
|
|
|
|
case 0xDF: // map 32
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
|
|
}
|
|
|
|
// negative fixint
|
|
case 0xE0:
|
|
case 0xE1:
|
|
case 0xE2:
|
|
case 0xE3:
|
|
case 0xE4:
|
|
case 0xE5:
|
|
case 0xE6:
|
|
case 0xE7:
|
|
case 0xE8:
|
|
case 0xE9:
|
|
case 0xEA:
|
|
case 0xEB:
|
|
case 0xEC:
|
|
case 0xED:
|
|
case 0xEE:
|
|
case 0xEF:
|
|
case 0xF0:
|
|
case 0xF1:
|
|
case 0xF2:
|
|
case 0xF3:
|
|
case 0xF4:
|
|
case 0xF5:
|
|
case 0xF6:
|
|
case 0xF7:
|
|
case 0xF8:
|
|
case 0xF9:
|
|
case 0xFA:
|
|
case 0xFB:
|
|
case 0xFC:
|
|
case 0xFD:
|
|
case 0xFE:
|
|
case 0xFF:
|
|
return sax->number_integer(static_cast<std::int8_t>(current));
|
|
|
|
default: // anything else
|
|
{
|
|
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::msgpack, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief reads a MessagePack string
|
|
|
|
This function first reads starting bytes to determine the expected
|
|
string length and then copies this number of bytes into a string.
|
|
|
|
@param[out] result created string
|
|
|
|
@return whether string creation completed
|
|
*/
|
|
bool get_msgpack_string(string_t& result)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (current)
|
|
{
|
|
// fixstr
|
|
case 0xA0:
|
|
case 0xA1:
|
|
case 0xA2:
|
|
case 0xA3:
|
|
case 0xA4:
|
|
case 0xA5:
|
|
case 0xA6:
|
|
case 0xA7:
|
|
case 0xA8:
|
|
case 0xA9:
|
|
case 0xAA:
|
|
case 0xAB:
|
|
case 0xAC:
|
|
case 0xAD:
|
|
case 0xAE:
|
|
case 0xAF:
|
|
case 0xB0:
|
|
case 0xB1:
|
|
case 0xB2:
|
|
case 0xB3:
|
|
case 0xB4:
|
|
case 0xB5:
|
|
case 0xB6:
|
|
case 0xB7:
|
|
case 0xB8:
|
|
case 0xB9:
|
|
case 0xBA:
|
|
case 0xBB:
|
|
case 0xBC:
|
|
case 0xBD:
|
|
case 0xBE:
|
|
case 0xBF:
|
|
{
|
|
return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
|
|
}
|
|
|
|
case 0xD9: // str 8
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
|
|
}
|
|
|
|
case 0xDA: // str 16
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
|
|
}
|
|
|
|
case 0xDB: // str 32
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
|
|
}
|
|
|
|
default:
|
|
{
|
|
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::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief reads a MessagePack byte array
|
|
|
|
This function first reads starting bytes to determine the expected
|
|
byte array length and then copies this number of bytes into a byte array.
|
|
|
|
@param[out] result created byte array
|
|
|
|
@return whether byte array creation completed
|
|
*/
|
|
bool get_msgpack_binary(binary_t& result)
|
|
{
|
|
// helper function to set the subtype
|
|
auto assign_and_return_true = [&result](std::int8_t subtype)
|
|
{
|
|
result.set_subtype(static_cast<std::uint8_t>(subtype));
|
|
return true;
|
|
};
|
|
|
|
switch (current)
|
|
{
|
|
case 0xC4: // bin 8
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::msgpack, len) &&
|
|
get_binary(input_format_t::msgpack, len, result);
|
|
}
|
|
|
|
case 0xC5: // bin 16
|
|
{
|
|
std::uint16_t len{};
|
|
return get_number(input_format_t::msgpack, len) &&
|
|
get_binary(input_format_t::msgpack, len, result);
|
|
}
|
|
|
|
case 0xC6: // bin 32
|
|
{
|
|
std::uint32_t len{};
|
|
return get_number(input_format_t::msgpack, len) &&
|
|
get_binary(input_format_t::msgpack, len, result);
|
|
}
|
|
|
|
case 0xC7: // ext 8
|
|
{
|
|
std::uint8_t len{};
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, len) &&
|
|
get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, len, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xC8: // ext 16
|
|
{
|
|
std::uint16_t len{};
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, len) &&
|
|
get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, len, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xC9: // ext 32
|
|
{
|
|
std::uint32_t len{};
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, len) &&
|
|
get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, len, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xD4: // fixext 1
|
|
{
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, 1, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xD5: // fixext 2
|
|
{
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, 2, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xD6: // fixext 4
|
|
{
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, 4, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xD7: // fixext 8
|
|
{
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, 8, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
case 0xD8: // fixext 16
|
|
{
|
|
std::int8_t subtype{};
|
|
return get_number(input_format_t::msgpack, subtype) &&
|
|
get_binary(input_format_t::msgpack, 16, result) &&
|
|
assign_and_return_true(subtype);
|
|
}
|
|
|
|
default: // LCOV_EXCL_LINE
|
|
return false; // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[in] len the length of the array
|
|
@return whether array creation completed
|
|
*/
|
|
bool get_msgpack_array(const std::size_t len)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (std::size_t i = 0; i < len; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return sax->end_array();
|
|
}
|
|
|
|
/*!
|
|
@param[in] len the length of the object
|
|
@return whether object creation completed
|
|
*/
|
|
bool get_msgpack_object(const std::size_t len)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string_t key;
|
|
for (std::size_t i = 0; i < len; ++i)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
|
|
{
|
|
return false;
|
|
}
|
|
key.clear();
|
|
}
|
|
|
|
return sax->end_object();
|
|
}
|
|
|
|
////////////
|
|
// UBJSON //
|
|
////////////
|
|
|
|
/*!
|
|
@param[in] get_char whether a new character should be retrieved from the
|
|
input (true, default) or whether the last read
|
|
character should be considered instead
|
|
|
|
@return whether a valid UBJSON value was passed to the SAX parser
|
|
*/
|
|
bool parse_ubjson_internal(const bool get_char = true)
|
|
{
|
|
return get_ubjson_value(get_char ? get_ignore_noop() : current);
|
|
}
|
|
|
|
/*!
|
|
@brief reads a UBJSON string
|
|
|
|
This function is either called after reading the 'S' byte explicitly
|
|
indicating a string, or in case of an object key where the 'S' byte can be
|
|
left out.
|
|
|
|
@param[out] result created string
|
|
@param[in] get_char whether a new character should be retrieved from the
|
|
input (true, default) or whether the last read
|
|
character should be considered instead
|
|
|
|
@return whether string creation completed
|
|
*/
|
|
bool get_ubjson_string(string_t& result, const bool get_char = true)
|
|
{
|
|
if (get_char)
|
|
{
|
|
get(); // TODO(niels): may we ignore N here?
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (current)
|
|
{
|
|
case 'U':
|
|
{
|
|
std::uint8_t len{};
|
|
return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
|
|
}
|
|
|
|
case 'i':
|
|
{
|
|
std::int8_t len{};
|
|
return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
|
|
}
|
|
|
|
case 'I':
|
|
{
|
|
std::int16_t len{};
|
|
return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
|
|
}
|
|
|
|
case 'l':
|
|
{
|
|
std::int32_t len{};
|
|
return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
|
|
}
|
|
|
|
case 'L':
|
|
{
|
|
std::int64_t len{};
|
|
return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
|
|
}
|
|
|
|
default:
|
|
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, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string"), BasicJsonType()));
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[out] result determined size
|
|
@return whether size determination completed
|
|
*/
|
|
bool get_ubjson_size_value(std::size_t& result)
|
|
{
|
|
switch (get_ignore_noop())
|
|
{
|
|
case 'U':
|
|
{
|
|
std::uint8_t number{};
|
|
if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
|
|
{
|
|
return false;
|
|
}
|
|
result = static_cast<std::size_t>(number);
|
|
return true;
|
|
}
|
|
|
|
case 'i':
|
|
{
|
|
std::int8_t number{};
|
|
if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
|
|
{
|
|
return false;
|
|
}
|
|
result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
|
|
return true;
|
|
}
|
|
|
|
case 'I':
|
|
{
|
|
std::int16_t number{};
|
|
if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
|
|
{
|
|
return false;
|
|
}
|
|
result = static_cast<std::size_t>(number);
|
|
return true;
|
|
}
|
|
|
|
case 'l':
|
|
{
|
|
std::int32_t number{};
|
|
if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
|
|
{
|
|
return false;
|
|
}
|
|
result = static_cast<std::size_t>(number);
|
|
return true;
|
|
}
|
|
|
|
case 'L':
|
|
{
|
|
std::int64_t number{};
|
|
if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
|
|
{
|
|
return false;
|
|
}
|
|
result = static_cast<std::size_t>(number);
|
|
return true;
|
|
}
|
|
|
|
default:
|
|
{
|
|
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, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief determine the type and size for a container
|
|
|
|
In the optimized UBJSON format, a type and a size can be provided to allow
|
|
for a more compact representation.
|
|
|
|
@param[out] result pair of the size and the type
|
|
|
|
@return whether pair creation completed
|
|
*/
|
|
bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
|
|
{
|
|
result.first = string_t::npos; // size
|
|
result.second = 0; // type
|
|
|
|
get_ignore_noop();
|
|
|
|
if (current == '$')
|
|
{
|
|
result.second = get(); // must not ignore 'N', because 'N' maybe the type
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
get_ignore_noop();
|
|
if (JSON_HEDLEY_UNLIKELY(current != '#'))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
|
|
{
|
|
return false;
|
|
}
|
|
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::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size"), BasicJsonType()));
|
|
}
|
|
|
|
return get_ubjson_size_value(result.first);
|
|
}
|
|
|
|
if (current == '#')
|
|
{
|
|
return get_ubjson_size_value(result.first);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
@param prefix the previously read or set type prefix
|
|
@return whether value creation completed
|
|
*/
|
|
bool get_ubjson_value(const char_int_type prefix)
|
|
{
|
|
switch (prefix)
|
|
{
|
|
case std::char_traits<char_type>::eof(): // EOF
|
|
return unexpect_eof(input_format_t::ubjson, "value");
|
|
|
|
case 'T': // true
|
|
return sax->boolean(true);
|
|
case 'F': // false
|
|
return sax->boolean(false);
|
|
|
|
case 'Z': // null
|
|
return sax->null();
|
|
|
|
case 'U':
|
|
{
|
|
std::uint8_t number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
|
|
}
|
|
|
|
case 'i':
|
|
{
|
|
std::int8_t number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 'I':
|
|
{
|
|
std::int16_t number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 'l':
|
|
{
|
|
std::int32_t number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 'L':
|
|
{
|
|
std::int64_t number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
|
|
}
|
|
|
|
case 'd':
|
|
{
|
|
float number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
case 'D':
|
|
{
|
|
double number{};
|
|
return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
|
|
}
|
|
|
|
case 'H':
|
|
{
|
|
return get_ubjson_high_precision_number();
|
|
}
|
|
|
|
case 'C': // char
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
|
|
{
|
|
return false;
|
|
}
|
|
if (JSON_HEDLEY_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"), BasicJsonType()));
|
|
}
|
|
string_t s(1, static_cast<typename string_t::value_type>(current));
|
|
return sax->string(s);
|
|
}
|
|
|
|
case 'S': // string
|
|
{
|
|
string_t s;
|
|
return get_ubjson_string(s) && sax->string(s);
|
|
}
|
|
|
|
case '[': // array
|
|
return get_ubjson_array();
|
|
|
|
case '{': // object
|
|
return get_ubjson_object();
|
|
|
|
default: // anything else
|
|
{
|
|
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::ubjson, "invalid byte: 0x" + last_token, "value"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@return whether array creation completed
|
|
*/
|
|
bool get_ubjson_array()
|
|
{
|
|
std::pair<std::size_t, char_int_type> size_and_type;
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (size_and_type.first != string_t::npos)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (size_and_type.second != 0)
|
|
{
|
|
if (size_and_type.second != 'N')
|
|
{
|
|
for (std::size_t i = 0; i < size_and_type.first; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (std::size_t i = 0; i < size_and_type.first; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
while (current != ']')
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
|
|
{
|
|
return false;
|
|
}
|
|
get_ignore_noop();
|
|
}
|
|
}
|
|
|
|
return sax->end_array();
|
|
}
|
|
|
|
/*!
|
|
@return whether object creation completed
|
|
*/
|
|
bool get_ubjson_object()
|
|
{
|
|
std::pair<std::size_t, char_int_type> size_and_type;
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string_t key;
|
|
if (size_and_type.first != string_t::npos)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (size_and_type.second != 0)
|
|
{
|
|
for (std::size_t i = 0; i < size_and_type.first; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
|
|
{
|
|
return false;
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
|
|
{
|
|
return false;
|
|
}
|
|
key.clear();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (std::size_t i = 0; i < size_and_type.first; ++i)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
|
|
{
|
|
return false;
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
|
|
{
|
|
return false;
|
|
}
|
|
key.clear();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
while (current != '}')
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
|
|
{
|
|
return false;
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
|
|
{
|
|
return false;
|
|
}
|
|
get_ignore_noop();
|
|
key.clear();
|
|
}
|
|
}
|
|
|
|
return sax->end_object();
|
|
}
|
|
|
|
// Note, no reader for UBJSON binary types is implemented because they do
|
|
// not exist
|
|
|
|
bool get_ubjson_high_precision_number()
|
|
{
|
|
// get size of following number string
|
|
std::size_t size{};
|
|
auto res = get_ubjson_size_value(size);
|
|
if (JSON_HEDLEY_UNLIKELY(!res))
|
|
{
|
|
return res;
|
|
}
|
|
|
|
// get number string
|
|
std::vector<char> number_vector;
|
|
for (std::size_t i = 0; i < size; ++i)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
|
|
{
|
|
return false;
|
|
}
|
|
number_vector.push_back(static_cast<char>(current));
|
|
}
|
|
|
|
// parse number string
|
|
using ia_type = decltype(detail::input_adapter(number_vector));
|
|
auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
|
|
const auto result_number = number_lexer.scan();
|
|
const auto number_string = number_lexer.get_token_string();
|
|
const auto result_remainder = number_lexer.scan();
|
|
|
|
using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
|
|
{
|
|
return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
|
|
}
|
|
|
|
switch (result_number)
|
|
{
|
|
case token_type::value_integer:
|
|
return sax->number_integer(number_lexer.get_number_integer());
|
|
case token_type::value_unsigned:
|
|
return sax->number_unsigned(number_lexer.get_number_unsigned());
|
|
case token_type::value_float:
|
|
return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
|
|
case token_type::uninitialized:
|
|
case token_type::literal_true:
|
|
case token_type::literal_false:
|
|
case token_type::literal_null:
|
|
case token_type::value_string:
|
|
case token_type::begin_array:
|
|
case token_type::begin_object:
|
|
case token_type::end_array:
|
|
case token_type::end_object:
|
|
case token_type::name_separator:
|
|
case token_type::value_separator:
|
|
case token_type::parse_error:
|
|
case token_type::end_of_input:
|
|
case token_type::literal_or_value:
|
|
default:
|
|
return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number"), BasicJsonType()));
|
|
}
|
|
}
|
|
|
|
///////////////////////
|
|
// Utility functions //
|
|
///////////////////////
|
|
|
|
/*!
|
|
@brief get next character from the input
|
|
|
|
This function provides the interface to the used input adapter. It does
|
|
not throw in case the input reached EOF, but returns a -'ve valued
|
|
`std::char_traits<char_type>::eof()` in that case.
|
|
|
|
@return character read from the input
|
|
*/
|
|
char_int_type get()
|
|
{
|
|
++chars_read;
|
|
return current = ia.get_character();
|
|
}
|
|
|
|
/*!
|
|
@return character read from the input after ignoring all 'N' entries
|
|
*/
|
|
char_int_type get_ignore_noop()
|
|
{
|
|
do
|
|
{
|
|
get();
|
|
}
|
|
while (current == 'N');
|
|
|
|
return current;
|
|
}
|
|
|
|
/*
|
|
@brief read a number from the input
|
|
|
|
@tparam NumberType the type of the number
|
|
@param[in] format the current format (for diagnostics)
|
|
@param[out] result number of type @a NumberType
|
|
|
|
@return whether conversion completed
|
|
|
|
@note This function needs to respect the system's endianness, because
|
|
bytes in CBOR, MessagePack, and UBJSON are stored in network order
|
|
(big endian) and therefore need reordering on little endian systems.
|
|
*/
|
|
template<typename NumberType, bool InputIsLittleEndian = false>
|
|
bool get_number(const input_format_t format, NumberType& result)
|
|
{
|
|
// step 1: read input into array with system's byte order
|
|
std::array<std::uint8_t, sizeof(NumberType)> vec{};
|
|
for (std::size_t i = 0; i < sizeof(NumberType); ++i)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// reverse byte order prior to conversion if necessary
|
|
if (is_little_endian != InputIsLittleEndian)
|
|
{
|
|
vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
|
|
}
|
|
else
|
|
{
|
|
vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
// step 2: convert array into number of type T and return
|
|
std::memcpy(&result, vec.data(), sizeof(NumberType));
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
@brief create a string by reading characters from the input
|
|
|
|
@tparam NumberType the type of the number
|
|
@param[in] format the current format (for diagnostics)
|
|
@param[in] len number of characters to read
|
|
@param[out] result string created by reading @a len bytes
|
|
|
|
@return whether string creation completed
|
|
|
|
@note We can not reserve @a len bytes for the result, because @a len
|
|
may be too large. Usually, @ref unexpect_eof() detects the end of
|
|
the input before we run out of string memory.
|
|
*/
|
|
template<typename NumberType>
|
|
bool get_string(const input_format_t format,
|
|
const NumberType len,
|
|
string_t& result)
|
|
{
|
|
bool success = true;
|
|
for (NumberType i = 0; i < len; i++)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
|
|
{
|
|
success = false;
|
|
break;
|
|
}
|
|
result.push_back(static_cast<typename string_t::value_type>(current));
|
|
}
|
|
return success;
|
|
}
|
|
|
|
/*!
|
|
@brief create a byte array by reading bytes from the input
|
|
|
|
@tparam NumberType the type of the number
|
|
@param[in] format the current format (for diagnostics)
|
|
@param[in] len number of bytes to read
|
|
@param[out] result byte array created by reading @a len bytes
|
|
|
|
@return whether byte array creation completed
|
|
|
|
@note We can not reserve @a len bytes for the result, because @a len
|
|
may be too large. Usually, @ref unexpect_eof() detects the end of
|
|
the input before we run out of memory.
|
|
*/
|
|
template<typename NumberType>
|
|
bool get_binary(const input_format_t format,
|
|
const NumberType len,
|
|
binary_t& result)
|
|
{
|
|
bool success = true;
|
|
for (NumberType i = 0; i < len; i++)
|
|
{
|
|
get();
|
|
if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
|
|
{
|
|
success = false;
|
|
break;
|
|
}
|
|
result.push_back(static_cast<std::uint8_t>(current));
|
|
}
|
|
return success;
|
|
}
|
|
|
|
/*!
|
|
@param[in] format the current format (for diagnostics)
|
|
@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_type>::eof()))
|
|
{
|
|
return sax->parse_error(chars_read, "<end of file>",
|
|
parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), BasicJsonType()));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*!
|
|
@return a string representation of the last read byte
|
|
*/
|
|
std::string get_token_string() const
|
|
{
|
|
std::array<char, 3> cr{{}};
|
|
static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
return std::string{cr.data()};
|
|
}
|
|
|
|
/*!
|
|
@param[in] format the current format
|
|
@param[in] detail a detailed error message
|
|
@param[in] context further context information
|
|
@return a message string to use in the parse_error exceptions
|
|
*/
|
|
std::string exception_message(const input_format_t format,
|
|
const std::string& detail,
|
|
const std::string& context) const
|
|
{
|
|
std::string error_msg = "syntax error while parsing ";
|
|
|
|
switch (format)
|
|
{
|
|
case input_format_t::cbor:
|
|
error_msg += "CBOR";
|
|
break;
|
|
|
|
case input_format_t::msgpack:
|
|
error_msg += "MessagePack";
|
|
break;
|
|
|
|
case input_format_t::ubjson:
|
|
error_msg += "UBJSON";
|
|
break;
|
|
|
|
case input_format_t::bson:
|
|
error_msg += "BSON";
|
|
break;
|
|
|
|
case input_format_t::json: // LCOV_EXCL_LINE
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
|
|
return error_msg + " " + context + ": " + detail;
|
|
}
|
|
|
|
private:
|
|
/// input adapter
|
|
InputAdapterType ia;
|
|
|
|
/// the current character
|
|
char_int_type current = std::char_traits<char_type>::eof();
|
|
|
|
/// the number of characters read
|
|
std::size_t chars_read = 0;
|
|
|
|
/// whether we can assume little endianness
|
|
const bool is_little_endian = little_endianness();
|
|
|
|
/// the SAX parser
|
|
json_sax_t* sax = nullptr;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/input/input_adapters.hpp>
|
|
|
|
// #include <nlohmann/detail/input/lexer.hpp>
|
|
|
|
// #include <nlohmann/detail/input/parser.hpp>
|
|
|
|
|
|
#include <cmath> // isfinite
|
|
#include <cstdint> // uint8_t
|
|
#include <functional> // function
|
|
#include <string> // string
|
|
#include <utility> // move
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/input/input_adapters.hpp>
|
|
|
|
// #include <nlohmann/detail/input/json_sax.hpp>
|
|
|
|
// #include <nlohmann/detail/input/lexer.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/is_sax.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
////////////
|
|
// parser //
|
|
////////////
|
|
|
|
enum class parse_event_t : std::uint8_t
|
|
{
|
|
/// the parser read `{` and started to process a JSON object
|
|
object_start,
|
|
/// the parser read `}` and finished processing a JSON object
|
|
object_end,
|
|
/// the parser read `[` and started to process a JSON array
|
|
array_start,
|
|
/// the parser read `]` and finished processing a JSON array
|
|
array_end,
|
|
/// the parser read a key of a value in an object
|
|
key,
|
|
/// the parser finished reading a JSON value
|
|
value
|
|
};
|
|
|
|
template<typename BasicJsonType>
|
|
using parser_callback_t =
|
|
std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
|
|
|
|
/*!
|
|
@brief syntax analysis
|
|
|
|
This class implements a recursive descent parser.
|
|
*/
|
|
template<typename BasicJsonType, typename InputAdapterType>
|
|
class parser
|
|
{
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using lexer_t = lexer<BasicJsonType, InputAdapterType>;
|
|
using token_type = typename lexer_t::token_type;
|
|
|
|
public:
|
|
/// a parser reading from an input adapter
|
|
explicit parser(InputAdapterType&& adapter,
|
|
const parser_callback_t<BasicJsonType> cb = nullptr,
|
|
const bool allow_exceptions_ = true,
|
|
const bool skip_comments = false)
|
|
: callback(cb)
|
|
, m_lexer(std::move(adapter), skip_comments)
|
|
, allow_exceptions(allow_exceptions_)
|
|
{
|
|
// read first token
|
|
get_token();
|
|
}
|
|
|
|
/*!
|
|
@brief public parser interface
|
|
|
|
@param[in] strict whether to expect the last token to be EOF
|
|
@param[in,out] result parsed JSON value
|
|
|
|
@throw parse_error.101 in case of an unexpected token
|
|
@throw parse_error.102 if to_unicode fails or surrogate error
|
|
@throw parse_error.103 if to_unicode fails
|
|
*/
|
|
void parse(const bool strict, BasicJsonType& result)
|
|
{
|
|
if (callback)
|
|
{
|
|
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
|
|
sax_parse_internal(&sdp);
|
|
|
|
// in strict mode, input must be completely read
|
|
if (strict && (get_token() != token_type::end_of_input))
|
|
{
|
|
sdp.parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(),
|
|
exception_message(token_type::end_of_input, "value"), BasicJsonType()));
|
|
}
|
|
|
|
// in case of an error, return discarded value
|
|
if (sdp.is_errored())
|
|
{
|
|
result = value_t::discarded;
|
|
return;
|
|
}
|
|
|
|
// set top-level value to null if it was discarded by the callback
|
|
// function
|
|
if (result.is_discarded())
|
|
{
|
|
result = nullptr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
|
|
sax_parse_internal(&sdp);
|
|
|
|
// in strict mode, input must be completely read
|
|
if (strict && (get_token() != token_type::end_of_input))
|
|
{
|
|
sdp.parse_error(m_lexer.get_position(),
|
|
m_lexer.get_token_string(),
|
|
parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), BasicJsonType()));
|
|
}
|
|
|
|
// in case of an error, return discarded value
|
|
if (sdp.is_errored())
|
|
{
|
|
result = value_t::discarded;
|
|
return;
|
|
}
|
|
}
|
|
|
|
result.assert_invariant();
|
|
}
|
|
|
|
/*!
|
|
@brief public accept interface
|
|
|
|
@param[in] strict whether to expect the last token to be EOF
|
|
@return whether the input is a proper JSON text
|
|
*/
|
|
bool accept(const bool strict = true)
|
|
{
|
|
json_sax_acceptor<BasicJsonType> sax_acceptor;
|
|
return sax_parse(&sax_acceptor, strict);
|
|
}
|
|
|
|
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> {};
|
|
const bool result = sax_parse_internal(sax);
|
|
|
|
// strict mode: next byte must be EOF
|
|
if (result && strict && (get_token() != token_type::end_of_input))
|
|
{
|
|
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::end_of_input, "value"), BasicJsonType()));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
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
|
|
// true = array; false = object
|
|
std::vector<bool> states;
|
|
// value to avoid a goto (see comment where set to true)
|
|
bool skip_to_state_evaluation = false;
|
|
|
|
while (true)
|
|
{
|
|
if (!skip_to_state_evaluation)
|
|
{
|
|
// invariant: get_token() was called before each iteration
|
|
switch (last_token)
|
|
{
|
|
case token_type::begin_object:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// closing } -> we are done
|
|
if (get_token() == token_type::end_object)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// parse key
|
|
if (JSON_HEDLEY_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"), BasicJsonType()));
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// parse separator (:)
|
|
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
|
|
{
|
|
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::name_separator, "object separator"), BasicJsonType()));
|
|
}
|
|
|
|
// remember we are now inside an object
|
|
states.push_back(false);
|
|
|
|
// parse values
|
|
get_token();
|
|
continue;
|
|
}
|
|
|
|
case token_type::begin_array:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// closing ] -> we are done
|
|
if (get_token() == token_type::end_array)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// remember we are now inside an array
|
|
states.push_back(true);
|
|
|
|
// parse values (no need to call get_token)
|
|
continue;
|
|
}
|
|
|
|
case token_type::value_float:
|
|
{
|
|
const auto res = m_lexer.get_number_float();
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!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() + "'", BasicJsonType()));
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case token_type::literal_false:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::literal_null:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->null()))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::literal_true:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::value_integer:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::value_string:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::value_unsigned:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case token_type::parse_error:
|
|
{
|
|
// using "uninitialized" to avoid "expected" message
|
|
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::uninitialized, "value"), BasicJsonType()));
|
|
}
|
|
|
|
case token_type::uninitialized:
|
|
case token_type::end_array:
|
|
case token_type::end_object:
|
|
case token_type::name_separator:
|
|
case token_type::value_separator:
|
|
case token_type::end_of_input:
|
|
case token_type::literal_or_value:
|
|
default: // the last token was unexpected
|
|
{
|
|
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::literal_or_value, "value"), BasicJsonType()));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
skip_to_state_evaluation = false;
|
|
}
|
|
|
|
// we reached this line after we successfully parsed a value
|
|
if (states.empty())
|
|
{
|
|
// empty stack: we reached the end of the hierarchy: done
|
|
return true;
|
|
}
|
|
|
|
if (states.back()) // array
|
|
{
|
|
// comma -> next value
|
|
if (get_token() == token_type::value_separator)
|
|
{
|
|
// parse a new value
|
|
get_token();
|
|
continue;
|
|
}
|
|
|
|
// closing ]
|
|
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// We are done with this array. Before we can parse a
|
|
// new value, we need to evaluate the new state first.
|
|
// By setting skip_to_state_evaluation to false, we
|
|
// are effectively jumping to the beginning of this if.
|
|
JSON_ASSERT(!states.empty());
|
|
states.pop_back();
|
|
skip_to_state_evaluation = true;
|
|
continue;
|
|
}
|
|
|
|
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::end_array, "array"), BasicJsonType()));
|
|
}
|
|
|
|
// states.back() is false -> object
|
|
|
|
// comma -> next value
|
|
if (get_token() == token_type::value_separator)
|
|
{
|
|
// parse key
|
|
if (JSON_HEDLEY_UNLIKELY(get_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"), BasicJsonType()));
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// parse separator (:)
|
|
if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
|
|
{
|
|
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::name_separator, "object separator"), BasicJsonType()));
|
|
}
|
|
|
|
// parse values
|
|
get_token();
|
|
continue;
|
|
}
|
|
|
|
// closing }
|
|
if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// We are done with this object. Before we can parse a
|
|
// new value, we need to evaluate the new state first.
|
|
// By setting skip_to_state_evaluation to false, we
|
|
// are effectively jumping to the beginning of this if.
|
|
JSON_ASSERT(!states.empty());
|
|
states.pop_back();
|
|
skip_to_state_evaluation = true;
|
|
continue;
|
|
}
|
|
|
|
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::end_object, "object"), BasicJsonType()));
|
|
}
|
|
}
|
|
|
|
/// get next token from lexer
|
|
token_type get_token()
|
|
{
|
|
return last_token = m_lexer.scan();
|
|
}
|
|
|
|
std::string exception_message(const token_type expected, const std::string& context)
|
|
{
|
|
std::string error_msg = "syntax error ";
|
|
|
|
if (!context.empty())
|
|
{
|
|
error_msg += "while parsing " + context + " ";
|
|
}
|
|
|
|
error_msg += "- ";
|
|
|
|
if (last_token == token_type::parse_error)
|
|
{
|
|
error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
|
|
m_lexer.get_token_string() + "'";
|
|
}
|
|
else
|
|
{
|
|
error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
|
|
}
|
|
|
|
if (expected != token_type::uninitialized)
|
|
{
|
|
error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
|
|
}
|
|
|
|
return error_msg;
|
|
}
|
|
|
|
private:
|
|
/// callback function
|
|
const parser_callback_t<BasicJsonType> callback = nullptr;
|
|
/// the type of the last read token
|
|
token_type last_token = token_type::uninitialized;
|
|
/// the lexer
|
|
lexer_t m_lexer;
|
|
/// whether to throw exceptions in case of errors
|
|
const bool allow_exceptions = true;
|
|
};
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/iterators/internal_iterator.hpp>
|
|
|
|
|
|
// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
|
|
|
|
|
|
#include <cstddef> // ptrdiff_t
|
|
#include <limits> // numeric_limits
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
/*
|
|
@brief an iterator for primitive JSON types
|
|
|
|
This class models an iterator for primitive JSON types (boolean, number,
|
|
string). It's only purpose is to allow the iterator/const_iterator classes
|
|
to "iterate" over primitive values. Internally, the iterator is modeled by
|
|
a `difference_type` variable. Value begin_value (`0`) models the begin,
|
|
end_value (`1`) models past the end.
|
|
*/
|
|
class primitive_iterator_t
|
|
{
|
|
private:
|
|
using difference_type = std::ptrdiff_t;
|
|
static constexpr difference_type begin_value = 0;
|
|
static constexpr difference_type end_value = begin_value + 1;
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
/// iterator as signed integer type
|
|
difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
|
|
|
|
public:
|
|
constexpr difference_type get_value() const noexcept
|
|
{
|
|
return m_it;
|
|
}
|
|
|
|
/// set iterator to a defined beginning
|
|
void set_begin() noexcept
|
|
{
|
|
m_it = begin_value;
|
|
}
|
|
|
|
/// set iterator to a defined past the end
|
|
void set_end() noexcept
|
|
{
|
|
m_it = end_value;
|
|
}
|
|
|
|
/// return whether the iterator can be dereferenced
|
|
constexpr bool is_begin() const noexcept
|
|
{
|
|
return m_it == begin_value;
|
|
}
|
|
|
|
/// return whether the iterator is at end
|
|
constexpr bool is_end() const noexcept
|
|
{
|
|
return m_it == end_value;
|
|
}
|
|
|
|
friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
|
|
{
|
|
return lhs.m_it == rhs.m_it;
|
|
}
|
|
|
|
friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
|
|
{
|
|
return lhs.m_it < rhs.m_it;
|
|
}
|
|
|
|
primitive_iterator_t operator+(difference_type n) noexcept
|
|
{
|
|
auto result = *this;
|
|
result += n;
|
|
return result;
|
|
}
|
|
|
|
friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
|
|
{
|
|
return lhs.m_it - rhs.m_it;
|
|
}
|
|
|
|
primitive_iterator_t& operator++() noexcept
|
|
{
|
|
++m_it;
|
|
return *this;
|
|
}
|
|
|
|
primitive_iterator_t const operator++(int) noexcept // NOLINT(readability-const-return-type)
|
|
{
|
|
auto result = *this;
|
|
++m_it;
|
|
return result;
|
|
}
|
|
|
|
primitive_iterator_t& operator--() noexcept
|
|
{
|
|
--m_it;
|
|
return *this;
|
|
}
|
|
|
|
primitive_iterator_t const operator--(int) noexcept // NOLINT(readability-const-return-type)
|
|
{
|
|
auto result = *this;
|
|
--m_it;
|
|
return result;
|
|
}
|
|
|
|
primitive_iterator_t& operator+=(difference_type n) noexcept
|
|
{
|
|
m_it += n;
|
|
return *this;
|
|
}
|
|
|
|
primitive_iterator_t& operator-=(difference_type n) noexcept
|
|
{
|
|
m_it -= n;
|
|
return *this;
|
|
}
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
/*!
|
|
@brief an iterator value
|
|
|
|
@note This structure could easily be a union, but MSVC currently does not allow
|
|
unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
|
|
*/
|
|
template<typename BasicJsonType> struct internal_iterator
|
|
{
|
|
/// iterator for JSON objects
|
|
typename BasicJsonType::object_t::iterator object_iterator {};
|
|
/// iterator for JSON arrays
|
|
typename BasicJsonType::array_t::iterator array_iterator {};
|
|
/// generic iterator for all other types
|
|
primitive_iterator_t primitive_iterator {};
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/iterators/iter_impl.hpp>
|
|
|
|
|
|
#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
|
|
#include <type_traits> // conditional, is_const, remove_const
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/iterators/internal_iterator.hpp>
|
|
|
|
// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
// forward declare, to be able to friend it later on
|
|
template<typename IteratorType> class iteration_proxy;
|
|
template<typename IteratorType> class iteration_proxy_value;
|
|
|
|
/*!
|
|
@brief a template for a bidirectional iterator for the @ref basic_json class
|
|
This class implements a both iterators (iterator and const_iterator) for the
|
|
@ref basic_json class.
|
|
@note An iterator is called *initialized* when a pointer to a JSON value has
|
|
been set (e.g., by a constructor or a copy assignment). If the iterator is
|
|
default-constructed, it is *uninitialized* and most methods are undefined.
|
|
**The library uses assertions to detect calls on uninitialized iterators.**
|
|
@requirement The class satisfies the following concept requirements:
|
|
-
|
|
[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
|
|
The iterator that can be moved can be moved in both directions (i.e.
|
|
incremented and decremented).
|
|
@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
|
|
iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
|
|
*/
|
|
template<typename BasicJsonType>
|
|
class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
|
|
{
|
|
/// the iterator with BasicJsonType of different const-ness
|
|
using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
|
|
/// allow basic_json to access private members
|
|
friend other_iter_impl;
|
|
friend BasicJsonType;
|
|
friend iteration_proxy<iter_impl>;
|
|
friend iteration_proxy_value<iter_impl>;
|
|
|
|
using object_t = typename BasicJsonType::object_t;
|
|
using array_t = typename BasicJsonType::array_t;
|
|
// make sure BasicJsonType is basic_json or const basic_json
|
|
static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
|
|
"iter_impl only accepts (const) basic_json");
|
|
|
|
public:
|
|
|
|
/// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
|
|
/// The C++ Standard has never required user-defined iterators to derive from std::iterator.
|
|
/// A user-defined iterator should provide publicly accessible typedefs named
|
|
/// iterator_category, value_type, difference_type, pointer, and reference.
|
|
/// Note that value_type is required to be non-const, even for constant iterators.
|
|
using iterator_category = std::bidirectional_iterator_tag;
|
|
|
|
/// the type of the values when the iterator is dereferenced
|
|
using value_type = typename BasicJsonType::value_type;
|
|
/// a type to represent differences between iterators
|
|
using difference_type = typename BasicJsonType::difference_type;
|
|
/// defines a pointer to the type iterated over (value_type)
|
|
using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
|
|
typename BasicJsonType::const_pointer,
|
|
typename BasicJsonType::pointer>::type;
|
|
/// defines a reference to the type iterated over (value_type)
|
|
using reference =
|
|
typename std::conditional<std::is_const<BasicJsonType>::value,
|
|
typename BasicJsonType::const_reference,
|
|
typename BasicJsonType::reference>::type;
|
|
|
|
iter_impl() = default;
|
|
~iter_impl() = default;
|
|
iter_impl(iter_impl&&) noexcept = default;
|
|
iter_impl& operator=(iter_impl&&) noexcept = default;
|
|
|
|
/*!
|
|
@brief constructor for a given JSON instance
|
|
@param[in] object pointer to a JSON object for this iterator
|
|
@pre object != nullptr
|
|
@post The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
explicit iter_impl(pointer object) noexcept : m_object(object)
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
m_it.object_iterator = typename object_t::iterator();
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
m_it.array_iterator = typename array_t::iterator();
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
m_it.primitive_iterator = primitive_iterator_t();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@note The conventional copy constructor and copy assignment are implicitly
|
|
defined. Combined with the following converting constructor and
|
|
assignment, they support: (1) copy from iterator to iterator, (2)
|
|
copy from const iterator to const iterator, and (3) conversion from
|
|
iterator to const iterator. However conversion from const iterator
|
|
to iterator is not defined.
|
|
*/
|
|
|
|
/*!
|
|
@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
|
|
{
|
|
if (&other != this)
|
|
{
|
|
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)
|
|
{}
|
|
|
|
/*!
|
|
@brief converting assignment
|
|
@param[in] other non-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<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
|
|
{
|
|
m_object = other.m_object;
|
|
m_it = other.m_it;
|
|
return *this;
|
|
}
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
/*!
|
|
@brief set the iterator to the first value
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
void set_begin() noexcept
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
m_it.object_iterator = m_object->m_value.object->begin();
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
m_it.array_iterator = m_object->m_value.array->begin();
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
{
|
|
// set to end so begin()==end() is true: null is empty
|
|
m_it.primitive_iterator.set_end();
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
m_it.primitive_iterator.set_begin();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief set the iterator past the last value
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
void set_end() noexcept
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
m_it.object_iterator = m_object->m_value.object->end();
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
m_it.array_iterator = m_object->m_value.array->end();
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
m_it.primitive_iterator.set_end();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public:
|
|
/*!
|
|
@brief return a reference to the value pointed to by the iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
reference operator*() const
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
|
|
return m_it.object_iterator->second;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
|
|
return *m_it.array_iterator;
|
|
}
|
|
|
|
case value_t::null:
|
|
JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
|
|
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
|
|
{
|
|
return *m_object;
|
|
}
|
|
|
|
JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief dereference the iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
pointer operator->() const
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
|
|
return &(m_it.object_iterator->second);
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
|
|
return &*m_it.array_iterator;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
|
|
{
|
|
return m_object;
|
|
}
|
|
|
|
JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief post-increment (it++)
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl const operator++(int) // NOLINT(readability-const-return-type)
|
|
{
|
|
auto result = *this;
|
|
++(*this);
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
@brief pre-increment (++it)
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl& operator++()
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
std::advance(m_it.object_iterator, 1);
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
std::advance(m_it.array_iterator, 1);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
++m_it.primitive_iterator;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
@brief post-decrement (it--)
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl const operator--(int) // NOLINT(readability-const-return-type)
|
|
{
|
|
auto result = *this;
|
|
--(*this);
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
@brief pre-decrement (--it)
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl& operator--()
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
std::advance(m_it.object_iterator, -1);
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
std::advance(m_it.array_iterator, -1);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
--m_it.primitive_iterator;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
@brief comparison: equal
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
|
|
bool operator==(const IterImpl& other) const
|
|
{
|
|
// if objects are not the same, the comparison is undefined
|
|
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
|
|
}
|
|
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
return (m_it.object_iterator == other.m_it.object_iterator);
|
|
|
|
case value_t::array:
|
|
return (m_it.array_iterator == other.m_it.array_iterator);
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
return (m_it.primitive_iterator == other.m_it.primitive_iterator);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief comparison: not equal
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
|
|
bool operator!=(const IterImpl& other) const
|
|
{
|
|
return !operator==(other);
|
|
}
|
|
|
|
/*!
|
|
@brief comparison: smaller
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
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))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", *m_object));
|
|
}
|
|
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", *m_object));
|
|
|
|
case value_t::array:
|
|
return (m_it.array_iterator < other.m_it.array_iterator);
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
return (m_it.primitive_iterator < other.m_it.primitive_iterator);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief comparison: less than or equal
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
bool operator<=(const iter_impl& other) const
|
|
{
|
|
return !other.operator < (*this);
|
|
}
|
|
|
|
/*!
|
|
@brief comparison: greater than
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
bool operator>(const iter_impl& other) const
|
|
{
|
|
return !operator<=(other);
|
|
}
|
|
|
|
/*!
|
|
@brief comparison: greater than or equal
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
bool operator>=(const iter_impl& other) const
|
|
{
|
|
return !operator<(other);
|
|
}
|
|
|
|
/*!
|
|
@brief add to iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl& operator+=(difference_type i)
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
|
|
|
|
case value_t::array:
|
|
{
|
|
std::advance(m_it.array_iterator, i);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
m_it.primitive_iterator += i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
@brief subtract from iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl& operator-=(difference_type i)
|
|
{
|
|
return operator+=(-i);
|
|
}
|
|
|
|
/*!
|
|
@brief add to iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl operator+(difference_type i) const
|
|
{
|
|
auto result = *this;
|
|
result += i;
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
@brief addition of distance and iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
friend iter_impl operator+(difference_type i, const iter_impl& it)
|
|
{
|
|
auto result = it;
|
|
result += i;
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
@brief subtract from iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
iter_impl operator-(difference_type i) const
|
|
{
|
|
auto result = *this;
|
|
result -= i;
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
@brief return difference
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
difference_type operator-(const iter_impl& other) const
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", *m_object));
|
|
|
|
case value_t::array:
|
|
return m_it.array_iterator - other.m_it.array_iterator;
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
return m_it.primitive_iterator - other.m_it.primitive_iterator;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief access to successor
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
reference operator[](difference_type n) const
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
switch (m_object->m_type)
|
|
{
|
|
case value_t::object:
|
|
JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", *m_object));
|
|
|
|
case value_t::array:
|
|
return *std::next(m_it.array_iterator, n);
|
|
|
|
case value_t::null:
|
|
JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
|
|
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
|
|
{
|
|
return *m_object;
|
|
}
|
|
|
|
JSON_THROW(invalid_iterator::create(214, "cannot get value", *m_object));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief return the key of an object iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
const typename object_t::key_type& key() const
|
|
{
|
|
JSON_ASSERT(m_object != nullptr);
|
|
|
|
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
|
|
{
|
|
return m_it.object_iterator->first;
|
|
}
|
|
|
|
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", *m_object));
|
|
}
|
|
|
|
/*!
|
|
@brief return the value of an iterator
|
|
@pre The iterator is initialized; i.e. `m_object != nullptr`.
|
|
*/
|
|
reference value() const
|
|
{
|
|
return operator*();
|
|
}
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
/// associated JSON instance
|
|
pointer m_object = nullptr;
|
|
/// the actual iterator of the associated instance
|
|
internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
|
|
|
|
// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
|
|
|
|
|
|
#include <cstddef> // ptrdiff_t
|
|
#include <iterator> // reverse_iterator
|
|
#include <utility> // declval
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
//////////////////////
|
|
// reverse_iterator //
|
|
//////////////////////
|
|
|
|
/*!
|
|
@brief a template for a reverse iterator class
|
|
|
|
@tparam Base the base iterator type to reverse. Valid types are @ref
|
|
iterator (to create @ref reverse_iterator) and @ref const_iterator (to
|
|
create @ref const_reverse_iterator).
|
|
|
|
@requirement The class satisfies the following concept requirements:
|
|
-
|
|
[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
|
|
The iterator that can be moved can be moved in both directions (i.e.
|
|
incremented and decremented).
|
|
- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
|
|
It is possible to write to the pointed-to element (only if @a Base is
|
|
@ref iterator).
|
|
|
|
@since version 1.0.0
|
|
*/
|
|
template<typename Base>
|
|
class json_reverse_iterator : public std::reverse_iterator<Base>
|
|
{
|
|
public:
|
|
using difference_type = std::ptrdiff_t;
|
|
/// shortcut to the reverse iterator adapter
|
|
using base_iterator = std::reverse_iterator<Base>;
|
|
/// the reference type for the pointed-to element
|
|
using reference = typename Base::reference;
|
|
|
|
/// create reverse iterator from iterator
|
|
explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
|
|
: base_iterator(it) {}
|
|
|
|
/// create reverse iterator from base class
|
|
explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
|
|
|
|
/// post-increment (it++)
|
|
json_reverse_iterator const operator++(int) // NOLINT(readability-const-return-type)
|
|
{
|
|
return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
|
|
}
|
|
|
|
/// pre-increment (++it)
|
|
json_reverse_iterator& operator++()
|
|
{
|
|
return static_cast<json_reverse_iterator&>(base_iterator::operator++());
|
|
}
|
|
|
|
/// post-decrement (it--)
|
|
json_reverse_iterator const operator--(int) // NOLINT(readability-const-return-type)
|
|
{
|
|
return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
|
|
}
|
|
|
|
/// pre-decrement (--it)
|
|
json_reverse_iterator& operator--()
|
|
{
|
|
return static_cast<json_reverse_iterator&>(base_iterator::operator--());
|
|
}
|
|
|
|
/// add to iterator
|
|
json_reverse_iterator& operator+=(difference_type i)
|
|
{
|
|
return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
|
|
}
|
|
|
|
/// add to iterator
|
|
json_reverse_iterator operator+(difference_type i) const
|
|
{
|
|
return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
|
|
}
|
|
|
|
/// subtract from iterator
|
|
json_reverse_iterator operator-(difference_type i) const
|
|
{
|
|
return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
|
|
}
|
|
|
|
/// return difference
|
|
difference_type operator-(const json_reverse_iterator& other) const
|
|
{
|
|
return base_iterator(*this) - base_iterator(other);
|
|
}
|
|
|
|
/// access to successor
|
|
reference operator[](difference_type n) const
|
|
{
|
|
return *(this->operator+(n));
|
|
}
|
|
|
|
/// return the key of an object iterator
|
|
auto key() const -> decltype(std::declval<Base>().key())
|
|
{
|
|
auto it = --this->base();
|
|
return it.key();
|
|
}
|
|
|
|
/// return the value of an iterator
|
|
reference value() const
|
|
{
|
|
auto it = --this->base();
|
|
return it.operator * ();
|
|
}
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
|
|
|
|
// #include <nlohmann/detail/json_pointer.hpp>
|
|
|
|
|
|
#include <algorithm> // all_of
|
|
#include <cctype> // isdigit
|
|
#include <limits> // max
|
|
#include <numeric> // accumulate
|
|
#include <string> // string
|
|
#include <utility> // move
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/string_escape.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
|
|
/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/
|
|
template<typename BasicJsonType>
|
|
class json_pointer
|
|
{
|
|
// allow basic_json to access private members
|
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
friend class basic_json;
|
|
|
|
public:
|
|
/// @brief create JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
|
|
explicit json_pointer(const std::string& s = "")
|
|
: reference_tokens(split(s))
|
|
{}
|
|
|
|
/// @brief return a string representation of the JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/to_string/
|
|
std::string to_string() const
|
|
{
|
|
return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
|
|
std::string{},
|
|
[](const std::string & a, const std::string & b)
|
|
{
|
|
return a + "/" + detail::escape(b);
|
|
});
|
|
}
|
|
|
|
/// @brief return a string representation of the JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
|
|
operator std::string() const
|
|
{
|
|
return to_string();
|
|
}
|
|
|
|
/// @brief append another JSON pointer at the end of this JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
|
|
json_pointer& operator/=(const json_pointer& ptr)
|
|
{
|
|
reference_tokens.insert(reference_tokens.end(),
|
|
ptr.reference_tokens.begin(),
|
|
ptr.reference_tokens.end());
|
|
return *this;
|
|
}
|
|
|
|
/// @brief append an unescaped reference token at the end of this JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
|
|
json_pointer& operator/=(std::string token)
|
|
{
|
|
push_back(std::move(token));
|
|
return *this;
|
|
}
|
|
|
|
/// @brief append an array index at the end of this JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
|
|
json_pointer& operator/=(std::size_t array_idx)
|
|
{
|
|
return *this /= std::to_string(array_idx);
|
|
}
|
|
|
|
/// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
|
|
friend json_pointer operator/(const json_pointer& lhs,
|
|
const json_pointer& rhs)
|
|
{
|
|
return json_pointer(lhs) /= rhs;
|
|
}
|
|
|
|
/// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
|
|
friend json_pointer operator/(const json_pointer& lhs, std::string token) // NOLINT(performance-unnecessary-value-param)
|
|
{
|
|
return json_pointer(lhs) /= std::move(token);
|
|
}
|
|
|
|
/// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
|
|
friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
|
|
{
|
|
return json_pointer(lhs) /= array_idx;
|
|
}
|
|
|
|
/// @brief returns the parent of this JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
|
|
json_pointer parent_pointer() const
|
|
{
|
|
if (empty())
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
json_pointer res = *this;
|
|
res.pop_back();
|
|
return res;
|
|
}
|
|
|
|
/// @brief remove last reference token
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
|
|
void pop_back()
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(empty()))
|
|
{
|
|
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
|
|
}
|
|
|
|
reference_tokens.pop_back();
|
|
}
|
|
|
|
/// @brief return last reference token
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/back/
|
|
const std::string& back() const
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(empty()))
|
|
{
|
|
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
|
|
}
|
|
|
|
return reference_tokens.back();
|
|
}
|
|
|
|
/// @brief append an unescaped token at the end of the reference pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/push_back/
|
|
void push_back(const std::string& token)
|
|
{
|
|
reference_tokens.push_back(token);
|
|
}
|
|
|
|
/// @brief append an unescaped token at the end of the reference pointer
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/push_back/
|
|
void push_back(std::string&& token)
|
|
{
|
|
reference_tokens.push_back(std::move(token));
|
|
}
|
|
|
|
/// @brief return whether pointer points to the root document
|
|
/// @sa https://json.nlohmann.me/api/json_pointer/empty/
|
|
bool empty() const noexcept
|
|
{
|
|
return reference_tokens.empty();
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@param[in] s reference token to be converted into an array index
|
|
|
|
@return integer representation of @a s
|
|
|
|
@throw parse_error.106 if an array index begins with '0'
|
|
@throw parse_error.109 if an array index begins not with a digit
|
|
@throw out_of_range.404 if string @a s could not be converted to an integer
|
|
@throw out_of_range.410 if an array index exceeds size_type
|
|
*/
|
|
static typename BasicJsonType::size_type array_index(const std::string& s)
|
|
{
|
|
using size_type = typename BasicJsonType::size_type;
|
|
|
|
// error condition (cf. RFC 6901, Sect. 4)
|
|
if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
|
|
{
|
|
JSON_THROW(detail::parse_error::create(106, 0, "array index '" + s + "' must not begin with '0'", BasicJsonType()));
|
|
}
|
|
|
|
// error condition (cf. RFC 6901, Sect. 4)
|
|
if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
|
|
{
|
|
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number", BasicJsonType()));
|
|
}
|
|
|
|
std::size_t processed_chars = 0;
|
|
unsigned long long res = 0; // NOLINT(runtime/int)
|
|
JSON_TRY
|
|
{
|
|
res = std::stoull(s, &processed_chars);
|
|
}
|
|
JSON_CATCH(std::out_of_range&)
|
|
{
|
|
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
|
|
}
|
|
|
|
// check if the string was completely read
|
|
if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
|
|
{
|
|
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'", BasicJsonType()));
|
|
}
|
|
|
|
// only triggered on special platforms (like 32bit), see also
|
|
// https://github.com/nlohmann/json/pull/2203
|
|
if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)())) // NOLINT(runtime/int)
|
|
{
|
|
JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type", BasicJsonType())); // LCOV_EXCL_LINE
|
|
}
|
|
|
|
return static_cast<size_type>(res);
|
|
}
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
json_pointer top() const
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(empty()))
|
|
{
|
|
JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", BasicJsonType()));
|
|
}
|
|
|
|
json_pointer result = *this;
|
|
result.reference_tokens = {reference_tokens[0]};
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@brief create and return a reference to the pointed to value
|
|
|
|
@complexity Linear in the number of reference tokens.
|
|
|
|
@throw parse_error.109 if array index is not a number
|
|
@throw type_error.313 if value cannot be unflattened
|
|
*/
|
|
BasicJsonType& get_and_create(BasicJsonType& j) const
|
|
{
|
|
auto* result = &j;
|
|
|
|
// in case no reference tokens exist, return a reference to the JSON value
|
|
// j which will be overwritten by a primitive value
|
|
for (const auto& reference_token : reference_tokens)
|
|
{
|
|
switch (result->type())
|
|
{
|
|
case detail::value_t::null:
|
|
{
|
|
if (reference_token == "0")
|
|
{
|
|
// start a new array if reference token is 0
|
|
result = &result->operator[](0);
|
|
}
|
|
else
|
|
{
|
|
// start a new object otherwise
|
|
result = &result->operator[](reference_token);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::object:
|
|
{
|
|
// create an entry in the object
|
|
result = &result->operator[](reference_token);
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::array:
|
|
{
|
|
// create an entry in the array
|
|
result = &result->operator[](array_index(reference_token));
|
|
break;
|
|
}
|
|
|
|
/*
|
|
The following code is only reached if there exists a reference
|
|
token _and_ the current value is primitive. In this case, we have
|
|
an error situation, because primitive values may only occur as
|
|
single value; that is, with an empty list of reference tokens.
|
|
*/
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
default:
|
|
JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", j));
|
|
}
|
|
}
|
|
|
|
return *result;
|
|
}
|
|
|
|
/*!
|
|
@brief return a reference to the pointed to value
|
|
|
|
@note This version does not throw if a value is not present, but tries to
|
|
create nested values instead. For instance, calling this function
|
|
with pointer `"/this/that"` on a null value is equivalent to calling
|
|
`operator[]("this").operator[]("that")` on that value, effectively
|
|
changing the null value to an object.
|
|
|
|
@param[in] ptr a JSON value
|
|
|
|
@return reference to the JSON value pointed to by the JSON pointer
|
|
|
|
@complexity Linear in the length of the JSON pointer.
|
|
|
|
@throw parse_error.106 if an array index begins with '0'
|
|
@throw parse_error.109 if an array index was not a number
|
|
@throw out_of_range.404 if the JSON pointer can not be resolved
|
|
*/
|
|
BasicJsonType& get_unchecked(BasicJsonType* ptr) const
|
|
{
|
|
for (const auto& reference_token : reference_tokens)
|
|
{
|
|
// convert null values to arrays or objects before continuing
|
|
if (ptr->is_null())
|
|
{
|
|
// check if reference token is a number
|
|
const bool nums =
|
|
std::all_of(reference_token.begin(), reference_token.end(),
|
|
[](const unsigned char x)
|
|
{
|
|
return std::isdigit(x);
|
|
});
|
|
|
|
// change value to array for numbers or "-" or to object otherwise
|
|
*ptr = (nums || reference_token == "-")
|
|
? detail::value_t::array
|
|
: detail::value_t::object;
|
|
}
|
|
|
|
switch (ptr->type())
|
|
{
|
|
case detail::value_t::object:
|
|
{
|
|
// use unchecked object access
|
|
ptr = &ptr->operator[](reference_token);
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::array:
|
|
{
|
|
if (reference_token == "-")
|
|
{
|
|
// explicitly treat "-" as index beyond the end
|
|
ptr = &ptr->operator[](ptr->m_value.array->size());
|
|
}
|
|
else
|
|
{
|
|
// convert array index to number; unchecked access
|
|
ptr = &ptr->operator[](array_index(reference_token));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::null:
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
default:
|
|
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
|
|
}
|
|
}
|
|
|
|
return *ptr;
|
|
}
|
|
|
|
/*!
|
|
@throw parse_error.106 if an array index begins with '0'
|
|
@throw parse_error.109 if an array index was not a number
|
|
@throw out_of_range.402 if the array index '-' is used
|
|
@throw out_of_range.404 if the JSON pointer can not be resolved
|
|
*/
|
|
BasicJsonType& get_checked(BasicJsonType* ptr) const
|
|
{
|
|
for (const auto& reference_token : reference_tokens)
|
|
{
|
|
switch (ptr->type())
|
|
{
|
|
case detail::value_t::object:
|
|
{
|
|
// note: at performs range check
|
|
ptr = &ptr->at(reference_token);
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::array:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
|
|
{
|
|
// "-" always fails the range check
|
|
JSON_THROW(detail::out_of_range::create(402,
|
|
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
|
|
") is out of range", *ptr));
|
|
}
|
|
|
|
// note: at performs range check
|
|
ptr = &ptr->at(array_index(reference_token));
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::null:
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
default:
|
|
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
|
|
}
|
|
}
|
|
|
|
return *ptr;
|
|
}
|
|
|
|
/*!
|
|
@brief return a const reference to the pointed to value
|
|
|
|
@param[in] ptr a JSON value
|
|
|
|
@return const reference to the JSON value pointed to by the JSON
|
|
pointer
|
|
|
|
@throw parse_error.106 if an array index begins with '0'
|
|
@throw parse_error.109 if an array index was not a number
|
|
@throw out_of_range.402 if the array index '-' is used
|
|
@throw out_of_range.404 if the JSON pointer can not be resolved
|
|
*/
|
|
const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
|
|
{
|
|
for (const auto& reference_token : reference_tokens)
|
|
{
|
|
switch (ptr->type())
|
|
{
|
|
case detail::value_t::object:
|
|
{
|
|
// use unchecked object access
|
|
ptr = &ptr->operator[](reference_token);
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::array:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
|
|
{
|
|
// "-" cannot be used for const access
|
|
JSON_THROW(detail::out_of_range::create(402, "array index '-' (" + std::to_string(ptr->m_value.array->size()) + ") is out of range", *ptr));
|
|
}
|
|
|
|
// use unchecked array access
|
|
ptr = &ptr->operator[](array_index(reference_token));
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::null:
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
default:
|
|
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
|
|
}
|
|
}
|
|
|
|
return *ptr;
|
|
}
|
|
|
|
/*!
|
|
@throw parse_error.106 if an array index begins with '0'
|
|
@throw parse_error.109 if an array index was not a number
|
|
@throw out_of_range.402 if the array index '-' is used
|
|
@throw out_of_range.404 if the JSON pointer can not be resolved
|
|
*/
|
|
const BasicJsonType& get_checked(const BasicJsonType* ptr) const
|
|
{
|
|
for (const auto& reference_token : reference_tokens)
|
|
{
|
|
switch (ptr->type())
|
|
{
|
|
case detail::value_t::object:
|
|
{
|
|
// note: at performs range check
|
|
ptr = &ptr->at(reference_token);
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::array:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
|
|
{
|
|
// "-" always fails the range check
|
|
JSON_THROW(detail::out_of_range::create(402,
|
|
"array index '-' (" + std::to_string(ptr->m_value.array->size()) +
|
|
") is out of range", *ptr));
|
|
}
|
|
|
|
// note: at performs range check
|
|
ptr = &ptr->at(array_index(reference_token));
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::null:
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
default:
|
|
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'", *ptr));
|
|
}
|
|
}
|
|
|
|
return *ptr;
|
|
}
|
|
|
|
/*!
|
|
@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
|
|
{
|
|
for (const auto& reference_token : reference_tokens)
|
|
{
|
|
switch (ptr->type())
|
|
{
|
|
case detail::value_t::object:
|
|
{
|
|
if (!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;
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
|
|
{
|
|
// invalid char
|
|
return false;
|
|
}
|
|
if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
|
|
{
|
|
// first char should be between '1' and '9'
|
|
return false;
|
|
}
|
|
for (std::size_t i = 1; i < reference_token.size(); i++)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
|
|
{
|
|
// other char should be between '0' and '9'
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
const auto idx = array_index(reference_token);
|
|
if (idx >= ptr->size())
|
|
{
|
|
// index out of range
|
|
return false;
|
|
}
|
|
|
|
ptr = &ptr->operator[](idx);
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::null:
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
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.
|
|
All exceptions below are documented there.
|
|
|
|
@throw parse_error.107 if the pointer is not empty or begins with '/'
|
|
@throw parse_error.108 if character '~' is not followed by '0' or '1'
|
|
*/
|
|
static std::vector<std::string> split(const std::string& reference_string)
|
|
{
|
|
std::vector<std::string> result;
|
|
|
|
// special case: empty reference string -> no reference tokens
|
|
if (reference_string.empty())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
// check if nonempty reference string begins with slash
|
|
if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
|
|
{
|
|
JSON_THROW(detail::parse_error::create(107, 1, "JSON pointer must be empty or begin with '/' - was: '" + reference_string + "'", BasicJsonType()));
|
|
}
|
|
|
|
// extract the reference tokens:
|
|
// - slash: position of the last read slash (or end of string)
|
|
// - start: position after the previous slash
|
|
for (
|
|
// search for the first slash after the first character
|
|
std::size_t slash = reference_string.find_first_of('/', 1),
|
|
// set the beginning of the first reference token
|
|
start = 1;
|
|
// we can stop if start == 0 (if slash == std::string::npos)
|
|
start != 0;
|
|
// set the beginning of the next reference token
|
|
// (will eventually be 0 if slash == std::string::npos)
|
|
start = (slash == std::string::npos) ? 0 : slash + 1,
|
|
// find next slash
|
|
slash = reference_string.find_first_of('/', start))
|
|
{
|
|
// use the text between the beginning of the reference token
|
|
// (start) and the last slash (slash).
|
|
auto reference_token = reference_string.substr(start, slash - start);
|
|
|
|
// check reference tokens are properly escaped
|
|
for (std::size_t pos = reference_token.find_first_of('~');
|
|
pos != std::string::npos;
|
|
pos = reference_token.find_first_of('~', pos + 1))
|
|
{
|
|
JSON_ASSERT(reference_token[pos] == '~');
|
|
|
|
// ~ must be followed by 0 or 1
|
|
if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
|
|
(reference_token[pos + 1] != '0' &&
|
|
reference_token[pos + 1] != '1')))
|
|
{
|
|
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", BasicJsonType()));
|
|
}
|
|
}
|
|
|
|
// finally, store the reference token
|
|
detail::unescape(reference_token);
|
|
result.push_back(reference_token);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@param[in] reference_string the reference string to the current value
|
|
@param[in] value the value to consider
|
|
@param[in,out] result the result object to insert values to
|
|
|
|
@note Empty objects or arrays are flattened to `null`.
|
|
*/
|
|
static void flatten(const std::string& reference_string,
|
|
const BasicJsonType& value,
|
|
BasicJsonType& result)
|
|
{
|
|
switch (value.type())
|
|
{
|
|
case detail::value_t::array:
|
|
{
|
|
if (value.m_value.array->empty())
|
|
{
|
|
// flatten empty array as null
|
|
result[reference_string] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
// iterate array and use index as reference string
|
|
for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
|
|
{
|
|
flatten(reference_string + "/" + std::to_string(i),
|
|
value.m_value.array->operator[](i), result);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::object:
|
|
{
|
|
if (value.m_value.object->empty())
|
|
{
|
|
// flatten empty object as null
|
|
result[reference_string] = nullptr;
|
|
}
|
|
else
|
|
{
|
|
// iterate object and use keys as reference string
|
|
for (const auto& element : *value.m_value.object)
|
|
{
|
|
flatten(reference_string + "/" + detail::escape(element.first), element.second, result);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case detail::value_t::null:
|
|
case detail::value_t::string:
|
|
case detail::value_t::boolean:
|
|
case detail::value_t::number_integer:
|
|
case detail::value_t::number_unsigned:
|
|
case detail::value_t::number_float:
|
|
case detail::value_t::binary:
|
|
case detail::value_t::discarded:
|
|
default:
|
|
{
|
|
// add primitive value with its reference string
|
|
result[reference_string] = value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[in] value flattened JSON
|
|
|
|
@return unflattened JSON
|
|
|
|
@throw parse_error.109 if array index is not a number
|
|
@throw type_error.314 if value is not an object
|
|
@throw type_error.315 if object values are not primitive
|
|
@throw type_error.313 if value cannot be unflattened
|
|
*/
|
|
static BasicJsonType
|
|
unflatten(const BasicJsonType& value)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
|
|
{
|
|
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", value));
|
|
}
|
|
|
|
BasicJsonType result;
|
|
|
|
// iterate the JSON object values
|
|
for (const auto& element : *value.m_value.object)
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
|
|
{
|
|
JSON_THROW(detail::type_error::create(315, "values in object must be primitive", element.second));
|
|
}
|
|
|
|
// assign value to reference pointed to by JSON pointer; Note that if
|
|
// the JSON pointer is "" (i.e., points to the whole value), function
|
|
// get_and_create returns a reference to result itself. An assignment
|
|
// will then create a primitive value.
|
|
json_pointer(element.first).get_and_create(result) = element.second;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
@brief compares two JSON pointers for equality
|
|
|
|
@param[in] lhs JSON pointer to compare
|
|
@param[in] rhs JSON pointer to compare
|
|
@return whether @a lhs is equal to @a rhs
|
|
|
|
@complexity Linear in the length of the JSON pointer
|
|
|
|
@exceptionsafety No-throw guarantee: this function never throws exceptions.
|
|
*/
|
|
friend bool operator==(json_pointer const& lhs,
|
|
json_pointer const& rhs) noexcept
|
|
{
|
|
return lhs.reference_tokens == rhs.reference_tokens;
|
|
}
|
|
|
|
/*!
|
|
@brief compares two JSON pointers for inequality
|
|
|
|
@param[in] lhs JSON pointer to compare
|
|
@param[in] rhs JSON pointer to compare
|
|
@return whether @a lhs is not equal @a rhs
|
|
|
|
@complexity Linear in the length of the JSON pointer
|
|
|
|
@exceptionsafety No-throw guarantee: this function never throws exceptions.
|
|
*/
|
|
friend bool operator!=(json_pointer const& lhs,
|
|
json_pointer const& rhs) noexcept
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
/// the reference tokens
|
|
std::vector<std::string> reference_tokens;
|
|
};
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/json_ref.hpp>
|
|
|
|
|
|
#include <initializer_list>
|
|
#include <utility>
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
template<typename BasicJsonType>
|
|
class json_ref
|
|
{
|
|
public:
|
|
using value_type = BasicJsonType;
|
|
|
|
json_ref(value_type&& value)
|
|
: owned_value(std::move(value))
|
|
{}
|
|
|
|
json_ref(const value_type& value)
|
|
: value_ref(&value)
|
|
{}
|
|
|
|
json_ref(std::initializer_list<json_ref> init)
|
|
: owned_value(init)
|
|
{}
|
|
|
|
template <
|
|
class... Args,
|
|
enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
|
|
json_ref(Args && ... args)
|
|
: owned_value(std::forward<Args>(args)...)
|
|
{}
|
|
|
|
// class should be movable only
|
|
json_ref(json_ref&&) noexcept = default;
|
|
json_ref(const json_ref&) = delete;
|
|
json_ref& operator=(const json_ref&) = delete;
|
|
json_ref& operator=(json_ref&&) = delete;
|
|
~json_ref() = default;
|
|
|
|
value_type moved_or_copied() const
|
|
{
|
|
if (value_ref == nullptr)
|
|
{
|
|
return std::move(owned_value);
|
|
}
|
|
return *value_ref;
|
|
}
|
|
|
|
value_type const& operator*() const
|
|
{
|
|
return value_ref ? *value_ref : owned_value;
|
|
}
|
|
|
|
value_type const* operator->() const
|
|
{
|
|
return &** this;
|
|
}
|
|
|
|
private:
|
|
mutable value_type owned_value = nullptr;
|
|
value_type const* value_ref = nullptr;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/string_escape.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/type_traits.hpp>
|
|
|
|
// #include <nlohmann/detail/output/binary_writer.hpp>
|
|
|
|
|
|
#include <algorithm> // reverse
|
|
#include <array> // array
|
|
#include <cmath> // isnan, isinf
|
|
#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
|
|
#include <cstring> // memcpy
|
|
#include <limits> // numeric_limits
|
|
#include <string> // string
|
|
#include <utility> // move
|
|
|
|
// #include <nlohmann/detail/input/binary_reader.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/output/output_adapters.hpp>
|
|
|
|
|
|
#include <algorithm> // copy
|
|
#include <cstddef> // size_t
|
|
#include <iterator> // back_inserter
|
|
#include <memory> // shared_ptr, make_shared
|
|
#include <string> // basic_string
|
|
#include <vector> // vector
|
|
|
|
#ifndef JSON_NO_IO
|
|
#include <ios> // streamsize
|
|
#include <ostream> // basic_ostream
|
|
#endif // JSON_NO_IO
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
/// abstract output adapter interface
|
|
template<typename CharType> struct output_adapter_protocol
|
|
{
|
|
virtual void write_character(CharType c) = 0;
|
|
virtual void write_characters(const CharType* s, std::size_t length) = 0;
|
|
virtual ~output_adapter_protocol() = default;
|
|
|
|
output_adapter_protocol() = default;
|
|
output_adapter_protocol(const output_adapter_protocol&) = default;
|
|
output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
|
|
output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
|
|
output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
|
|
};
|
|
|
|
/// a type to simplify interfaces
|
|
template<typename CharType>
|
|
using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
|
|
|
|
/// output adapter for byte vectors
|
|
template<typename CharType, typename AllocatorType = std::allocator<CharType>>
|
|
class output_vector_adapter : public output_adapter_protocol<CharType>
|
|
{
|
|
public:
|
|
explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
|
|
: v(vec)
|
|
{}
|
|
|
|
void write_character(CharType c) override
|
|
{
|
|
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));
|
|
}
|
|
|
|
private:
|
|
std::vector<CharType, AllocatorType>& v;
|
|
};
|
|
|
|
#ifndef JSON_NO_IO
|
|
/// output adapter for output streams
|
|
template<typename CharType>
|
|
class output_stream_adapter : public output_adapter_protocol<CharType>
|
|
{
|
|
public:
|
|
explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
|
|
: stream(s)
|
|
{}
|
|
|
|
void write_character(CharType c) override
|
|
{
|
|
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));
|
|
}
|
|
|
|
private:
|
|
std::basic_ostream<CharType>& stream;
|
|
};
|
|
#endif // JSON_NO_IO
|
|
|
|
/// output adapter for basic_string
|
|
template<typename CharType, typename StringType = std::basic_string<CharType>>
|
|
class output_string_adapter : public output_adapter_protocol<CharType>
|
|
{
|
|
public:
|
|
explicit output_string_adapter(StringType& s) noexcept
|
|
: str(s)
|
|
{}
|
|
|
|
void write_character(CharType c) override
|
|
{
|
|
str.push_back(c);
|
|
}
|
|
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
void write_characters(const CharType* s, std::size_t length) override
|
|
{
|
|
str.append(s, length);
|
|
}
|
|
|
|
private:
|
|
StringType& str;
|
|
};
|
|
|
|
template<typename CharType, typename StringType = std::basic_string<CharType>>
|
|
class output_adapter
|
|
{
|
|
public:
|
|
template<typename AllocatorType = std::allocator<CharType>>
|
|
output_adapter(std::vector<CharType, AllocatorType>& vec)
|
|
: oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
|
|
|
|
#ifndef JSON_NO_IO
|
|
output_adapter(std::basic_ostream<CharType>& s)
|
|
: oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
|
|
#endif // JSON_NO_IO
|
|
|
|
output_adapter(StringType& s)
|
|
: oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
|
|
|
|
operator output_adapter_t<CharType>()
|
|
{
|
|
return oa;
|
|
}
|
|
|
|
private:
|
|
output_adapter_t<CharType> oa = nullptr;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
///////////////////
|
|
// binary writer //
|
|
///////////////////
|
|
|
|
/*!
|
|
@brief serialization to CBOR and MessagePack values
|
|
*/
|
|
template<typename BasicJsonType, typename CharType>
|
|
class binary_writer
|
|
{
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using binary_t = typename BasicJsonType::binary_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
|
|
public:
|
|
/*!
|
|
@brief create a binary writer
|
|
|
|
@param[in] adapter output adapter to write to
|
|
*/
|
|
explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
|
|
{
|
|
JSON_ASSERT(oa);
|
|
}
|
|
|
|
/*!
|
|
@param[in] j JSON value to serialize
|
|
@pre j.type() == value_t::object
|
|
*/
|
|
void write_bson(const BasicJsonType& j)
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::object:
|
|
{
|
|
write_bson_object(*j.m_value.object);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::array:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name()), j));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[in] j JSON value to serialize
|
|
*/
|
|
void write_cbor(const BasicJsonType& j)
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::null:
|
|
{
|
|
oa->write_character(to_char_type(0xF6));
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
oa->write_character(j.m_value.boolean
|
|
? to_char_type(0xF5)
|
|
: to_char_type(0xF4));
|
|
break;
|
|
}
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
if (j.m_value.number_integer >= 0)
|
|
{
|
|
// CBOR does not differentiate between positive signed
|
|
// integers and unsigned integers. Therefore, we used the
|
|
// code from the value_t::number_unsigned case here.
|
|
if (j.m_value.number_integer <= 0x17)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x18));
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x19));
|
|
write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x1A));
|
|
write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
|
|
}
|
|
else
|
|
{
|
|
oa->write_character(to_char_type(0x1B));
|
|
write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The conversions below encode the sign in the first
|
|
// byte, and the value is converted to a positive number.
|
|
const auto positive_number = -1 - j.m_value.number_integer;
|
|
if (j.m_value.number_integer >= -24)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0x20 + positive_number));
|
|
}
|
|
else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x38));
|
|
write_number(static_cast<std::uint8_t>(positive_number));
|
|
}
|
|
else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x39));
|
|
write_number(static_cast<std::uint16_t>(positive_number));
|
|
}
|
|
else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x3A));
|
|
write_number(static_cast<std::uint32_t>(positive_number));
|
|
}
|
|
else
|
|
{
|
|
oa->write_character(to_char_type(0x3B));
|
|
write_number(static_cast<std::uint64_t>(positive_number));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
if (j.m_value.number_unsigned <= 0x17)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x18));
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x19));
|
|
write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x1A));
|
|
write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
|
|
}
|
|
else
|
|
{
|
|
oa->write_character(to_char_type(0x1B));
|
|
write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
if (std::isnan(j.m_value.number_float))
|
|
{
|
|
// NaN is 0xf97e00 in CBOR
|
|
oa->write_character(to_char_type(0xF9));
|
|
oa->write_character(to_char_type(0x7E));
|
|
oa->write_character(to_char_type(0x00));
|
|
}
|
|
else if (std::isinf(j.m_value.number_float))
|
|
{
|
|
// Infinity is 0xf97c00, -Infinity is 0xf9fc00
|
|
oa->write_character(to_char_type(0xf9));
|
|
oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
|
|
oa->write_character(to_char_type(0x00));
|
|
}
|
|
else
|
|
{
|
|
write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
// step 1: write control byte and the string length
|
|
const auto N = j.m_value.string->size();
|
|
if (N <= 0x17)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0x60 + N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x78));
|
|
write_number(static_cast<std::uint8_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x79));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x7A));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
// LCOV_EXCL_START
|
|
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x7B));
|
|
write_number(static_cast<std::uint64_t>(N));
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
// step 2: write the string
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
|
|
j.m_value.string->size());
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
// step 1: write control byte and the array size
|
|
const auto N = j.m_value.array->size();
|
|
if (N <= 0x17)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0x80 + N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x98));
|
|
write_number(static_cast<std::uint8_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x99));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x9A));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
// LCOV_EXCL_START
|
|
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x9B));
|
|
write_number(static_cast<std::uint64_t>(N));
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
// step 2: write each element
|
|
for (const auto& el : *j.m_value.array)
|
|
{
|
|
write_cbor(el);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
if (j.m_value.binary->has_subtype())
|
|
{
|
|
if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0xd8));
|
|
write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
|
|
}
|
|
else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0xd9));
|
|
write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
|
|
}
|
|
else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0xda));
|
|
write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
|
|
}
|
|
else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0xdb));
|
|
write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
|
|
}
|
|
}
|
|
|
|
// step 1: write control byte and the binary array size
|
|
const auto N = j.m_value.binary->size();
|
|
if (N <= 0x17)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0x40 + N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x58));
|
|
write_number(static_cast<std::uint8_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x59));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x5A));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
// LCOV_EXCL_START
|
|
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0x5B));
|
|
write_number(static_cast<std::uint64_t>(N));
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
// step 2: write each element
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(j.m_value.binary->data()),
|
|
N);
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
// step 1: write control byte and the object size
|
|
const auto N = j.m_value.object->size();
|
|
if (N <= 0x17)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(0xA0 + N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0xB8));
|
|
write_number(static_cast<std::uint8_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0xB9));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0xBA));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
// LCOV_EXCL_START
|
|
else if (N <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
oa->write_character(to_char_type(0xBB));
|
|
write_number(static_cast<std::uint64_t>(N));
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
|
|
// step 2: write each element
|
|
for (const auto& el : *j.m_value.object)
|
|
{
|
|
write_cbor(el.first);
|
|
write_cbor(el.second);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[in] j JSON value to serialize
|
|
*/
|
|
void write_msgpack(const BasicJsonType& j)
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::null: // nil
|
|
{
|
|
oa->write_character(to_char_type(0xC0));
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean: // true and false
|
|
{
|
|
oa->write_character(j.m_value.boolean
|
|
? to_char_type(0xC3)
|
|
: to_char_type(0xC2));
|
|
break;
|
|
}
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
if (j.m_value.number_integer >= 0)
|
|
{
|
|
// MessagePack does not differentiate between positive
|
|
// signed integers and unsigned integers. Therefore, we used
|
|
// the code from the value_t::number_unsigned case here.
|
|
if (j.m_value.number_unsigned < 128)
|
|
{
|
|
// positive fixnum
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
// uint 8
|
|
oa->write_character(to_char_type(0xCC));
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
// uint 16
|
|
oa->write_character(to_char_type(0xCD));
|
|
write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
// uint 32
|
|
oa->write_character(to_char_type(0xCE));
|
|
write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
// uint 64
|
|
oa->write_character(to_char_type(0xCF));
|
|
write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (j.m_value.number_integer >= -32)
|
|
{
|
|
// negative fixnum
|
|
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
|
|
j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
|
|
{
|
|
// int 8
|
|
oa->write_character(to_char_type(0xD0));
|
|
write_number(static_cast<std::int8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
|
|
j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
|
|
{
|
|
// int 16
|
|
oa->write_character(to_char_type(0xD1));
|
|
write_number(static_cast<std::int16_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
|
|
j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
|
|
{
|
|
// int 32
|
|
oa->write_character(to_char_type(0xD2));
|
|
write_number(static_cast<std::int32_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
|
|
j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
|
|
{
|
|
// int 64
|
|
oa->write_character(to_char_type(0xD3));
|
|
write_number(static_cast<std::int64_t>(j.m_value.number_integer));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
if (j.m_value.number_unsigned < 128)
|
|
{
|
|
// positive fixnum
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
// uint 8
|
|
oa->write_character(to_char_type(0xCC));
|
|
write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
// uint 16
|
|
oa->write_character(to_char_type(0xCD));
|
|
write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
// uint 32
|
|
oa->write_character(to_char_type(0xCE));
|
|
write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
|
|
}
|
|
else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
|
|
{
|
|
// uint 64
|
|
oa->write_character(to_char_type(0xCF));
|
|
write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
// step 1: write control byte and the string length
|
|
const auto N = j.m_value.string->size();
|
|
if (N <= 31)
|
|
{
|
|
// fixstr
|
|
write_number(static_cast<std::uint8_t>(0xA0 | N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
// str 8
|
|
oa->write_character(to_char_type(0xD9));
|
|
write_number(static_cast<std::uint8_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
// str 16
|
|
oa->write_character(to_char_type(0xDA));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
// str 32
|
|
oa->write_character(to_char_type(0xDB));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
|
|
// step 2: write the string
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
|
|
j.m_value.string->size());
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
// step 1: write control byte and the array size
|
|
const auto N = j.m_value.array->size();
|
|
if (N <= 15)
|
|
{
|
|
// fixarray
|
|
write_number(static_cast<std::uint8_t>(0x90 | N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
// array 16
|
|
oa->write_character(to_char_type(0xDC));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
// array 32
|
|
oa->write_character(to_char_type(0xDD));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
|
|
// step 2: write each element
|
|
for (const auto& el : *j.m_value.array)
|
|
{
|
|
write_msgpack(el);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
// step 0: determine if the binary type has a set subtype to
|
|
// determine whether or not to use the ext or fixext types
|
|
const bool use_ext = j.m_value.binary->has_subtype();
|
|
|
|
// step 1: write control byte and the byte string length
|
|
const auto N = j.m_value.binary->size();
|
|
if (N <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
std::uint8_t output_type{};
|
|
bool fixed = true;
|
|
if (use_ext)
|
|
{
|
|
switch (N)
|
|
{
|
|
case 1:
|
|
output_type = 0xD4; // fixext 1
|
|
break;
|
|
case 2:
|
|
output_type = 0xD5; // fixext 2
|
|
break;
|
|
case 4:
|
|
output_type = 0xD6; // fixext 4
|
|
break;
|
|
case 8:
|
|
output_type = 0xD7; // fixext 8
|
|
break;
|
|
case 16:
|
|
output_type = 0xD8; // fixext 16
|
|
break;
|
|
default:
|
|
output_type = 0xC7; // ext 8
|
|
fixed = false;
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
output_type = 0xC4; // bin 8
|
|
fixed = false;
|
|
}
|
|
|
|
oa->write_character(to_char_type(output_type));
|
|
if (!fixed)
|
|
{
|
|
write_number(static_cast<std::uint8_t>(N));
|
|
}
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
std::uint8_t output_type = use_ext
|
|
? 0xC8 // ext 16
|
|
: 0xC5; // bin 16
|
|
|
|
oa->write_character(to_char_type(output_type));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
std::uint8_t output_type = use_ext
|
|
? 0xC9 // ext 32
|
|
: 0xC6; // bin 32
|
|
|
|
oa->write_character(to_char_type(output_type));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
|
|
// step 1.5: if this is an ext type, write the subtype
|
|
if (use_ext)
|
|
{
|
|
write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
|
|
}
|
|
|
|
// step 2: write the byte string
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(j.m_value.binary->data()),
|
|
N);
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
// step 1: write control byte and the object size
|
|
const auto N = j.m_value.object->size();
|
|
if (N <= 15)
|
|
{
|
|
// fixmap
|
|
write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint16_t>::max)())
|
|
{
|
|
// map 16
|
|
oa->write_character(to_char_type(0xDE));
|
|
write_number(static_cast<std::uint16_t>(N));
|
|
}
|
|
else if (N <= (std::numeric_limits<std::uint32_t>::max)())
|
|
{
|
|
// map 32
|
|
oa->write_character(to_char_type(0xDF));
|
|
write_number(static_cast<std::uint32_t>(N));
|
|
}
|
|
|
|
// step 2: write each element
|
|
for (const auto& el : *j.m_value.object)
|
|
{
|
|
write_msgpack(el.first);
|
|
write_msgpack(el.second);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@param[in] j JSON value to serialize
|
|
@param[in] use_count whether to use '#' prefixes (optimized format)
|
|
@param[in] use_type whether to use '$' prefixes (optimized format)
|
|
@param[in] add_prefix whether prefixes need to be used for this value
|
|
*/
|
|
void write_ubjson(const BasicJsonType& j, const bool use_count,
|
|
const bool use_type, const bool add_prefix = true)
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::null:
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('Z'));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(j.m_value.boolean
|
|
? to_char_type('T')
|
|
: to_char_type('F'));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('S'));
|
|
}
|
|
write_number_with_ubjson_prefix(j.m_value.string->size(), true);
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
|
|
j.m_value.string->size());
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('['));
|
|
}
|
|
|
|
bool prefix_required = true;
|
|
if (use_type && !j.m_value.array->empty())
|
|
{
|
|
JSON_ASSERT(use_count);
|
|
const CharType first_prefix = ubjson_prefix(j.front());
|
|
const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
|
|
[this, first_prefix](const BasicJsonType & v)
|
|
{
|
|
return ubjson_prefix(v) == first_prefix;
|
|
});
|
|
|
|
if (same_prefix)
|
|
{
|
|
prefix_required = false;
|
|
oa->write_character(to_char_type('$'));
|
|
oa->write_character(first_prefix);
|
|
}
|
|
}
|
|
|
|
if (use_count)
|
|
{
|
|
oa->write_character(to_char_type('#'));
|
|
write_number_with_ubjson_prefix(j.m_value.array->size(), true);
|
|
}
|
|
|
|
for (const auto& el : *j.m_value.array)
|
|
{
|
|
write_ubjson(el, use_count, use_type, prefix_required);
|
|
}
|
|
|
|
if (!use_count)
|
|
{
|
|
oa->write_character(to_char_type(']'));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('['));
|
|
}
|
|
|
|
if (use_type && !j.m_value.binary->empty())
|
|
{
|
|
JSON_ASSERT(use_count);
|
|
oa->write_character(to_char_type('$'));
|
|
oa->write_character('U');
|
|
}
|
|
|
|
if (use_count)
|
|
{
|
|
oa->write_character(to_char_type('#'));
|
|
write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
|
|
}
|
|
|
|
if (use_type)
|
|
{
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(j.m_value.binary->data()),
|
|
j.m_value.binary->size());
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < j.m_value.binary->size(); ++i)
|
|
{
|
|
oa->write_character(to_char_type('U'));
|
|
oa->write_character(j.m_value.binary->data()[i]);
|
|
}
|
|
}
|
|
|
|
if (!use_count)
|
|
{
|
|
oa->write_character(to_char_type(']'));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('{'));
|
|
}
|
|
|
|
bool prefix_required = true;
|
|
if (use_type && !j.m_value.object->empty())
|
|
{
|
|
JSON_ASSERT(use_count);
|
|
const CharType first_prefix = ubjson_prefix(j.front());
|
|
const bool same_prefix = std::all_of(j.begin(), j.end(),
|
|
[this, first_prefix](const BasicJsonType & v)
|
|
{
|
|
return ubjson_prefix(v) == first_prefix;
|
|
});
|
|
|
|
if (same_prefix)
|
|
{
|
|
prefix_required = false;
|
|
oa->write_character(to_char_type('$'));
|
|
oa->write_character(first_prefix);
|
|
}
|
|
}
|
|
|
|
if (use_count)
|
|
{
|
|
oa->write_character(to_char_type('#'));
|
|
write_number_with_ubjson_prefix(j.m_value.object->size(), true);
|
|
}
|
|
|
|
for (const auto& el : *j.m_value.object)
|
|
{
|
|
write_number_with_ubjson_prefix(el.first.size(), true);
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(el.first.c_str()),
|
|
el.first.size());
|
|
write_ubjson(el.second, use_count, use_type, prefix_required);
|
|
}
|
|
|
|
if (!use_count)
|
|
{
|
|
oa->write_character(to_char_type('}'));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private:
|
|
//////////
|
|
// BSON //
|
|
//////////
|
|
|
|
/*!
|
|
@return The size of a BSON document entry header, including the id marker
|
|
and the entry name size (and its null-terminator).
|
|
*/
|
|
static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
|
|
{
|
|
const auto it = name.find(static_cast<typename string_t::value_type>(0));
|
|
if (JSON_HEDLEY_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) + ")", j));
|
|
static_cast<void>(j);
|
|
}
|
|
|
|
return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
|
|
}
|
|
|
|
/*!
|
|
@brief Writes the given @a element_type and @a name to the output adapter
|
|
*/
|
|
void write_bson_entry_header(const string_t& name,
|
|
const std::uint8_t element_type)
|
|
{
|
|
oa->write_character(to_char_type(element_type)); // boolean
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(name.c_str()),
|
|
name.size() + 1u);
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and boolean value @a value
|
|
*/
|
|
void write_bson_boolean(const string_t& name,
|
|
const bool value)
|
|
{
|
|
write_bson_entry_header(name, 0x08);
|
|
oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and double value @a value
|
|
*/
|
|
void write_bson_double(const string_t& name,
|
|
const double value)
|
|
{
|
|
write_bson_entry_header(name, 0x01);
|
|
write_number<double, true>(value);
|
|
}
|
|
|
|
/*!
|
|
@return The size of the BSON-encoded string in @a value
|
|
*/
|
|
static std::size_t calc_bson_string_size(const string_t& value)
|
|
{
|
|
return sizeof(std::int32_t) + value.size() + 1ul;
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and string value @a value
|
|
*/
|
|
void write_bson_string(const string_t& name,
|
|
const string_t& value)
|
|
{
|
|
write_bson_entry_header(name, 0x02);
|
|
|
|
write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
|
|
oa->write_characters(
|
|
reinterpret_cast<const CharType*>(value.c_str()),
|
|
value.size() + 1);
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and null value
|
|
*/
|
|
void write_bson_null(const string_t& name)
|
|
{
|
|
write_bson_entry_header(name, 0x0A);
|
|
}
|
|
|
|
/*!
|
|
@return The size of the BSON-encoded integer @a value
|
|
*/
|
|
static std::size_t calc_bson_integer_size(const std::int64_t value)
|
|
{
|
|
return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
|
|
? sizeof(std::int32_t)
|
|
: sizeof(std::int64_t);
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and integer @a value
|
|
*/
|
|
void write_bson_integer(const string_t& name,
|
|
const std::int64_t value)
|
|
{
|
|
if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
|
|
{
|
|
write_bson_entry_header(name, 0x10); // int32
|
|
write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
|
|
}
|
|
else
|
|
{
|
|
write_bson_entry_header(name, 0x12); // int64
|
|
write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@return The size of the BSON-encoded unsigned integer in @a j
|
|
*/
|
|
static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
|
|
{
|
|
return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
|
|
? sizeof(std::int32_t)
|
|
: sizeof(std::int64_t);
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and unsigned @a value
|
|
*/
|
|
void write_bson_unsigned(const string_t& name,
|
|
const BasicJsonType& j)
|
|
{
|
|
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
|
|
{
|
|
write_bson_entry_header(name, 0x10 /* int32 */);
|
|
write_number<std::int32_t, true>(static_cast<std::int32_t>(j.m_value.number_unsigned));
|
|
}
|
|
else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
|
|
{
|
|
write_bson_entry_header(name, 0x12 /* int64 */);
|
|
write_number<std::int64_t, true>(static_cast<std::int64_t>(j.m_value.number_unsigned));
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(j.m_value.number_unsigned) + " cannot be represented by BSON as it does not fit int64", j));
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and object @a value
|
|
*/
|
|
void write_bson_object_entry(const string_t& name,
|
|
const typename BasicJsonType::object_t& value)
|
|
{
|
|
write_bson_entry_header(name, 0x03); // object
|
|
write_bson_object(value);
|
|
}
|
|
|
|
/*!
|
|
@return The size of the BSON-encoded array @a value
|
|
*/
|
|
static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
|
|
{
|
|
std::size_t array_index = 0ul;
|
|
|
|
const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
|
|
{
|
|
return result + calc_bson_element_size(std::to_string(array_index++), el);
|
|
});
|
|
|
|
return sizeof(std::int32_t) + embedded_document_size + 1ul;
|
|
}
|
|
|
|
/*!
|
|
@return The size of the BSON-encoded binary array @a value
|
|
*/
|
|
static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
|
|
{
|
|
return sizeof(std::int32_t) + value.size() + 1ul;
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and array @a value
|
|
*/
|
|
void write_bson_array(const string_t& name,
|
|
const typename BasicJsonType::array_t& value)
|
|
{
|
|
write_bson_entry_header(name, 0x04); // array
|
|
write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
|
|
|
|
std::size_t array_index = 0ul;
|
|
|
|
for (const auto& el : value)
|
|
{
|
|
write_bson_element(std::to_string(array_index++), el);
|
|
}
|
|
|
|
oa->write_character(to_char_type(0x00));
|
|
}
|
|
|
|
/*!
|
|
@brief Writes a BSON element with key @a name and binary value @a value
|
|
*/
|
|
void write_bson_binary(const string_t& name,
|
|
const binary_t& value)
|
|
{
|
|
write_bson_entry_header(name, 0x05);
|
|
|
|
write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
|
|
write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
|
|
|
|
oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
|
|
}
|
|
|
|
/*!
|
|
@brief Calculates the size necessary to serialize the JSON value @a j with its @a name
|
|
@return The calculated size for the BSON document entry for @a j with the given @a name.
|
|
*/
|
|
static std::size_t calc_bson_element_size(const string_t& name,
|
|
const BasicJsonType& j)
|
|
{
|
|
const auto header_size = calc_bson_entry_header_size(name, j);
|
|
switch (j.type())
|
|
{
|
|
case value_t::object:
|
|
return header_size + calc_bson_object_size(*j.m_value.object);
|
|
|
|
case value_t::array:
|
|
return header_size + calc_bson_array_size(*j.m_value.array);
|
|
|
|
case value_t::binary:
|
|
return header_size + calc_bson_binary_size(*j.m_value.binary);
|
|
|
|
case value_t::boolean:
|
|
return header_size + 1ul;
|
|
|
|
case value_t::number_float:
|
|
return header_size + 8ul;
|
|
|
|
case value_t::number_integer:
|
|
return header_size + calc_bson_integer_size(j.m_value.number_integer);
|
|
|
|
case value_t::number_unsigned:
|
|
return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
|
|
|
|
case value_t::string:
|
|
return header_size + calc_bson_string_size(*j.m_value.string);
|
|
|
|
case value_t::null:
|
|
return header_size + 0ul;
|
|
|
|
// LCOV_EXCL_START
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
|
|
return 0ul;
|
|
// LCOV_EXCL_STOP
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief Serializes the JSON value @a j to BSON and associates it with the
|
|
key @a name.
|
|
@param name The name to associate with the JSON entity @a j within the
|
|
current BSON document
|
|
*/
|
|
void write_bson_element(const string_t& name,
|
|
const BasicJsonType& j)
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::object:
|
|
return write_bson_object_entry(name, *j.m_value.object);
|
|
|
|
case value_t::array:
|
|
return write_bson_array(name, *j.m_value.array);
|
|
|
|
case value_t::binary:
|
|
return write_bson_binary(name, *j.m_value.binary);
|
|
|
|
case value_t::boolean:
|
|
return write_bson_boolean(name, j.m_value.boolean);
|
|
|
|
case value_t::number_float:
|
|
return write_bson_double(name, j.m_value.number_float);
|
|
|
|
case value_t::number_integer:
|
|
return write_bson_integer(name, j.m_value.number_integer);
|
|
|
|
case value_t::number_unsigned:
|
|
return write_bson_unsigned(name, j);
|
|
|
|
case value_t::string:
|
|
return write_bson_string(name, *j.m_value.string);
|
|
|
|
case value_t::null:
|
|
return write_bson_null(name);
|
|
|
|
// LCOV_EXCL_START
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
|
|
return;
|
|
// LCOV_EXCL_STOP
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief Calculates the size of the BSON serialization of the given
|
|
JSON-object @a j.
|
|
@param[in] value JSON value to serialize
|
|
@pre value.type() == value_t::object
|
|
*/
|
|
static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
|
|
{
|
|
std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
|
|
[](size_t result, const typename BasicJsonType::object_t::value_type & el)
|
|
{
|
|
return result += calc_bson_element_size(el.first, el.second);
|
|
});
|
|
|
|
return sizeof(std::int32_t) + document_size + 1ul;
|
|
}
|
|
|
|
/*!
|
|
@param[in] value JSON value to serialize
|
|
@pre value.type() == value_t::object
|
|
*/
|
|
void write_bson_object(const typename BasicJsonType::object_t& value)
|
|
{
|
|
write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
|
|
|
|
for (const auto& el : value)
|
|
{
|
|
write_bson_element(el.first, el.second);
|
|
}
|
|
|
|
oa->write_character(to_char_type(0x00));
|
|
}
|
|
|
|
//////////
|
|
// CBOR //
|
|
//////////
|
|
|
|
static constexpr CharType get_cbor_float_prefix(float /*unused*/)
|
|
{
|
|
return to_char_type(0xFA); // Single-Precision Float
|
|
}
|
|
|
|
static constexpr CharType get_cbor_float_prefix(double /*unused*/)
|
|
{
|
|
return to_char_type(0xFB); // Double-Precision Float
|
|
}
|
|
|
|
/////////////
|
|
// MsgPack //
|
|
/////////////
|
|
|
|
static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
|
|
{
|
|
return to_char_type(0xCA); // float 32
|
|
}
|
|
|
|
static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
|
|
{
|
|
return to_char_type(0xCB); // float 64
|
|
}
|
|
|
|
////////////
|
|
// UBJSON //
|
|
////////////
|
|
|
|
// UBJSON: write number (floating point)
|
|
template<typename NumberType, typename std::enable_if<
|
|
std::is_floating_point<NumberType>::value, int>::type = 0>
|
|
void write_number_with_ubjson_prefix(const NumberType n,
|
|
const bool add_prefix)
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(get_ubjson_float_prefix(n));
|
|
}
|
|
write_number(n);
|
|
}
|
|
|
|
// UBJSON: write number (unsigned integer)
|
|
template<typename NumberType, typename std::enable_if<
|
|
std::is_unsigned<NumberType>::value, int>::type = 0>
|
|
void write_number_with_ubjson_prefix(const NumberType n,
|
|
const bool add_prefix)
|
|
{
|
|
if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('i')); // int8
|
|
}
|
|
write_number(static_cast<std::uint8_t>(n));
|
|
}
|
|
else if (n <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('U')); // uint8
|
|
}
|
|
write_number(static_cast<std::uint8_t>(n));
|
|
}
|
|
else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('I')); // int16
|
|
}
|
|
write_number(static_cast<std::int16_t>(n));
|
|
}
|
|
else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('l')); // int32
|
|
}
|
|
write_number(static_cast<std::int32_t>(n));
|
|
}
|
|
else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('L')); // int64
|
|
}
|
|
write_number(static_cast<std::int64_t>(n));
|
|
}
|
|
else
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('H')); // high-precision number
|
|
}
|
|
|
|
const auto number = BasicJsonType(n).dump();
|
|
write_number_with_ubjson_prefix(number.size(), true);
|
|
for (std::size_t i = 0; i < number.size(); ++i)
|
|
{
|
|
oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
|
|
}
|
|
}
|
|
}
|
|
|
|
// UBJSON: write number (signed integer)
|
|
template < typename NumberType, typename std::enable_if <
|
|
std::is_signed<NumberType>::value&&
|
|
!std::is_floating_point<NumberType>::value, int >::type = 0 >
|
|
void write_number_with_ubjson_prefix(const NumberType n,
|
|
const bool add_prefix)
|
|
{
|
|
if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('i')); // int8
|
|
}
|
|
write_number(static_cast<std::int8_t>(n));
|
|
}
|
|
else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('U')); // uint8
|
|
}
|
|
write_number(static_cast<std::uint8_t>(n));
|
|
}
|
|
else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('I')); // int16
|
|
}
|
|
write_number(static_cast<std::int16_t>(n));
|
|
}
|
|
else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('l')); // int32
|
|
}
|
|
write_number(static_cast<std::int32_t>(n));
|
|
}
|
|
else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('L')); // int64
|
|
}
|
|
write_number(static_cast<std::int64_t>(n));
|
|
}
|
|
// LCOV_EXCL_START
|
|
else
|
|
{
|
|
if (add_prefix)
|
|
{
|
|
oa->write_character(to_char_type('H')); // high-precision number
|
|
}
|
|
|
|
const auto number = BasicJsonType(n).dump();
|
|
write_number_with_ubjson_prefix(number.size(), true);
|
|
for (std::size_t i = 0; i < number.size(); ++i)
|
|
{
|
|
oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
|
|
}
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
}
|
|
|
|
/*!
|
|
@brief determine the type prefix of container values
|
|
*/
|
|
CharType ubjson_prefix(const BasicJsonType& j) const noexcept
|
|
{
|
|
switch (j.type())
|
|
{
|
|
case value_t::null:
|
|
return 'Z';
|
|
|
|
case value_t::boolean:
|
|
return j.m_value.boolean ? 'T' : 'F';
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
|
|
{
|
|
return 'i';
|
|
}
|
|
if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
|
|
{
|
|
return 'U';
|
|
}
|
|
if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
|
|
{
|
|
return 'I';
|
|
}
|
|
if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
|
|
{
|
|
return 'l';
|
|
}
|
|
if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
|
|
{
|
|
return 'L';
|
|
}
|
|
// anything else is treated as high-precision number
|
|
return 'H'; // LCOV_EXCL_LINE
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((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)()))
|
|
{
|
|
return 'U';
|
|
}
|
|
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((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)()))
|
|
{
|
|
return 'l';
|
|
}
|
|
if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
|
|
{
|
|
return 'L';
|
|
}
|
|
// anything else is treated as high-precision number
|
|
return 'H'; // LCOV_EXCL_LINE
|
|
}
|
|
|
|
case value_t::number_float:
|
|
return get_ubjson_float_prefix(j.m_value.number_float);
|
|
|
|
case value_t::string:
|
|
return 'S';
|
|
|
|
case value_t::array: // fallthrough
|
|
case value_t::binary:
|
|
return '[';
|
|
|
|
case value_t::object:
|
|
return '{';
|
|
|
|
case value_t::discarded:
|
|
default: // discarded values
|
|
return 'N';
|
|
}
|
|
}
|
|
|
|
static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
|
|
{
|
|
return 'd'; // float 32
|
|
}
|
|
|
|
static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
|
|
{
|
|
return 'D'; // float 64
|
|
}
|
|
|
|
///////////////////////
|
|
// Utility functions //
|
|
///////////////////////
|
|
|
|
/*
|
|
@brief write a number to output input
|
|
@param[in] n number of type @a NumberType
|
|
@tparam NumberType the type of the number
|
|
@tparam OutputIsLittleEndian Set to true if output data is
|
|
required to be little endian
|
|
|
|
@note This function needs to respect the system's endianness, because bytes
|
|
in CBOR, MessagePack, and UBJSON are stored in network order (big
|
|
endian) and therefore need reordering on little endian systems.
|
|
*/
|
|
template<typename NumberType, bool OutputIsLittleEndian = false>
|
|
void write_number(const NumberType n)
|
|
{
|
|
// step 1: write number to array of length NumberType
|
|
std::array<CharType, sizeof(NumberType)> vec{};
|
|
std::memcpy(vec.data(), &n, sizeof(NumberType));
|
|
|
|
// step 2: write array to output (with possible reordering)
|
|
if (is_little_endian != OutputIsLittleEndian)
|
|
{
|
|
// reverse byte order prior to conversion if necessary
|
|
std::reverse(vec.begin(), vec.end());
|
|
}
|
|
|
|
oa->write_characters(vec.data(), sizeof(NumberType));
|
|
}
|
|
|
|
void write_compact_float(const number_float_t n, detail::input_format_t format)
|
|
{
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wfloat-equal"
|
|
#endif
|
|
if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
|
|
static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
|
|
static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
|
|
{
|
|
oa->write_character(format == detail::input_format_t::cbor
|
|
? get_cbor_float_prefix(static_cast<float>(n))
|
|
: get_msgpack_float_prefix(static_cast<float>(n)));
|
|
write_number(static_cast<float>(n));
|
|
}
|
|
else
|
|
{
|
|
oa->write_character(format == detail::input_format_t::cbor
|
|
? get_cbor_float_prefix(n)
|
|
: get_msgpack_float_prefix(n));
|
|
write_number(n);
|
|
}
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
|
|
public:
|
|
// The following to_char_type functions are implement the conversion
|
|
// between uint8_t and CharType. In case CharType is not unsigned,
|
|
// such a conversion is required to allow values greater than 128.
|
|
// See <https://github.com/nlohmann/json/issues/1286> for a discussion.
|
|
template < typename C = CharType,
|
|
enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
|
|
static constexpr CharType to_char_type(std::uint8_t x) noexcept
|
|
{
|
|
return *reinterpret_cast<char*>(&x);
|
|
}
|
|
|
|
template < typename C = CharType,
|
|
enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
|
|
static CharType to_char_type(std::uint8_t x) noexcept
|
|
{
|
|
static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
|
|
static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
|
|
CharType result;
|
|
std::memcpy(&result, &x, sizeof(x));
|
|
return result;
|
|
}
|
|
|
|
template<typename C = CharType,
|
|
enable_if_t<std::is_unsigned<C>::value>* = nullptr>
|
|
static constexpr CharType to_char_type(std::uint8_t x) noexcept
|
|
{
|
|
return x;
|
|
}
|
|
|
|
template < typename InputCharType, typename C = CharType,
|
|
enable_if_t <
|
|
std::is_signed<C>::value &&
|
|
std::is_signed<char>::value &&
|
|
std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
|
|
> * = nullptr >
|
|
static constexpr CharType to_char_type(InputCharType x) noexcept
|
|
{
|
|
return x;
|
|
}
|
|
|
|
private:
|
|
/// whether we can assume little endianness
|
|
const bool is_little_endian = little_endianness();
|
|
|
|
/// the output
|
|
output_adapter_t<CharType> oa = nullptr;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/output/output_adapters.hpp>
|
|
|
|
// #include <nlohmann/detail/output/serializer.hpp>
|
|
|
|
|
|
#include <algorithm> // reverse, remove, fill, find, none_of
|
|
#include <array> // array
|
|
#include <clocale> // localeconv, lconv
|
|
#include <cmath> // labs, isfinite, isnan, signbit
|
|
#include <cstddef> // size_t, ptrdiff_t
|
|
#include <cstdint> // uint8_t
|
|
#include <cstdio> // snprintf
|
|
#include <limits> // numeric_limits
|
|
#include <string> // string, char_traits
|
|
#include <iomanip> // setfill, setw
|
|
#include <sstream> // stringstream
|
|
#include <type_traits> // is_same
|
|
#include <utility> // move
|
|
|
|
// #include <nlohmann/detail/conversions/to_chars.hpp>
|
|
|
|
|
|
#include <array> // array
|
|
#include <cmath> // signbit, isfinite
|
|
#include <cstdint> // intN_t, uintN_t
|
|
#include <cstring> // memcpy, memmove
|
|
#include <limits> // numeric_limits
|
|
#include <type_traits> // conditional
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
|
|
/*!
|
|
@brief implements the Grisu2 algorithm for binary to decimal floating-point
|
|
conversion.
|
|
|
|
This implementation is a slightly modified version of the reference
|
|
implementation which may be obtained from
|
|
http://florian.loitsch.com/publications (bench.tar.gz).
|
|
|
|
The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
|
|
|
|
For a detailed description of the algorithm see:
|
|
|
|
[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
|
|
Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
|
|
Language Design and Implementation, PLDI 2010
|
|
[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
|
|
Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
|
|
Design and Implementation, PLDI 1996
|
|
*/
|
|
namespace dtoa_impl
|
|
{
|
|
|
|
template<typename Target, typename Source>
|
|
Target reinterpret_bits(const Source source)
|
|
{
|
|
static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
|
|
|
|
Target target;
|
|
std::memcpy(&target, &source, sizeof(Source));
|
|
return target;
|
|
}
|
|
|
|
struct diyfp // f * 2^e
|
|
{
|
|
static constexpr int kPrecision = 64; // = q
|
|
|
|
std::uint64_t f = 0;
|
|
int e = 0;
|
|
|
|
constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
|
|
|
|
/*!
|
|
@brief returns x - y
|
|
@pre x.e == y.e and x.f >= y.f
|
|
*/
|
|
static diyfp sub(const diyfp& x, const diyfp& y) noexcept
|
|
{
|
|
JSON_ASSERT(x.e == y.e);
|
|
JSON_ASSERT(x.f >= y.f);
|
|
|
|
return {x.f - y.f, x.e};
|
|
}
|
|
|
|
/*!
|
|
@brief returns x * y
|
|
@note The result is rounded. (Only the upper q bits are returned.)
|
|
*/
|
|
static diyfp mul(const diyfp& x, const diyfp& y) noexcept
|
|
{
|
|
static_assert(kPrecision == 64, "internal error");
|
|
|
|
// Computes:
|
|
// f = round((x.f * y.f) / 2^q)
|
|
// e = x.e + y.e + q
|
|
|
|
// Emulate the 64-bit * 64-bit multiplication:
|
|
//
|
|
// p = u * v
|
|
// = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
|
|
// = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
|
|
// = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
|
|
// = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
|
|
// = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
|
|
// = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
|
|
// = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
|
|
//
|
|
// (Since Q might be larger than 2^32 - 1)
|
|
//
|
|
// = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
|
|
//
|
|
// (Q_hi + H does not overflow a 64-bit int)
|
|
//
|
|
// = p_lo + 2^64 p_hi
|
|
|
|
const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
|
|
const std::uint64_t u_hi = x.f >> 32u;
|
|
const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
|
|
const std::uint64_t v_hi = y.f >> 32u;
|
|
|
|
const std::uint64_t p0 = u_lo * v_lo;
|
|
const std::uint64_t p1 = u_lo * v_hi;
|
|
const std::uint64_t p2 = u_hi * v_lo;
|
|
const std::uint64_t p3 = u_hi * v_hi;
|
|
|
|
const std::uint64_t p0_hi = p0 >> 32u;
|
|
const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
|
|
const std::uint64_t p1_hi = p1 >> 32u;
|
|
const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
|
|
const std::uint64_t p2_hi = p2 >> 32u;
|
|
|
|
std::uint64_t Q = p0_hi + p1_lo + p2_lo;
|
|
|
|
// The full product might now be computed as
|
|
//
|
|
// p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
|
|
// p_lo = p0_lo + (Q << 32)
|
|
//
|
|
// But in this particular case here, the full p_lo is not required.
|
|
// Effectively we only need to add the highest bit in p_lo to p_hi (and
|
|
// Q_hi + 1 does not overflow).
|
|
|
|
Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
|
|
|
|
const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
|
|
|
|
return {h, x.e + y.e + 64};
|
|
}
|
|
|
|
/*!
|
|
@brief normalize x such that the significand is >= 2^(q-1)
|
|
@pre x.f != 0
|
|
*/
|
|
static diyfp normalize(diyfp x) noexcept
|
|
{
|
|
JSON_ASSERT(x.f != 0);
|
|
|
|
while ((x.f >> 63u) == 0)
|
|
{
|
|
x.f <<= 1u;
|
|
x.e--;
|
|
}
|
|
|
|
return x;
|
|
}
|
|
|
|
/*!
|
|
@brief normalize x such that the result has the exponent E
|
|
@pre e >= x.e and the upper e - x.e bits of x.f must be zero.
|
|
*/
|
|
static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
|
|
{
|
|
const int delta = x.e - target_exponent;
|
|
|
|
JSON_ASSERT(delta >= 0);
|
|
JSON_ASSERT(((x.f << delta) >> delta) == x.f);
|
|
|
|
return {x.f << delta, target_exponent};
|
|
}
|
|
};
|
|
|
|
struct boundaries
|
|
{
|
|
diyfp w;
|
|
diyfp minus;
|
|
diyfp plus;
|
|
};
|
|
|
|
/*!
|
|
Compute the (normalized) diyfp representing the input number 'value' and its
|
|
boundaries.
|
|
|
|
@pre value must be finite and positive
|
|
*/
|
|
template<typename FloatType>
|
|
boundaries compute_boundaries(FloatType value)
|
|
{
|
|
JSON_ASSERT(std::isfinite(value));
|
|
JSON_ASSERT(value > 0);
|
|
|
|
// Convert the IEEE representation into a diyfp.
|
|
//
|
|
// If v is denormal:
|
|
// value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
|
|
// If v is normalized:
|
|
// value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
|
|
|
|
static_assert(std::numeric_limits<FloatType>::is_iec559,
|
|
"internal error: dtoa_short requires an IEEE-754 floating-point implementation");
|
|
|
|
constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
|
|
constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
|
|
constexpr int kMinExp = 1 - kBias;
|
|
constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
|
|
|
|
using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
|
|
|
|
const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
|
|
const std::uint64_t E = bits >> (kPrecision - 1);
|
|
const std::uint64_t F = bits & (kHiddenBit - 1);
|
|
|
|
const bool is_denormal = E == 0;
|
|
const diyfp v = is_denormal
|
|
? diyfp(F, kMinExp)
|
|
: diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
|
|
|
|
// Compute the boundaries m- and m+ of the floating-point value
|
|
// v = f * 2^e.
|
|
//
|
|
// Determine v- and v+, the floating-point predecessor and successor if v,
|
|
// respectively.
|
|
//
|
|
// v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
|
|
// = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
|
|
//
|
|
// v+ = v + 2^e
|
|
//
|
|
// Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
|
|
// between m- and m+ round to v, regardless of how the input rounding
|
|
// algorithm breaks ties.
|
|
//
|
|
// ---+-------------+-------------+-------------+-------------+--- (A)
|
|
// v- m- v m+ v+
|
|
//
|
|
// -----------------+------+------+-------------+-------------+--- (B)
|
|
// v- m- v m+ v+
|
|
|
|
const bool lower_boundary_is_closer = F == 0 && E > 1;
|
|
const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
|
|
const diyfp m_minus = lower_boundary_is_closer
|
|
? diyfp(4 * v.f - 1, v.e - 2) // (B)
|
|
: diyfp(2 * v.f - 1, v.e - 1); // (A)
|
|
|
|
// Determine the normalized w+ = m+.
|
|
const diyfp w_plus = diyfp::normalize(m_plus);
|
|
|
|
// Determine w- = m- such that e_(w-) = e_(w+).
|
|
const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
|
|
|
|
return {diyfp::normalize(v), w_minus, w_plus};
|
|
}
|
|
|
|
// Given normalized diyfp w, Grisu needs to find a (normalized) cached
|
|
// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
|
|
// within a certain range [alpha, gamma] (Definition 3.2 from [1])
|
|
//
|
|
// alpha <= e = e_c + e_w + q <= gamma
|
|
//
|
|
// or
|
|
//
|
|
// f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
|
|
// <= f_c * f_w * 2^gamma
|
|
//
|
|
// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
|
|
//
|
|
// 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
|
|
//
|
|
// or
|
|
//
|
|
// 2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
|
|
//
|
|
// The choice of (alpha,gamma) determines the size of the table and the form of
|
|
// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
|
|
// in practice:
|
|
//
|
|
// The idea is to cut the number c * w = f * 2^e into two parts, which can be
|
|
// processed independently: An integral part p1, and a fractional part p2:
|
|
//
|
|
// f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
|
|
// = (f div 2^-e) + (f mod 2^-e) * 2^e
|
|
// = p1 + p2 * 2^e
|
|
//
|
|
// The conversion of p1 into decimal form requires a series of divisions and
|
|
// modulos by (a power of) 10. These operations are faster for 32-bit than for
|
|
// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
|
|
// achieved by choosing
|
|
//
|
|
// -e >= 32 or e <= -32 := gamma
|
|
//
|
|
// In order to convert the fractional part
|
|
//
|
|
// p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
|
|
//
|
|
// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
|
|
// d[-i] are extracted in order:
|
|
//
|
|
// (10 * p2) div 2^-e = d[-1]
|
|
// (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
|
|
//
|
|
// The multiplication by 10 must not overflow. It is sufficient to choose
|
|
//
|
|
// 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
|
|
//
|
|
// Since p2 = f mod 2^-e < 2^-e,
|
|
//
|
|
// -e <= 60 or e >= -60 := alpha
|
|
|
|
constexpr int kAlpha = -60;
|
|
constexpr int kGamma = -32;
|
|
|
|
struct cached_power // c = f * 2^e ~= 10^k
|
|
{
|
|
std::uint64_t f;
|
|
int e;
|
|
int k;
|
|
};
|
|
|
|
/*!
|
|
For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
|
|
power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
|
|
satisfies (Definition 3.2 from [1])
|
|
|
|
alpha <= e_c + e + q <= gamma.
|
|
*/
|
|
inline cached_power get_cached_power_for_binary_exponent(int e)
|
|
{
|
|
// Now
|
|
//
|
|
// alpha <= e_c + e + q <= gamma (1)
|
|
// ==> f_c * 2^alpha <= c * 2^e * 2^q
|
|
//
|
|
// and since the c's are normalized, 2^(q-1) <= f_c,
|
|
//
|
|
// ==> 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
|
|
//
|
|
// k = ceil( log_10( 2^(alpha - e - 1) ) )
|
|
// = ceil( (alpha - e - 1) * log_10(2) )
|
|
//
|
|
// From the paper:
|
|
// "In theory the result of the procedure could be wrong since c is rounded,
|
|
// and the computation itself is approximated [...]. In practice, however,
|
|
// this simple function is sufficient."
|
|
//
|
|
// For IEEE double precision floating-point numbers converted into
|
|
// normalized diyfp's w = f * 2^e, with q = 64,
|
|
//
|
|
// e >= -1022 (min IEEE exponent)
|
|
// -52 (p - 1)
|
|
// -52 (p - 1, possibly normalize denormal IEEE numbers)
|
|
// -11 (normalize the diyfp)
|
|
// = -1137
|
|
//
|
|
// and
|
|
//
|
|
// e <= +1023 (max IEEE exponent)
|
|
// -52 (p - 1)
|
|
// -11 (normalize the diyfp)
|
|
// = 960
|
|
//
|
|
// This binary exponent range [-1137,960] results in a decimal exponent
|
|
// range [-307,324]. One does not need to store a cached power for each
|
|
// k in this range. For each such k it suffices to find a cached power
|
|
// such that the exponent of the product lies in [alpha,gamma].
|
|
// This implies that the difference of the decimal exponents of adjacent
|
|
// table entries must be less than or equal to
|
|
//
|
|
// floor( (gamma - alpha) * log_10(2) ) = 8.
|
|
//
|
|
// (A smaller distance gamma-alpha would require a larger table.)
|
|
|
|
// NB:
|
|
// Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
|
|
|
|
constexpr int kCachedPowersMinDecExp = -300;
|
|
constexpr int kCachedPowersDecStep = 8;
|
|
|
|
static constexpr std::array<cached_power, 79> kCachedPowers =
|
|
{
|
|
{
|
|
{ 0xAB70FE17C79AC6CA, -1060, -300 },
|
|
{ 0xFF77B1FCBEBCDC4F, -1034, -292 },
|
|
{ 0xBE5691EF416BD60C, -1007, -284 },
|
|
{ 0x8DD01FAD907FFC3C, -980, -276 },
|
|
{ 0xD3515C2831559A83, -954, -268 },
|
|
{ 0x9D71AC8FADA6C9B5, -927, -260 },
|
|
{ 0xEA9C227723EE8BCB, -901, -252 },
|
|
{ 0xAECC49914078536D, -874, -244 },
|
|
{ 0x823C12795DB6CE57, -847, -236 },
|
|
{ 0xC21094364DFB5637, -821, -228 },
|
|
{ 0x9096EA6F3848984F, -794, -220 },
|
|
{ 0xD77485CB25823AC7, -768, -212 },
|
|
{ 0xA086CFCD97BF97F4, -741, -204 },
|
|
{ 0xEF340A98172AACE5, -715, -196 },
|
|
{ 0xB23867FB2A35B28E, -688, -188 },
|
|
{ 0x84C8D4DFD2C63F3B, -661, -180 },
|
|
{ 0xC5DD44271AD3CDBA, -635, -172 },
|
|
{ 0x936B9FCEBB25C996, -608, -164 },
|
|
{ 0xDBAC6C247D62A584, -582, -156 },
|
|
{ 0xA3AB66580D5FDAF6, -555, -148 },
|
|
{ 0xF3E2F893DEC3F126, -529, -140 },
|
|
{ 0xB5B5ADA8AAFF80B8, -502, -132 },
|
|
{ 0x87625F056C7C4A8B, -475, -124 },
|
|
{ 0xC9BCFF6034C13053, -449, -116 },
|
|
{ 0x964E858C91BA2655, -422, -108 },
|
|
{ 0xDFF9772470297EBD, -396, -100 },
|
|
{ 0xA6DFBD9FB8E5B88F, -369, -92 },
|
|
{ 0xF8A95FCF88747D94, -343, -84 },
|
|
{ 0xB94470938FA89BCF, -316, -76 },
|
|
{ 0x8A08F0F8BF0F156B, -289, -68 },
|
|
{ 0xCDB02555653131B6, -263, -60 },
|
|
{ 0x993FE2C6D07B7FAC, -236, -52 },
|
|
{ 0xE45C10C42A2B3B06, -210, -44 },
|
|
{ 0xAA242499697392D3, -183, -36 },
|
|
{ 0xFD87B5F28300CA0E, -157, -28 },
|
|
{ 0xBCE5086492111AEB, -130, -20 },
|
|
{ 0x8CBCCC096F5088CC, -103, -12 },
|
|
{ 0xD1B71758E219652C, -77, -4 },
|
|
{ 0x9C40000000000000, -50, 4 },
|
|
{ 0xE8D4A51000000000, -24, 12 },
|
|
{ 0xAD78EBC5AC620000, 3, 20 },
|
|
{ 0x813F3978F8940984, 30, 28 },
|
|
{ 0xC097CE7BC90715B3, 56, 36 },
|
|
{ 0x8F7E32CE7BEA5C70, 83, 44 },
|
|
{ 0xD5D238A4ABE98068, 109, 52 },
|
|
{ 0x9F4F2726179A2245, 136, 60 },
|
|
{ 0xED63A231D4C4FB27, 162, 68 },
|
|
{ 0xB0DE65388CC8ADA8, 189, 76 },
|
|
{ 0x83C7088E1AAB65DB, 216, 84 },
|
|
{ 0xC45D1DF942711D9A, 242, 92 },
|
|
{ 0x924D692CA61BE758, 269, 100 },
|
|
{ 0xDA01EE641A708DEA, 295, 108 },
|
|
{ 0xA26DA3999AEF774A, 322, 116 },
|
|
{ 0xF209787BB47D6B85, 348, 124 },
|
|
{ 0xB454E4A179DD1877, 375, 132 },
|
|
{ 0x865B86925B9BC5C2, 402, 140 },
|
|
{ 0xC83553C5C8965D3D, 428, 148 },
|
|
{ 0x952AB45CFA97A0B3, 455, 156 },
|
|
{ 0xDE469FBD99A05FE3, 481, 164 },
|
|
{ 0xA59BC234DB398C25, 508, 172 },
|
|
{ 0xF6C69A72A3989F5C, 534, 180 },
|
|
{ 0xB7DCBF5354E9BECE, 561, 188 },
|
|
{ 0x88FCF317F22241E2, 588, 196 },
|
|
{ 0xCC20CE9BD35C78A5, 614, 204 },
|
|
{ 0x98165AF37B2153DF, 641, 212 },
|
|
{ 0xE2A0B5DC971F303A, 667, 220 },
|
|
{ 0xA8D9D1535CE3B396, 694, 228 },
|
|
{ 0xFB9B7CD9A4A7443C, 720, 236 },
|
|
{ 0xBB764C4CA7A44410, 747, 244 },
|
|
{ 0x8BAB8EEFB6409C1A, 774, 252 },
|
|
{ 0xD01FEF10A657842C, 800, 260 },
|
|
{ 0x9B10A4E5E9913129, 827, 268 },
|
|
{ 0xE7109BFBA19C0C9D, 853, 276 },
|
|
{ 0xAC2820D9623BF429, 880, 284 },
|
|
{ 0x80444B5E7AA7CF85, 907, 292 },
|
|
{ 0xBF21E44003ACDD2D, 933, 300 },
|
|
{ 0x8E679C2F5E44FF8F, 960, 308 },
|
|
{ 0xD433179D9C8CB841, 986, 316 },
|
|
{ 0x9E19DB92B4E31BA9, 1013, 324 },
|
|
}
|
|
};
|
|
|
|
// This computation gives exactly the same results for k as
|
|
// k = ceil((kAlpha - e - 1) * 0.30102999566398114)
|
|
// for |e| <= 1500, but doesn't require floating-point operations.
|
|
// NB: log_10(2) ~= 78913 / 2^18
|
|
JSON_ASSERT(e >= -1500);
|
|
JSON_ASSERT(e <= 1500);
|
|
const int f = kAlpha - e - 1;
|
|
const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
|
|
|
|
const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
|
|
JSON_ASSERT(index >= 0);
|
|
JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
|
|
|
|
const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
|
|
JSON_ASSERT(kAlpha <= cached.e + e + 64);
|
|
JSON_ASSERT(kGamma >= cached.e + e + 64);
|
|
|
|
return cached;
|
|
}
|
|
|
|
/*!
|
|
For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
|
|
For n == 0, returns 1 and sets pow10 := 1.
|
|
*/
|
|
inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
|
|
{
|
|
// LCOV_EXCL_START
|
|
if (n >= 1000000000)
|
|
{
|
|
pow10 = 1000000000;
|
|
return 10;
|
|
}
|
|
// LCOV_EXCL_STOP
|
|
if (n >= 100000000)
|
|
{
|
|
pow10 = 100000000;
|
|
return 9;
|
|
}
|
|
if (n >= 10000000)
|
|
{
|
|
pow10 = 10000000;
|
|
return 8;
|
|
}
|
|
if (n >= 1000000)
|
|
{
|
|
pow10 = 1000000;
|
|
return 7;
|
|
}
|
|
if (n >= 100000)
|
|
{
|
|
pow10 = 100000;
|
|
return 6;
|
|
}
|
|
if (n >= 10000)
|
|
{
|
|
pow10 = 10000;
|
|
return 5;
|
|
}
|
|
if (n >= 1000)
|
|
{
|
|
pow10 = 1000;
|
|
return 4;
|
|
}
|
|
if (n >= 100)
|
|
{
|
|
pow10 = 100;
|
|
return 3;
|
|
}
|
|
if (n >= 10)
|
|
{
|
|
pow10 = 10;
|
|
return 2;
|
|
}
|
|
|
|
pow10 = 1;
|
|
return 1;
|
|
}
|
|
|
|
inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
|
|
std::uint64_t rest, std::uint64_t ten_k)
|
|
{
|
|
JSON_ASSERT(len >= 1);
|
|
JSON_ASSERT(dist <= delta);
|
|
JSON_ASSERT(rest <= delta);
|
|
JSON_ASSERT(ten_k > 0);
|
|
|
|
// <--------------------------- delta ---->
|
|
// <---- dist --------->
|
|
// --------------[------------------+-------------------]--------------
|
|
// M- w M+
|
|
//
|
|
// ten_k
|
|
// <------>
|
|
// <---- rest ---->
|
|
// --------------[------------------+----+--------------]--------------
|
|
// w V
|
|
// = buf * 10^k
|
|
//
|
|
// ten_k represents a unit-in-the-last-place in the decimal representation
|
|
// stored in buf.
|
|
// Decrement buf by ten_k while this takes buf closer to w.
|
|
|
|
// The tests are written in this order to avoid overflow in unsigned
|
|
// integer arithmetic.
|
|
|
|
while (rest < dist
|
|
&& delta - rest >= ten_k
|
|
&& (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
|
|
{
|
|
JSON_ASSERT(buf[len - 1] != '0');
|
|
buf[len - 1]--;
|
|
rest += ten_k;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
|
|
M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
|
|
*/
|
|
inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
|
|
diyfp M_minus, diyfp w, diyfp M_plus)
|
|
{
|
|
static_assert(kAlpha >= -60, "internal error");
|
|
static_assert(kGamma <= -32, "internal error");
|
|
|
|
// Generates the digits (and the exponent) of a decimal floating-point
|
|
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
|
|
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
|
|
//
|
|
// <--------------------------- delta ---->
|
|
// <---- dist --------->
|
|
// --------------[------------------+-------------------]--------------
|
|
// M- w M+
|
|
//
|
|
// Grisu2 generates the digits of M+ from left to right and stops as soon as
|
|
// V is in [M-,M+].
|
|
|
|
JSON_ASSERT(M_plus.e >= kAlpha);
|
|
JSON_ASSERT(M_plus.e <= kGamma);
|
|
|
|
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
|
|
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
|
|
|
|
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
|
|
//
|
|
// M+ = f * 2^e
|
|
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
|
|
// = ((p1 ) * 2^-e + (p2 )) * 2^e
|
|
// = p1 + p2 * 2^e
|
|
|
|
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
|
|
|
|
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
|
|
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
|
|
|
|
// 1)
|
|
//
|
|
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
|
|
|
|
JSON_ASSERT(p1 > 0);
|
|
|
|
std::uint32_t pow10{};
|
|
const int k = find_largest_pow10(p1, pow10);
|
|
|
|
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
|
|
//
|
|
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
|
|
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
|
|
//
|
|
// M+ = p1 + p2 * 2^e
|
|
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
|
|
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
|
|
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
|
|
//
|
|
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
|
|
//
|
|
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
|
|
//
|
|
// but stop as soon as
|
|
//
|
|
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
|
|
|
|
int n = k;
|
|
while (n > 0)
|
|
{
|
|
// Invariants:
|
|
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
|
|
// pow10 = 10^(n-1) <= p1 < 10^n
|
|
//
|
|
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
|
|
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
|
|
//
|
|
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
|
|
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
|
|
//
|
|
JSON_ASSERT(d <= 9);
|
|
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
|
|
//
|
|
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
|
|
//
|
|
p1 = r;
|
|
n--;
|
|
//
|
|
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
|
|
// pow10 = 10^n
|
|
//
|
|
|
|
// Now check if enough digits have been generated.
|
|
// Compute
|
|
//
|
|
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
|
|
//
|
|
// Note:
|
|
// Since rest and delta share the same exponent e, it suffices to
|
|
// compare the significands.
|
|
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
|
|
if (rest <= delta)
|
|
{
|
|
// V = buffer * 10^n, with M- <= V <= M+.
|
|
|
|
decimal_exponent += n;
|
|
|
|
// We may now just stop. But instead look if the buffer could be
|
|
// decremented to bring V closer to w.
|
|
//
|
|
// pow10 = 10^n is now 1 ulp in the decimal representation V.
|
|
// The rounding procedure works with diyfp's with an implicit
|
|
// exponent of e.
|
|
//
|
|
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
|
|
//
|
|
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
|
|
grisu2_round(buffer, length, dist, delta, rest, ten_n);
|
|
|
|
return;
|
|
}
|
|
|
|
pow10 /= 10;
|
|
//
|
|
// pow10 = 10^(n-1) <= p1 < 10^n
|
|
// Invariants restored.
|
|
}
|
|
|
|
// 2)
|
|
//
|
|
// The digits of the integral part have been generated:
|
|
//
|
|
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
|
|
// = buffer + p2 * 2^e
|
|
//
|
|
// Now generate the digits of the fractional part p2 * 2^e.
|
|
//
|
|
// Note:
|
|
// No decimal point is generated: the exponent is adjusted instead.
|
|
//
|
|
// p2 actually represents the fraction
|
|
//
|
|
// p2 * 2^e
|
|
// = p2 / 2^-e
|
|
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
|
|
//
|
|
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
|
|
//
|
|
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
|
|
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
|
|
//
|
|
// using
|
|
//
|
|
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
|
|
// = ( d) * 2^-e + ( r)
|
|
//
|
|
// or
|
|
// 10^m * p2 * 2^e = d + r * 2^e
|
|
//
|
|
// i.e.
|
|
//
|
|
// M+ = buffer + p2 * 2^e
|
|
// = buffer + 10^-m * (d + r * 2^e)
|
|
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
|
|
//
|
|
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
|
|
|
|
JSON_ASSERT(p2 > delta);
|
|
|
|
int m = 0;
|
|
for (;;)
|
|
{
|
|
// Invariant:
|
|
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
|
|
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
|
|
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
|
|
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
|
|
//
|
|
JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
|
|
p2 *= 10;
|
|
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
|
|
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
|
|
//
|
|
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
|
|
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
|
|
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
|
|
//
|
|
JSON_ASSERT(d <= 9);
|
|
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
|
|
//
|
|
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
|
|
//
|
|
p2 = r;
|
|
m++;
|
|
//
|
|
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
|
|
// Invariant restored.
|
|
|
|
// Check if enough digits have been generated.
|
|
//
|
|
// 10^-m * p2 * 2^e <= delta * 2^e
|
|
// p2 * 2^e <= 10^m * delta * 2^e
|
|
// p2 <= 10^m * delta
|
|
delta *= 10;
|
|
dist *= 10;
|
|
if (p2 <= delta)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// V = buffer * 10^-m, with M- <= V <= M+.
|
|
|
|
decimal_exponent -= m;
|
|
|
|
// 1 ulp in the decimal representation is now 10^-m.
|
|
// Since delta and dist are now scaled by 10^m, we need to do the
|
|
// same with ulp in order to keep the units in sync.
|
|
//
|
|
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
|
|
//
|
|
const std::uint64_t ten_m = one.f;
|
|
grisu2_round(buffer, length, dist, delta, p2, ten_m);
|
|
|
|
// By construction this algorithm generates the shortest possible decimal
|
|
// number (Loitsch, Theorem 6.2) which rounds back to w.
|
|
// For an input number of precision p, at least
|
|
//
|
|
// N = 1 + ceil(p * log_10(2))
|
|
//
|
|
// decimal digits are sufficient to identify all binary floating-point
|
|
// numbers (Matula, "In-and-Out conversions").
|
|
// This implies that the algorithm does not produce more than N decimal
|
|
// digits.
|
|
//
|
|
// N = 17 for p = 53 (IEEE double precision)
|
|
// N = 9 for p = 24 (IEEE single precision)
|
|
}
|
|
|
|
/*!
|
|
v = buf * 10^decimal_exponent
|
|
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)
|
|
{
|
|
JSON_ASSERT(m_plus.e == m_minus.e);
|
|
JSON_ASSERT(m_plus.e == v.e);
|
|
|
|
// --------(-----------------------+-----------------------)-------- (A)
|
|
// m- v m+
|
|
//
|
|
// --------------------(-----------+-----------------------)-------- (B)
|
|
// m- v m+
|
|
//
|
|
// First scale v (and m- and m+) such that the exponent is in the range
|
|
// [alpha, gamma].
|
|
|
|
const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
|
|
|
|
const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
|
|
|
|
// The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
|
|
const diyfp w = diyfp::mul(v, c_minus_k);
|
|
const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
|
|
const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
|
|
|
|
// ----(---+---)---------------(---+---)---------------(---+---)----
|
|
// w- w w+
|
|
// = c*m- = c*v = c*m+
|
|
//
|
|
// diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
|
|
// w+ are now off by a small amount.
|
|
// In fact:
|
|
//
|
|
// w - v * 10^k < 1 ulp
|
|
//
|
|
// To account for this inaccuracy, add resp. subtract 1 ulp.
|
|
//
|
|
// --------+---[---------------(---+---)---------------]---+--------
|
|
// w- M- w M+ w+
|
|
//
|
|
// Now any number in [M-, M+] (bounds included) will round to w when input,
|
|
// regardless of how the input rounding algorithm breaks ties.
|
|
//
|
|
// And digit_gen generates the shortest possible such number in [M-, M+].
|
|
// Note that this does not mean that Grisu2 always generates the shortest
|
|
// possible number in the interval (m-, m+).
|
|
const diyfp M_minus(w_minus.f + 1, w_minus.e);
|
|
const diyfp M_plus (w_plus.f - 1, w_plus.e );
|
|
|
|
decimal_exponent = -cached.k; // = -(-k) = k
|
|
|
|
grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
|
|
}
|
|
|
|
/*!
|
|
v = buf * 10^decimal_exponent
|
|
len is the length of the buffer (number of decimal digits)
|
|
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,
|
|
"internal error: not enough precision");
|
|
|
|
JSON_ASSERT(std::isfinite(value));
|
|
JSON_ASSERT(value > 0);
|
|
|
|
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
|
|
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
|
|
// decimal representations are not exactly "short".
|
|
//
|
|
// The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
|
|
// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
|
|
// and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
|
|
// does.
|
|
// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
|
|
// representation using the corresponding std::from_chars function recovers value exactly". That
|
|
// indicates that single precision floating-point numbers should be recovered using
|
|
// 'std::strtof'.
|
|
//
|
|
// NB: If the neighbors are computed for single-precision numbers, there is a single float
|
|
// (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
|
|
// value is off by 1 ulp.
|
|
#if 0
|
|
const boundaries w = compute_boundaries(static_cast<double>(value));
|
|
#else
|
|
const boundaries w = compute_boundaries(value);
|
|
#endif
|
|
|
|
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
|
|
}
|
|
|
|
/*!
|
|
@brief appends a decimal representation of e to buf
|
|
@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)
|
|
{
|
|
JSON_ASSERT(e > -1000);
|
|
JSON_ASSERT(e < 1000);
|
|
|
|
if (e < 0)
|
|
{
|
|
e = -e;
|
|
*buf++ = '-';
|
|
}
|
|
else
|
|
{
|
|
*buf++ = '+';
|
|
}
|
|
|
|
auto k = static_cast<std::uint32_t>(e);
|
|
if (k < 10)
|
|
{
|
|
// Always print at least two digits in the exponent.
|
|
// This is for compatibility with printf("%g").
|
|
*buf++ = '0';
|
|
*buf++ = static_cast<char>('0' + k);
|
|
}
|
|
else if (k < 100)
|
|
{
|
|
*buf++ = static_cast<char>('0' + k / 10);
|
|
k %= 10;
|
|
*buf++ = static_cast<char>('0' + k);
|
|
}
|
|
else
|
|
{
|
|
*buf++ = static_cast<char>('0' + k / 100);
|
|
k %= 100;
|
|
*buf++ = static_cast<char>('0' + k / 10);
|
|
k %= 10;
|
|
*buf++ = static_cast<char>('0' + k);
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
/*!
|
|
@brief prettify v = buf * 10^decimal_exponent
|
|
|
|
If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
|
|
notation. Otherwise it will be printed in exponential notation.
|
|
|
|
@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)
|
|
{
|
|
JSON_ASSERT(min_exp < 0);
|
|
JSON_ASSERT(max_exp > 0);
|
|
|
|
const int k = len;
|
|
const int n = len + decimal_exponent;
|
|
|
|
// v = buf * 10^(n-k)
|
|
// k is the length of the buffer (number of decimal digits)
|
|
// n is the position of the decimal point relative to the start of the buffer.
|
|
|
|
if (k <= n && n <= max_exp)
|
|
{
|
|
// digits[000]
|
|
// len <= max_exp + 2
|
|
|
|
std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
|
|
// Make it look like a floating-point number (#362, #378)
|
|
buf[n + 0] = '.';
|
|
buf[n + 1] = '0';
|
|
return buf + (static_cast<size_t>(n) + 2);
|
|
}
|
|
|
|
if (0 < n && n <= max_exp)
|
|
{
|
|
// dig.its
|
|
// len <= max_digits10 + 1
|
|
|
|
JSON_ASSERT(k > n);
|
|
|
|
std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
|
|
buf[n] = '.';
|
|
return buf + (static_cast<size_t>(k) + 1U);
|
|
}
|
|
|
|
if (min_exp < n && n <= 0)
|
|
{
|
|
// 0.[000]digits
|
|
// len <= 2 + (-min_exp - 1) + max_digits10
|
|
|
|
std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
|
|
buf[0] = '0';
|
|
buf[1] = '.';
|
|
std::memset(buf + 2, '0', static_cast<size_t>(-n));
|
|
return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
|
|
}
|
|
|
|
if (k == 1)
|
|
{
|
|
// dE+123
|
|
// len <= 1 + 5
|
|
|
|
buf += 1;
|
|
}
|
|
else
|
|
{
|
|
// d.igitsE+123
|
|
// len <= max_digits10 + 1 + 5
|
|
|
|
std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
|
|
buf[1] = '.';
|
|
buf += 1 + static_cast<size_t>(k);
|
|
}
|
|
|
|
*buf++ = 'e';
|
|
return append_exponent(buf, n - 1);
|
|
}
|
|
|
|
} // namespace dtoa_impl
|
|
|
|
/*!
|
|
@brief generates a decimal representation of the floating-point number value in [first, last).
|
|
|
|
The format of the resulting decimal representation is similar to printf's %g
|
|
format. Returns an iterator pointing past-the-end of the decimal representation.
|
|
|
|
@note The input number must be finite, i.e. NaN's and Inf's are not supported.
|
|
@note The buffer must be large enough.
|
|
@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
|
|
JSON_ASSERT(std::isfinite(value));
|
|
|
|
// Use signbit(value) instead of (value < 0) since signbit works for -0.
|
|
if (std::signbit(value))
|
|
{
|
|
value = -value;
|
|
*first++ = '-';
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wfloat-equal"
|
|
#endif
|
|
if (value == 0) // +-0
|
|
{
|
|
*first++ = '0';
|
|
// Make it look like a floating-point number (#362, #378)
|
|
*first++ = '.';
|
|
*first++ = '0';
|
|
return first;
|
|
}
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
|
|
|
|
// Compute v = buffer * 10^decimal_exponent.
|
|
// The decimal digits are stored in the buffer, which needs to be interpreted
|
|
// as an unsigned decimal integer.
|
|
// len is the length of the buffer, i.e. the number of decimal digits.
|
|
int len = 0;
|
|
int decimal_exponent = 0;
|
|
dtoa_impl::grisu2(first, len, decimal_exponent, value);
|
|
|
|
JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
|
|
|
|
// Format the buffer like printf("%.*g", prec, value)
|
|
constexpr int kMinExp = -4;
|
|
// Use digits10 here to increase compatibility with version 2.
|
|
constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
|
|
|
|
JSON_ASSERT(last - first >= kMaxExp + 2);
|
|
JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
|
|
JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
|
|
|
|
return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
|
|
}
|
|
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/exceptions.hpp>
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
// #include <nlohmann/detail/meta/cpp_future.hpp>
|
|
|
|
// #include <nlohmann/detail/output/binary_writer.hpp>
|
|
|
|
// #include <nlohmann/detail/output/output_adapters.hpp>
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
namespace detail
|
|
{
|
|
///////////////////
|
|
// serialization //
|
|
///////////////////
|
|
|
|
/// how to treat decoding errors
|
|
enum class error_handler_t
|
|
{
|
|
strict, ///< throw a type_error exception in case of invalid UTF-8
|
|
replace, ///< replace invalid UTF-8 sequences with U+FFFD
|
|
ignore ///< ignore invalid UTF-8 sequences
|
|
};
|
|
|
|
template<typename BasicJsonType>
|
|
class serializer
|
|
{
|
|
using string_t = typename BasicJsonType::string_t;
|
|
using number_float_t = typename BasicJsonType::number_float_t;
|
|
using number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using binary_char_t = typename BasicJsonType::binary_t::value_type;
|
|
static constexpr std::uint8_t UTF8_ACCEPT = 0;
|
|
static constexpr std::uint8_t UTF8_REJECT = 1;
|
|
|
|
public:
|
|
/*!
|
|
@param[in] s output stream to serialize to
|
|
@param[in] ichar indentation character to use
|
|
@param[in] error_handler_ how to react on decoding errors
|
|
*/
|
|
serializer(output_adapter_t<char> s, const char ichar,
|
|
error_handler_t error_handler_ = error_handler_t::strict)
|
|
: o(std::move(s))
|
|
, loc(std::localeconv())
|
|
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
|
|
, decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
|
|
, indent_char(ichar)
|
|
, indent_string(512, indent_char)
|
|
, error_handler(error_handler_)
|
|
{}
|
|
|
|
// delete because of pointer members
|
|
serializer(const serializer&) = delete;
|
|
serializer& operator=(const serializer&) = delete;
|
|
serializer(serializer&&) = delete;
|
|
serializer& operator=(serializer&&) = delete;
|
|
~serializer() = default;
|
|
|
|
/*!
|
|
@brief internal implementation of the serialization function
|
|
|
|
This function is called by the public member function dump and organizes
|
|
the serialization internally. The indentation level is propagated as
|
|
additional parameter. In case of arrays and objects, the function is
|
|
called recursively.
|
|
|
|
- strings and object keys are escaped using `escape_string()`
|
|
- integer numbers are converted implicitly via `operator<<`
|
|
- floating-point numbers are converted to a string using `"%g"` format
|
|
- binary values are serialized as objects containing the subtype and the
|
|
byte array
|
|
|
|
@param[in] val value to serialize
|
|
@param[in] pretty_print whether the output shall be pretty-printed
|
|
@param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
|
|
in the output are escaped with `\uXXXX` sequences, and the result consists
|
|
of ASCII characters only.
|
|
@param[in] indent_step the indent level
|
|
@param[in] current_indent the current indent level (only used internally)
|
|
*/
|
|
void dump(const BasicJsonType& val,
|
|
const bool pretty_print,
|
|
const bool ensure_ascii,
|
|
const unsigned int indent_step,
|
|
const unsigned int current_indent = 0)
|
|
{
|
|
switch (val.m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
if (val.m_value.object->empty())
|
|
{
|
|
o->write_characters("{}", 2);
|
|
return;
|
|
}
|
|
|
|
if (pretty_print)
|
|
{
|
|
o->write_characters("{\n", 2);
|
|
|
|
// variable to hold indentation for recursive calls
|
|
const auto new_indent = current_indent + indent_step;
|
|
if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
|
|
{
|
|
indent_string.resize(indent_string.size() * 2, ' ');
|
|
}
|
|
|
|
// first n-1 elements
|
|
auto i = val.m_value.object->cbegin();
|
|
for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
|
|
{
|
|
o->write_characters(indent_string.c_str(), new_indent);
|
|
o->write_character('\"');
|
|
dump_escaped(i->first, ensure_ascii);
|
|
o->write_characters("\": ", 3);
|
|
dump(i->second, true, ensure_ascii, indent_step, new_indent);
|
|
o->write_characters(",\n", 2);
|
|
}
|
|
|
|
// last element
|
|
JSON_ASSERT(i != val.m_value.object->cend());
|
|
JSON_ASSERT(std::next(i) == val.m_value.object->cend());
|
|
o->write_characters(indent_string.c_str(), new_indent);
|
|
o->write_character('\"');
|
|
dump_escaped(i->first, ensure_ascii);
|
|
o->write_characters("\": ", 3);
|
|
dump(i->second, true, ensure_ascii, indent_step, new_indent);
|
|
|
|
o->write_character('\n');
|
|
o->write_characters(indent_string.c_str(), current_indent);
|
|
o->write_character('}');
|
|
}
|
|
else
|
|
{
|
|
o->write_character('{');
|
|
|
|
// first n-1 elements
|
|
auto i = val.m_value.object->cbegin();
|
|
for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
|
|
{
|
|
o->write_character('\"');
|
|
dump_escaped(i->first, ensure_ascii);
|
|
o->write_characters("\":", 2);
|
|
dump(i->second, false, ensure_ascii, indent_step, current_indent);
|
|
o->write_character(',');
|
|
}
|
|
|
|
// last element
|
|
JSON_ASSERT(i != val.m_value.object->cend());
|
|
JSON_ASSERT(std::next(i) == val.m_value.object->cend());
|
|
o->write_character('\"');
|
|
dump_escaped(i->first, ensure_ascii);
|
|
o->write_characters("\":", 2);
|
|
dump(i->second, false, ensure_ascii, indent_step, current_indent);
|
|
|
|
o->write_character('}');
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
if (val.m_value.array->empty())
|
|
{
|
|
o->write_characters("[]", 2);
|
|
return;
|
|
}
|
|
|
|
if (pretty_print)
|
|
{
|
|
o->write_characters("[\n", 2);
|
|
|
|
// variable to hold indentation for recursive calls
|
|
const auto new_indent = current_indent + indent_step;
|
|
if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
|
|
{
|
|
indent_string.resize(indent_string.size() * 2, ' ');
|
|
}
|
|
|
|
// first n-1 elements
|
|
for (auto i = val.m_value.array->cbegin();
|
|
i != val.m_value.array->cend() - 1; ++i)
|
|
{
|
|
o->write_characters(indent_string.c_str(), new_indent);
|
|
dump(*i, true, ensure_ascii, indent_step, new_indent);
|
|
o->write_characters(",\n", 2);
|
|
}
|
|
|
|
// last element
|
|
JSON_ASSERT(!val.m_value.array->empty());
|
|
o->write_characters(indent_string.c_str(), new_indent);
|
|
dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
|
|
|
|
o->write_character('\n');
|
|
o->write_characters(indent_string.c_str(), current_indent);
|
|
o->write_character(']');
|
|
}
|
|
else
|
|
{
|
|
o->write_character('[');
|
|
|
|
// first n-1 elements
|
|
for (auto i = val.m_value.array->cbegin();
|
|
i != val.m_value.array->cend() - 1; ++i)
|
|
{
|
|
dump(*i, false, ensure_ascii, indent_step, current_indent);
|
|
o->write_character(',');
|
|
}
|
|
|
|
// last element
|
|
JSON_ASSERT(!val.m_value.array->empty());
|
|
dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
|
|
|
|
o->write_character(']');
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
o->write_character('\"');
|
|
dump_escaped(*val.m_value.string, ensure_ascii);
|
|
o->write_character('\"');
|
|
return;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
if (pretty_print)
|
|
{
|
|
o->write_characters("{\n", 2);
|
|
|
|
// variable to hold indentation for recursive calls
|
|
const auto new_indent = current_indent + indent_step;
|
|
if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
|
|
{
|
|
indent_string.resize(indent_string.size() * 2, ' ');
|
|
}
|
|
|
|
o->write_characters(indent_string.c_str(), new_indent);
|
|
|
|
o->write_characters("\"bytes\": [", 10);
|
|
|
|
if (!val.m_value.binary->empty())
|
|
{
|
|
for (auto i = val.m_value.binary->cbegin();
|
|
i != val.m_value.binary->cend() - 1; ++i)
|
|
{
|
|
dump_integer(*i);
|
|
o->write_characters(", ", 2);
|
|
}
|
|
dump_integer(val.m_value.binary->back());
|
|
}
|
|
|
|
o->write_characters("],\n", 3);
|
|
o->write_characters(indent_string.c_str(), new_indent);
|
|
|
|
o->write_characters("\"subtype\": ", 11);
|
|
if (val.m_value.binary->has_subtype())
|
|
{
|
|
dump_integer(val.m_value.binary->subtype());
|
|
}
|
|
else
|
|
{
|
|
o->write_characters("null", 4);
|
|
}
|
|
o->write_character('\n');
|
|
o->write_characters(indent_string.c_str(), current_indent);
|
|
o->write_character('}');
|
|
}
|
|
else
|
|
{
|
|
o->write_characters("{\"bytes\":[", 10);
|
|
|
|
if (!val.m_value.binary->empty())
|
|
{
|
|
for (auto i = val.m_value.binary->cbegin();
|
|
i != val.m_value.binary->cend() - 1; ++i)
|
|
{
|
|
dump_integer(*i);
|
|
o->write_character(',');
|
|
}
|
|
dump_integer(val.m_value.binary->back());
|
|
}
|
|
|
|
o->write_characters("],\"subtype\":", 12);
|
|
if (val.m_value.binary->has_subtype())
|
|
{
|
|
dump_integer(val.m_value.binary->subtype());
|
|
o->write_character('}');
|
|
}
|
|
else
|
|
{
|
|
o->write_characters("null}", 5);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
if (val.m_value.boolean)
|
|
{
|
|
o->write_characters("true", 4);
|
|
}
|
|
else
|
|
{
|
|
o->write_characters("false", 5);
|
|
}
|
|
return;
|
|
}
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
dump_integer(val.m_value.number_integer);
|
|
return;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
dump_integer(val.m_value.number_unsigned);
|
|
return;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
dump_float(val.m_value.number_float);
|
|
return;
|
|
}
|
|
|
|
case value_t::discarded:
|
|
{
|
|
o->write_characters("<discarded>", 11);
|
|
return;
|
|
}
|
|
|
|
case value_t::null:
|
|
{
|
|
o->write_characters("null", 4);
|
|
return;
|
|
}
|
|
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
/*!
|
|
@brief dump escaped string
|
|
|
|
Escape a string by replacing certain special characters by a sequence of an
|
|
escape character (backslash) and another character and other control
|
|
characters by a sequence of "\u" followed by a four-digit hex
|
|
representation. The escaped string is written to output stream @a o.
|
|
|
|
@param[in] s the string to escape
|
|
@param[in] ensure_ascii whether to escape non-ASCII characters with
|
|
\uXXXX sequences
|
|
|
|
@complexity Linear in the length of string @a s.
|
|
*/
|
|
void dump_escaped(const string_t& s, const bool ensure_ascii)
|
|
{
|
|
std::uint32_t codepoint{};
|
|
std::uint8_t state = UTF8_ACCEPT;
|
|
std::size_t bytes = 0; // number of bytes written to string_buffer
|
|
|
|
// number of bytes written at the point of the last valid byte
|
|
std::size_t bytes_after_last_accept = 0;
|
|
std::size_t undumped_chars = 0;
|
|
|
|
for (std::size_t i = 0; i < s.size(); ++i)
|
|
{
|
|
const auto byte = static_cast<std::uint8_t>(s[i]);
|
|
|
|
switch (decode(state, codepoint, byte))
|
|
{
|
|
case UTF8_ACCEPT: // decode found a new code point
|
|
{
|
|
switch (codepoint)
|
|
{
|
|
case 0x08: // backspace
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = 'b';
|
|
break;
|
|
}
|
|
|
|
case 0x09: // horizontal tab
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = 't';
|
|
break;
|
|
}
|
|
|
|
case 0x0A: // newline
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = 'n';
|
|
break;
|
|
}
|
|
|
|
case 0x0C: // formfeed
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = 'f';
|
|
break;
|
|
}
|
|
|
|
case 0x0D: // carriage return
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = 'r';
|
|
break;
|
|
}
|
|
|
|
case 0x22: // quotation mark
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = '\"';
|
|
break;
|
|
}
|
|
|
|
case 0x5C: // reverse solidus
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = '\\';
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
// escape control characters (0x00..0x1F) or, if
|
|
// ensure_ascii parameter is used, non-ASCII characters
|
|
if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
|
|
{
|
|
if (codepoint <= 0xFFFF)
|
|
{
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
|
|
static_cast<std::uint16_t>(codepoint)));
|
|
bytes += 6;
|
|
}
|
|
else
|
|
{
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
|
|
static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
|
|
static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
|
|
bytes += 12;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// copy byte to buffer (all previous bytes
|
|
// been copied have in default case above)
|
|
string_buffer[bytes++] = s[i];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// write buffer and reset index; there must be 13 bytes
|
|
// left, as this is the maximal number of bytes to be
|
|
// written ("\uxxxx\uxxxx\0") for one code point
|
|
if (string_buffer.size() - bytes < 13)
|
|
{
|
|
o->write_characters(string_buffer.data(), bytes);
|
|
bytes = 0;
|
|
}
|
|
|
|
// remember the byte position of this accept
|
|
bytes_after_last_accept = bytes;
|
|
undumped_chars = 0;
|
|
break;
|
|
}
|
|
|
|
case UTF8_REJECT: // decode found invalid UTF-8 byte
|
|
{
|
|
switch (error_handler)
|
|
{
|
|
case error_handler_t::strict:
|
|
{
|
|
std::stringstream ss;
|
|
ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (byte | 0);
|
|
JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str(), BasicJsonType()));
|
|
}
|
|
|
|
case error_handler_t::ignore:
|
|
case error_handler_t::replace:
|
|
{
|
|
// in case we saw this character the first time, we
|
|
// would like to read it again, because the byte
|
|
// may be OK for itself, but just not OK for the
|
|
// previous sequence
|
|
if (undumped_chars > 0)
|
|
{
|
|
--i;
|
|
}
|
|
|
|
// reset length buffer to the last accepted index;
|
|
// thus removing/ignoring the invalid characters
|
|
bytes = bytes_after_last_accept;
|
|
|
|
if (error_handler == error_handler_t::replace)
|
|
{
|
|
// add a replacement character
|
|
if (ensure_ascii)
|
|
{
|
|
string_buffer[bytes++] = '\\';
|
|
string_buffer[bytes++] = 'u';
|
|
string_buffer[bytes++] = 'f';
|
|
string_buffer[bytes++] = 'f';
|
|
string_buffer[bytes++] = 'f';
|
|
string_buffer[bytes++] = 'd';
|
|
}
|
|
else
|
|
{
|
|
string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
|
|
string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
|
|
string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
|
|
}
|
|
|
|
// write buffer and reset index; there must be 13 bytes
|
|
// left, as this is the maximal number of bytes to be
|
|
// written ("\uxxxx\uxxxx\0") for one code point
|
|
if (string_buffer.size() - bytes < 13)
|
|
{
|
|
o->write_characters(string_buffer.data(), bytes);
|
|
bytes = 0;
|
|
}
|
|
|
|
bytes_after_last_accept = bytes;
|
|
}
|
|
|
|
undumped_chars = 0;
|
|
|
|
// continue processing the string
|
|
state = UTF8_ACCEPT;
|
|
break;
|
|
}
|
|
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: // decode found yet incomplete multi-byte code point
|
|
{
|
|
if (!ensure_ascii)
|
|
{
|
|
// code point will not be escaped - copy byte to buffer
|
|
string_buffer[bytes++] = s[i];
|
|
}
|
|
++undumped_chars;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// we finished processing the string
|
|
if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
|
|
{
|
|
// write buffer
|
|
if (bytes > 0)
|
|
{
|
|
o->write_characters(string_buffer.data(), bytes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we finish reading, but do not accept: string was incomplete
|
|
switch (error_handler)
|
|
{
|
|
case error_handler_t::strict:
|
|
{
|
|
std::stringstream ss;
|
|
ss << std::uppercase << std::setfill('0') << std::setw(2) << std::hex << (static_cast<std::uint8_t>(s.back()) | 0);
|
|
JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str(), BasicJsonType()));
|
|
}
|
|
|
|
case error_handler_t::ignore:
|
|
{
|
|
// write all accepted bytes
|
|
o->write_characters(string_buffer.data(), bytes_after_last_accept);
|
|
break;
|
|
}
|
|
|
|
case error_handler_t::replace:
|
|
{
|
|
// write all accepted bytes
|
|
o->write_characters(string_buffer.data(), bytes_after_last_accept);
|
|
// add a replacement character
|
|
if (ensure_ascii)
|
|
{
|
|
o->write_characters("\\ufffd", 6);
|
|
}
|
|
else
|
|
{
|
|
o->write_characters("\xEF\xBF\xBD", 3);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@brief count digits
|
|
|
|
Count the number of decimal (base 10) digits for an input unsigned integer.
|
|
|
|
@param[in] x unsigned integer number to count its digits
|
|
@return number of decimal digits
|
|
*/
|
|
inline unsigned int count_digits(number_unsigned_t x) noexcept
|
|
{
|
|
unsigned int n_digits = 1;
|
|
for (;;)
|
|
{
|
|
if (x < 10)
|
|
{
|
|
return n_digits;
|
|
}
|
|
if (x < 100)
|
|
{
|
|
return n_digits + 1;
|
|
}
|
|
if (x < 1000)
|
|
{
|
|
return n_digits + 2;
|
|
}
|
|
if (x < 10000)
|
|
{
|
|
return n_digits + 3;
|
|
}
|
|
x = x / 10000u;
|
|
n_digits += 4;
|
|
}
|
|
}
|
|
|
|
// templates to avoid warnings about useless casts
|
|
template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
|
|
bool is_negative_number(NumberType x)
|
|
{
|
|
return x < 0;
|
|
}
|
|
|
|
template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
|
|
bool is_negative_number(NumberType /*unused*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*!
|
|
@brief dump an integer
|
|
|
|
Dump a given integer to output stream @a o. Works internally with
|
|
@a number_buffer.
|
|
|
|
@param[in] x integer number (signed or unsigned) to dump
|
|
@tparam NumberType either @a number_integer_t or @a number_unsigned_t
|
|
*/
|
|
template < typename NumberType, detail::enable_if_t <
|
|
std::is_integral<NumberType>::value ||
|
|
std::is_same<NumberType, number_unsigned_t>::value ||
|
|
std::is_same<NumberType, number_integer_t>::value ||
|
|
std::is_same<NumberType, binary_char_t>::value,
|
|
int > = 0 >
|
|
void dump_integer(NumberType x)
|
|
{
|
|
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
|
|
{
|
|
{
|
|
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
|
|
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
|
|
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
|
|
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
|
|
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
|
|
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
|
|
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
|
|
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
|
|
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
|
|
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
|
|
}
|
|
};
|
|
|
|
// special case for "0"
|
|
if (x == 0)
|
|
{
|
|
o->write_character('0');
|
|
return;
|
|
}
|
|
|
|
// use a pointer to fill the buffer
|
|
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
|
|
number_unsigned_t abs_value;
|
|
|
|
unsigned int n_chars{};
|
|
|
|
if (is_negative_number(x))
|
|
{
|
|
*buffer_ptr = '-';
|
|
abs_value = remove_sign(static_cast<number_integer_t>(x));
|
|
|
|
// account one more byte for the minus sign
|
|
n_chars = 1 + count_digits(abs_value);
|
|
}
|
|
else
|
|
{
|
|
abs_value = static_cast<number_unsigned_t>(x);
|
|
n_chars = count_digits(abs_value);
|
|
}
|
|
|
|
// spare 1 byte for '\0'
|
|
JSON_ASSERT(n_chars < number_buffer.size() - 1);
|
|
|
|
// jump to the end to generate the string from backward,
|
|
// so we later avoid reversing the result
|
|
buffer_ptr += n_chars;
|
|
|
|
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
|
|
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
|
|
while (abs_value >= 100)
|
|
{
|
|
const auto digits_index = static_cast<unsigned>((abs_value % 100));
|
|
abs_value /= 100;
|
|
*(--buffer_ptr) = digits_to_99[digits_index][1];
|
|
*(--buffer_ptr) = digits_to_99[digits_index][0];
|
|
}
|
|
|
|
if (abs_value >= 10)
|
|
{
|
|
const auto digits_index = static_cast<unsigned>(abs_value);
|
|
*(--buffer_ptr) = digits_to_99[digits_index][1];
|
|
*(--buffer_ptr) = digits_to_99[digits_index][0];
|
|
}
|
|
else
|
|
{
|
|
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
|
|
}
|
|
|
|
o->write_characters(number_buffer.data(), n_chars);
|
|
}
|
|
|
|
/*!
|
|
@brief dump a floating-point number
|
|
|
|
Dump a given floating-point number to output stream @a o. Works internally
|
|
with @a number_buffer.
|
|
|
|
@param[in] x floating-point number to dump
|
|
*/
|
|
void dump_float(number_float_t x)
|
|
{
|
|
// NaN / inf
|
|
if (!std::isfinite(x))
|
|
{
|
|
o->write_characters("null", 4);
|
|
return;
|
|
}
|
|
|
|
// If number_float_t is an IEEE-754 single or double precision number,
|
|
// use the Grisu2 algorithm to produce short numbers which are
|
|
// guaranteed to round-trip, using strtof and strtod, resp.
|
|
//
|
|
// NB: The test below works if <long double> == <double>.
|
|
static constexpr bool is_ieee_single_or_double
|
|
= (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
|
|
(std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
|
|
|
|
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
|
|
}
|
|
|
|
void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
|
|
{
|
|
auto* begin = number_buffer.data();
|
|
auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
|
|
|
|
o->write_characters(begin, static_cast<size_t>(end - begin));
|
|
}
|
|
|
|
void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
|
|
{
|
|
// get number of digits for a float -> text -> float round-trip
|
|
static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
|
|
|
|
// the actual conversion
|
|
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
|
|
std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
|
|
|
|
// negative value indicates an error
|
|
JSON_ASSERT(len > 0);
|
|
// check if buffer was large enough
|
|
JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
|
|
|
|
// erase thousands separator
|
|
if (thousands_sep != '\0')
|
|
{
|
|
// NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
|
|
const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
|
|
std::fill(end, number_buffer.end(), '\0');
|
|
JSON_ASSERT((end - number_buffer.begin()) <= len);
|
|
len = (end - number_buffer.begin());
|
|
}
|
|
|
|
// convert decimal point to '.'
|
|
if (decimal_point != '\0' && decimal_point != '.')
|
|
{
|
|
// NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
|
|
const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
|
|
if (dec_pos != number_buffer.end())
|
|
{
|
|
*dec_pos = '.';
|
|
}
|
|
}
|
|
|
|
o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
|
|
|
|
// determine if we need to append ".0"
|
|
const bool value_is_int_like =
|
|
std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
|
|
[](char c)
|
|
{
|
|
return c == '.' || c == 'e';
|
|
});
|
|
|
|
if (value_is_int_like)
|
|
{
|
|
o->write_characters(".0", 2);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
@brief check whether a string is UTF-8 encoded
|
|
|
|
The function checks each byte of a string whether it is UTF-8 encoded. The
|
|
result of the check is stored in the @a state parameter. The function must
|
|
be called initially with state 0 (accept). State 1 means the string must
|
|
be rejected, because the current byte is not allowed. If the string is
|
|
completely processed, but the state is non-zero, the string ended
|
|
prematurely; that is, the last byte indicated more bytes should have
|
|
followed.
|
|
|
|
@param[in,out] state the state of the decoding
|
|
@param[in,out] codep codepoint (valid only if resulting state is UTF8_ACCEPT)
|
|
@param[in] byte next byte to decode
|
|
@return new state
|
|
|
|
@note The function has been edited: a std::array is used.
|
|
|
|
@copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
|
|
@sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
|
*/
|
|
static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
|
|
{
|
|
static const std::array<std::uint8_t, 400> utf8d =
|
|
{
|
|
{
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
|
|
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
|
|
8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
|
|
0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
|
|
0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
|
|
0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
|
|
1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
|
|
1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
|
|
1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
|
|
}
|
|
};
|
|
|
|
JSON_ASSERT(byte < utf8d.size());
|
|
const std::uint8_t type = utf8d[byte];
|
|
|
|
codep = (state != UTF8_ACCEPT)
|
|
? (byte & 0x3fu) | (codep << 6u)
|
|
: (0xFFu >> type) & (byte);
|
|
|
|
std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
|
|
JSON_ASSERT(index < 400);
|
|
state = utf8d[index];
|
|
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)
|
|
{
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) 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
|
|
{
|
|
JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
|
|
return static_cast<number_unsigned_t>(-(x + 1)) + 1;
|
|
}
|
|
|
|
private:
|
|
/// the output of the serializer
|
|
output_adapter_t<char> o = nullptr;
|
|
|
|
/// a (hopefully) large enough character buffer
|
|
std::array<char, 64> number_buffer{{}};
|
|
|
|
/// the locale
|
|
const std::lconv* loc = nullptr;
|
|
/// the locale's thousand separator character
|
|
const char thousands_sep = '\0';
|
|
/// the locale's decimal point character
|
|
const char decimal_point = '\0';
|
|
|
|
/// string buffer
|
|
std::array<char, 512> string_buffer{{}};
|
|
|
|
/// the indentation character
|
|
const char indent_char;
|
|
/// the indentation string
|
|
string_t indent_string;
|
|
|
|
/// error_handler how to react on decoding errors
|
|
const error_handler_t error_handler;
|
|
};
|
|
} // namespace detail
|
|
} // namespace nlohmann
|
|
|
|
// #include <nlohmann/detail/value_t.hpp>
|
|
|
|
// #include <nlohmann/json_fwd.hpp>
|
|
|
|
// #include <nlohmann/ordered_map.hpp>
|
|
|
|
|
|
#include <functional> // less
|
|
#include <initializer_list> // initializer_list
|
|
#include <iterator> // input_iterator_tag, iterator_traits
|
|
#include <memory> // allocator
|
|
#include <stdexcept> // for out_of_range
|
|
#include <type_traits> // enable_if, is_convertible
|
|
#include <utility> // pair
|
|
#include <vector> // vector
|
|
|
|
// #include <nlohmann/detail/macro_scope.hpp>
|
|
|
|
|
|
namespace nlohmann
|
|
{
|
|
|
|
/// ordered_map: a minimal map-like container that preserves insertion order
|
|
/// for use within nlohmann::basic_json<ordered_map>
|
|
template <class Key, class T, class IgnoredLess = std::less<Key>,
|
|
class Allocator = std::allocator<std::pair<const Key, T>>>
|
|
struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
|
|
{
|
|
using key_type = Key;
|
|
using mapped_type = T;
|
|
using Container = std::vector<std::pair<const Key, T>, Allocator>;
|
|
using iterator = typename Container::iterator;
|
|
using const_iterator = typename Container::const_iterator;
|
|
using size_type = typename Container::size_type;
|
|
using value_type = typename Container::value_type;
|
|
|
|
// Explicit constructors instead of `using Container::Container`
|
|
// otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
|
|
ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
|
|
template <class It>
|
|
ordered_map(It first, It last, const Allocator& alloc = Allocator())
|
|
: Container{first, last, alloc} {}
|
|
ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
|
|
: Container{init, alloc} {}
|
|
|
|
std::pair<iterator, bool> emplace(const key_type& key, T&& t)
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
return {it, false};
|
|
}
|
|
}
|
|
Container::emplace_back(key, t);
|
|
return {--this->end(), true};
|
|
}
|
|
|
|
T& operator[](const Key& key)
|
|
{
|
|
return emplace(key, T{}).first->second;
|
|
}
|
|
|
|
const T& operator[](const Key& key) const
|
|
{
|
|
return at(key);
|
|
}
|
|
|
|
T& at(const Key& key)
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
return it->second;
|
|
}
|
|
}
|
|
|
|
JSON_THROW(std::out_of_range("key not found"));
|
|
}
|
|
|
|
const T& at(const Key& key) const
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
return it->second;
|
|
}
|
|
}
|
|
|
|
JSON_THROW(std::out_of_range("key not found"));
|
|
}
|
|
|
|
size_type erase(const Key& key)
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
// Since we cannot move const Keys, re-construct them in place
|
|
for (auto next = it; ++next != this->end(); ++it)
|
|
{
|
|
it->~value_type(); // Destroy but keep allocation
|
|
new (&*it) value_type{std::move(*next)};
|
|
}
|
|
Container::pop_back();
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
iterator erase(iterator pos)
|
|
{
|
|
return erase(pos, std::next(pos));
|
|
}
|
|
|
|
iterator erase(iterator first, iterator last)
|
|
{
|
|
const auto elements_affected = std::distance(first, last);
|
|
const auto offset = std::distance(Container::begin(), first);
|
|
|
|
// This is the start situation. We need to delete elements_affected
|
|
// elements (3 in this example: e, f, g), and need to return an
|
|
// iterator past the last deleted element (h in this example).
|
|
// Note that offset is the distance from the start of the vector
|
|
// to first. We will need this later.
|
|
|
|
// [ a, b, c, d, e, f, g, h, i, j ]
|
|
// ^ ^
|
|
// first last
|
|
|
|
// Since we cannot move const Keys, we re-construct them in place.
|
|
// We start at first and re-construct (viz. copy) the elements from
|
|
// the back of the vector. Example for first iteration:
|
|
|
|
// ,--------.
|
|
// v | destroy e and re-construct with h
|
|
// [ a, b, c, d, e, f, g, h, i, j ]
|
|
// ^ ^
|
|
// it it + elements_affected
|
|
|
|
for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
|
|
{
|
|
it->~value_type(); // destroy but keep allocation
|
|
new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
|
|
}
|
|
|
|
// [ a, b, c, d, h, i, j, h, i, j ]
|
|
// ^ ^
|
|
// first last
|
|
|
|
// remove the unneeded elements at the end of the vector
|
|
Container::resize(this->size() - static_cast<size_type>(elements_affected));
|
|
|
|
// [ a, b, c, d, h, i, j ]
|
|
// ^ ^
|
|
// first last
|
|
|
|
// first is now pointing past the last deleted element, but we cannot
|
|
// use this iterator, because it may have been invalidated by the
|
|
// resize call. Instead, we can return begin() + offset.
|
|
return Container::begin() + offset;
|
|
}
|
|
|
|
size_type count(const Key& key) const
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
iterator find(const Key& key)
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
return it;
|
|
}
|
|
}
|
|
return Container::end();
|
|
}
|
|
|
|
const_iterator find(const Key& key) const
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == key)
|
|
{
|
|
return it;
|
|
}
|
|
}
|
|
return Container::end();
|
|
}
|
|
|
|
std::pair<iterator, bool> insert( value_type&& value )
|
|
{
|
|
return emplace(value.first, std::move(value.second));
|
|
}
|
|
|
|
std::pair<iterator, bool> insert( const value_type& value )
|
|
{
|
|
for (auto it = this->begin(); it != this->end(); ++it)
|
|
{
|
|
if (it->first == value.first)
|
|
{
|
|
return {it, false};
|
|
}
|
|
}
|
|
Container::push_back(value);
|
|
return {--this->end(), true};
|
|
}
|
|
|
|
template<typename InputIt>
|
|
using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
|
|
std::input_iterator_tag>::value>::type;
|
|
|
|
template<typename InputIt, typename = require_input_iter<InputIt>>
|
|
void insert(InputIt first, InputIt last)
|
|
{
|
|
for (auto it = first; it != last; ++it)
|
|
{
|
|
insert(*it);
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace nlohmann
|
|
|
|
|
|
#if defined(JSON_HAS_CPP_17)
|
|
#include <string_view>
|
|
#endif
|
|
|
|
/*!
|
|
@brief namespace for Niels Lohmann
|
|
@see https://github.com/nlohmann
|
|
@since version 1.0.0
|
|
*/
|
|
namespace nlohmann
|
|
{
|
|
|
|
/*!
|
|
@brief a class to store JSON values
|
|
|
|
@internal
|
|
@invariant The member variables @a m_value and @a m_type have the following
|
|
relationship:
|
|
- If `m_type == value_t::object`, then `m_value.object != nullptr`.
|
|
- If `m_type == value_t::array`, then `m_value.array != nullptr`.
|
|
- If `m_type == value_t::string`, then `m_value.string != nullptr`.
|
|
The invariants are checked by member function assert_invariant().
|
|
|
|
@note ObjectType trick from https://stackoverflow.com/a/9860911
|
|
@endinternal
|
|
|
|
@since version 1.0.0
|
|
|
|
@nosubgrouping
|
|
*/
|
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
|
|
{
|
|
private:
|
|
template<detail::value_t> friend struct detail::external_constructor;
|
|
friend ::nlohmann::json_pointer<basic_json>;
|
|
|
|
template<typename BasicJsonType, typename InputType>
|
|
friend class ::nlohmann::detail::parser;
|
|
friend ::nlohmann::detail::serializer<basic_json>;
|
|
template<typename BasicJsonType>
|
|
friend class ::nlohmann::detail::iter_impl;
|
|
template<typename BasicJsonType, typename CharType>
|
|
friend class ::nlohmann::detail::binary_writer;
|
|
template<typename BasicJsonType, typename InputType, typename SAX>
|
|
friend class ::nlohmann::detail::binary_reader;
|
|
template<typename BasicJsonType>
|
|
friend class ::nlohmann::detail::json_sax_dom_parser;
|
|
template<typename BasicJsonType>
|
|
friend class ::nlohmann::detail::json_sax_dom_callback_parser;
|
|
friend class ::nlohmann::detail::exception;
|
|
|
|
/// workaround type for MSVC
|
|
using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
// convenience aliases for types residing in namespace detail;
|
|
using lexer = ::nlohmann::detail::lexer_base<basic_json>;
|
|
|
|
template<typename InputAdapterType>
|
|
static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
|
|
InputAdapterType adapter,
|
|
detail::parser_callback_t<basic_json>cb = nullptr,
|
|
const bool allow_exceptions = true,
|
|
const bool ignore_comments = false
|
|
)
|
|
{
|
|
return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
|
|
std::move(cb), allow_exceptions, ignore_comments);
|
|
}
|
|
|
|
private:
|
|
using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
|
|
template<typename BasicJsonType>
|
|
using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
|
|
template<typename BasicJsonType>
|
|
using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
|
|
template<typename Iterator>
|
|
using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
|
|
template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
|
|
|
|
template<typename CharType>
|
|
using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
|
|
|
|
template<typename InputType>
|
|
using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
|
|
template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
using serializer = ::nlohmann::detail::serializer<basic_json>;
|
|
|
|
public:
|
|
using value_t = detail::value_t;
|
|
/// JSON Pointer, see @ref nlohmann::json_pointer
|
|
using json_pointer = ::nlohmann::json_pointer<basic_json>;
|
|
template<typename T, typename SFINAE>
|
|
using json_serializer = JSONSerializer<T, SFINAE>;
|
|
/// how to treat decoding errors
|
|
using error_handler_t = detail::error_handler_t;
|
|
/// how to treat CBOR tags
|
|
using cbor_tag_handler_t = detail::cbor_tag_handler_t;
|
|
/// helper type for initializer lists of basic_json values
|
|
using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
|
|
|
|
using input_format_t = detail::input_format_t;
|
|
/// SAX interface type, see @ref nlohmann::json_sax
|
|
using json_sax_t = json_sax<basic_json>;
|
|
|
|
////////////////
|
|
// exceptions //
|
|
////////////////
|
|
|
|
/// @name exceptions
|
|
/// Classes to implement user-defined exceptions.
|
|
/// @{
|
|
|
|
using exception = detail::exception;
|
|
using parse_error = detail::parse_error;
|
|
using invalid_iterator = detail::invalid_iterator;
|
|
using type_error = detail::type_error;
|
|
using out_of_range = detail::out_of_range;
|
|
using other_error = detail::other_error;
|
|
|
|
/// @}
|
|
|
|
|
|
/////////////////////
|
|
// container types //
|
|
/////////////////////
|
|
|
|
/// @name container types
|
|
/// The canonic container types to use @ref basic_json like any other STL
|
|
/// container.
|
|
/// @{
|
|
|
|
/// the type of elements in a basic_json container
|
|
using value_type = basic_json;
|
|
|
|
/// the type of an element reference
|
|
using reference = value_type&;
|
|
/// the type of an element const reference
|
|
using const_reference = const value_type&;
|
|
|
|
/// a type to represent differences between iterators
|
|
using difference_type = std::ptrdiff_t;
|
|
/// a type to represent container sizes
|
|
using size_type = std::size_t;
|
|
|
|
/// the allocator type
|
|
using allocator_type = AllocatorType<basic_json>;
|
|
|
|
/// the type of an element pointer
|
|
using pointer = typename std::allocator_traits<allocator_type>::pointer;
|
|
/// the type of an element const pointer
|
|
using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
|
|
|
|
/// an iterator for a basic_json container
|
|
using iterator = iter_impl<basic_json>;
|
|
/// a const iterator for a basic_json container
|
|
using const_iterator = iter_impl<const basic_json>;
|
|
/// a reverse iterator for a basic_json container
|
|
using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
|
|
/// a const reverse iterator for a basic_json container
|
|
using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
|
|
|
|
/// @}
|
|
|
|
|
|
/// @brief returns the allocator associated with the container
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
|
|
static allocator_type get_allocator()
|
|
{
|
|
return allocator_type();
|
|
}
|
|
|
|
/// @brief returns version information on the library
|
|
/// @sa https://json.nlohmann.me/api/basic_json/meta/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json meta()
|
|
{
|
|
basic_json result;
|
|
|
|
result["copyright"] = "(C) 2013-2022 Niels Lohmann";
|
|
result["name"] = "JSON for Modern C++";
|
|
result["url"] = "https://github.com/nlohmann/json";
|
|
result["version"]["string"] =
|
|
std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
|
|
std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
|
|
std::to_string(NLOHMANN_JSON_VERSION_PATCH);
|
|
result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
|
|
result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
|
|
result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
|
|
|
|
#ifdef _WIN32
|
|
result["platform"] = "win32";
|
|
#elif defined __linux__
|
|
result["platform"] = "linux";
|
|
#elif defined __APPLE__
|
|
result["platform"] = "apple";
|
|
#elif defined __unix__
|
|
result["platform"] = "unix";
|
|
#else
|
|
result["platform"] = "unknown";
|
|
#endif
|
|
|
|
#if defined(__ICC) || defined(__INTEL_COMPILER)
|
|
result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
|
|
#elif defined(__clang__)
|
|
result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
|
|
#elif defined(__GNUC__) || defined(__GNUG__)
|
|
result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
|
|
#elif defined(__HP_cc) || defined(__HP_aCC)
|
|
result["compiler"] = "hp"
|
|
#elif defined(__IBMCPP__)
|
|
result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
|
|
#elif defined(_MSC_VER)
|
|
result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
|
|
#elif defined(__PGI)
|
|
result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
|
|
#elif defined(__SUNPRO_CC)
|
|
result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
|
|
#else
|
|
result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
result["compiler"]["c++"] = std::to_string(__cplusplus);
|
|
#else
|
|
result["compiler"]["c++"] = "unknown";
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
|
|
///////////////////////////
|
|
// JSON value data types //
|
|
///////////////////////////
|
|
|
|
/// @name JSON value data types
|
|
/// The data types to store a JSON value. These types are derived from
|
|
/// the template arguments passed to class @ref basic_json.
|
|
/// @{
|
|
|
|
/// @brief object key comparator type
|
|
/// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
|
|
#if defined(JSON_HAS_CPP_14)
|
|
// Use transparent comparator if possible, combined with perfect forwarding
|
|
// on find() and count() calls prevents unnecessary string construction.
|
|
using object_comparator_t = std::less<>;
|
|
#else
|
|
using object_comparator_t = std::less<StringType>;
|
|
#endif
|
|
|
|
/// @brief a type for an object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/object_t/
|
|
using object_t = ObjectType<StringType,
|
|
basic_json,
|
|
object_comparator_t,
|
|
AllocatorType<std::pair<const StringType,
|
|
basic_json>>>;
|
|
|
|
/// @brief a type for an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/array_t/
|
|
using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
|
|
|
|
/// @brief a type for a string
|
|
/// @sa https://json.nlohmann.me/api/basic_json/string_t/
|
|
using string_t = StringType;
|
|
|
|
/// @brief a type for a boolean
|
|
/// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
|
|
using boolean_t = BooleanType;
|
|
|
|
/// @brief a type for a number (integer)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
|
|
using number_integer_t = NumberIntegerType;
|
|
|
|
/// @brief a type for a number (unsigned)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
|
|
using number_unsigned_t = NumberUnsignedType;
|
|
|
|
/// @brief a type for a number (floating-point)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
|
|
using number_float_t = NumberFloatType;
|
|
|
|
/// @brief a type for a packed binary type
|
|
/// @sa https://json.nlohmann.me/api/basic_json/binary_t/
|
|
using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
|
|
|
|
/// @}
|
|
|
|
private:
|
|
|
|
/// helper for exception-safe object creation
|
|
template<typename T, typename... Args>
|
|
JSON_HEDLEY_RETURNS_NON_NULL
|
|
static T* create(Args&& ... args)
|
|
{
|
|
AllocatorType<T> alloc;
|
|
using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
|
|
|
|
auto deleter = [&](T * obj)
|
|
{
|
|
AllocatorTraits::deallocate(alloc, obj, 1);
|
|
};
|
|
std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
|
|
AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
|
|
JSON_ASSERT(obj != nullptr);
|
|
return obj.release();
|
|
}
|
|
|
|
////////////////////////
|
|
// JSON value storage //
|
|
////////////////////////
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
/*!
|
|
@brief a JSON value
|
|
|
|
The actual storage for a JSON value of the @ref basic_json class. This
|
|
union combines the different storage types for the JSON value types
|
|
defined in @ref value_t.
|
|
|
|
JSON type | value_t type | used type
|
|
--------- | --------------- | ------------------------
|
|
object | object | pointer to @ref object_t
|
|
array | array | pointer to @ref array_t
|
|
string | string | pointer to @ref string_t
|
|
boolean | boolean | @ref boolean_t
|
|
number | number_integer | @ref number_integer_t
|
|
number | number_unsigned | @ref number_unsigned_t
|
|
number | number_float | @ref number_float_t
|
|
binary | binary | pointer to @ref binary_t
|
|
null | null | *no value is stored*
|
|
|
|
@note Variable-length types (objects, arrays, and strings) are stored as
|
|
pointers. The size of the union should not exceed 64 bits if the default
|
|
value types are used.
|
|
|
|
@since version 1.0.0
|
|
*/
|
|
union json_value
|
|
{
|
|
/// object (stored with pointer to save storage)
|
|
object_t* object;
|
|
/// array (stored with pointer to save storage)
|
|
array_t* array;
|
|
/// string (stored with pointer to save storage)
|
|
string_t* string;
|
|
/// binary (stored with pointer to save storage)
|
|
binary_t* binary;
|
|
/// boolean
|
|
boolean_t boolean;
|
|
/// number (integer)
|
|
number_integer_t number_integer;
|
|
/// number (unsigned integer)
|
|
number_unsigned_t number_unsigned;
|
|
/// number (floating-point)
|
|
number_float_t number_float;
|
|
|
|
/// default constructor (for null values)
|
|
json_value() = default;
|
|
/// constructor for booleans
|
|
json_value(boolean_t v) noexcept : boolean(v) {}
|
|
/// constructor for numbers (integer)
|
|
json_value(number_integer_t v) noexcept : number_integer(v) {}
|
|
/// constructor for numbers (unsigned)
|
|
json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
|
|
/// constructor for numbers (floating-point)
|
|
json_value(number_float_t v) noexcept : number_float(v) {}
|
|
/// constructor for empty values of a given type
|
|
json_value(value_t t)
|
|
{
|
|
switch (t)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
object = create<object_t>();
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
array = create<array_t>();
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
string = create<string_t>("");
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
binary = create<binary_t>();
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
boolean = static_cast<boolean_t>(false);
|
|
break;
|
|
}
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
number_integer = static_cast<number_integer_t>(0);
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
number_unsigned = static_cast<number_unsigned_t>(0);
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
number_float = static_cast<number_float_t>(0.0);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
{
|
|
object = nullptr; // silence warning, see #821
|
|
break;
|
|
}
|
|
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
object = nullptr; // silence warning, see #821
|
|
if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
|
|
{
|
|
JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.10.5", basic_json())); // LCOV_EXCL_LINE
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// constructor for strings
|
|
json_value(const string_t& value) : string(create<string_t>(value)) {}
|
|
|
|
/// constructor for rvalue strings
|
|
json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
|
|
|
|
/// constructor for objects
|
|
json_value(const object_t& value) : object(create<object_t>(value)) {}
|
|
|
|
/// constructor for rvalue objects
|
|
json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
|
|
|
|
/// constructor for arrays
|
|
json_value(const array_t& value) : array(create<array_t>(value)) {}
|
|
|
|
/// constructor for rvalue arrays
|
|
json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
|
|
|
|
/// constructor for binary arrays
|
|
json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
|
|
|
|
/// constructor for rvalue binary arrays
|
|
json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
|
|
|
|
/// constructor for binary arrays (internal type)
|
|
json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
|
|
|
|
/// constructor for rvalue binary arrays (internal type)
|
|
json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
|
|
|
|
void destroy(value_t t)
|
|
{
|
|
if (t == value_t::array || t == value_t::object)
|
|
{
|
|
// 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
|
|
{
|
|
stack.reserve(object->size());
|
|
for (auto&& it : *object)
|
|
{
|
|
stack.push_back(std::move(it.second));
|
|
}
|
|
}
|
|
|
|
while (!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:
|
|
{
|
|
AllocatorType<object_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
AllocatorType<array_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
AllocatorType<string_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
AllocatorType<binary_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
private:
|
|
/*!
|
|
@brief checks the class invariants
|
|
|
|
This function asserts the class invariants. It needs to be called at the
|
|
end of every constructor to make sure that created objects respect the
|
|
invariant. Furthermore, it has to be called each time the type of a JSON
|
|
value is changed, because the invariant expresses a relationship between
|
|
@a m_type and @a m_value.
|
|
|
|
Furthermore, the parent relation is checked for arrays and objects: If
|
|
@a check_parents true and the value is an array or object, then the
|
|
container's elements must have the current value as parent.
|
|
|
|
@param[in] check_parents whether the parent relation should be checked.
|
|
The value is true by default and should only be set to false
|
|
during destruction of objects when the invariant does not
|
|
need to hold.
|
|
*/
|
|
void assert_invariant(bool check_parents = true) const noexcept
|
|
{
|
|
JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
|
|
JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
|
|
JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
|
|
JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
|
|
|
|
#if JSON_DIAGNOSTICS
|
|
JSON_TRY
|
|
{
|
|
// cppcheck-suppress assertWithSideEffect
|
|
JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
|
|
{
|
|
return j.m_parent == this;
|
|
}));
|
|
}
|
|
JSON_CATCH(...) {} // LCOV_EXCL_LINE
|
|
#endif
|
|
static_cast<void>(check_parents);
|
|
}
|
|
|
|
void set_parents()
|
|
{
|
|
#if JSON_DIAGNOSTICS
|
|
switch (m_type)
|
|
{
|
|
case value_t::array:
|
|
{
|
|
for (auto& element : *m_value.array)
|
|
{
|
|
element.m_parent = this;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
for (auto& element : *m_value.object)
|
|
{
|
|
element.second.m_parent = this;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
|
|
{
|
|
#if JSON_DIAGNOSTICS
|
|
for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
|
|
{
|
|
(it + i)->m_parent = this;
|
|
}
|
|
#else
|
|
static_cast<void>(count_set_parents);
|
|
#endif
|
|
return it;
|
|
}
|
|
|
|
reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
|
|
{
|
|
#if JSON_DIAGNOSTICS
|
|
if (old_capacity != static_cast<std::size_t>(-1))
|
|
{
|
|
// see https://github.com/nlohmann/json/issues/2838
|
|
JSON_ASSERT(type() == value_t::array);
|
|
if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
|
|
{
|
|
// capacity has changed: update all parents
|
|
set_parents();
|
|
return j;
|
|
}
|
|
}
|
|
|
|
// ordered_json uses a vector internally, so pointers could have
|
|
// been invalidated; see https://github.com/nlohmann/json/issues/2962
|
|
#ifdef JSON_HEDLEY_MSVC_VERSION
|
|
#pragma warning(push )
|
|
#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
|
|
#endif
|
|
if (detail::is_ordered_map<object_t>::value)
|
|
{
|
|
set_parents();
|
|
return j;
|
|
}
|
|
#ifdef JSON_HEDLEY_MSVC_VERSION
|
|
#pragma warning( pop )
|
|
#endif
|
|
|
|
j.m_parent = this;
|
|
#else
|
|
static_cast<void>(j);
|
|
static_cast<void>(old_capacity);
|
|
#endif
|
|
return j;
|
|
}
|
|
|
|
public:
|
|
//////////////////////////
|
|
// JSON parser callback //
|
|
//////////////////////////
|
|
|
|
/// @brief parser event types
|
|
/// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
|
|
using parse_event_t = detail::parse_event_t;
|
|
|
|
/// @brief per-element parser callback type
|
|
/// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
|
|
using parser_callback_t = detail::parser_callback_t<basic_json>;
|
|
|
|
//////////////////
|
|
// constructors //
|
|
//////////////////
|
|
|
|
/// @name constructors and destructors
|
|
/// Constructors of class @ref basic_json, copy/move constructor, copy
|
|
/// assignment, static functions creating objects, and the destructor.
|
|
/// @{
|
|
|
|
/// @brief create an empty value with a given type
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
basic_json(const value_t v)
|
|
: m_type(v), m_value(v)
|
|
{
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief create a null object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
basic_json(std::nullptr_t = nullptr) noexcept
|
|
: basic_json(value_t::null)
|
|
{
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief create a JSON value from compatible types
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
template < typename CompatibleType,
|
|
typename U = detail::uncvref_t<CompatibleType>,
|
|
detail::enable_if_t <
|
|
!detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
|
|
basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
|
|
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
|
|
std::forward<CompatibleType>(val))))
|
|
{
|
|
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief create a JSON value from an existing one
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
template < typename BasicJsonType,
|
|
detail::enable_if_t <
|
|
detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
|
|
basic_json(const BasicJsonType& val)
|
|
{
|
|
using other_boolean_t = typename BasicJsonType::boolean_t;
|
|
using other_number_float_t = typename BasicJsonType::number_float_t;
|
|
using other_number_integer_t = typename BasicJsonType::number_integer_t;
|
|
using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
|
|
using other_string_t = typename BasicJsonType::string_t;
|
|
using other_object_t = typename BasicJsonType::object_t;
|
|
using other_array_t = typename BasicJsonType::array_t;
|
|
using other_binary_t = typename BasicJsonType::binary_t;
|
|
|
|
switch (val.type())
|
|
{
|
|
case value_t::boolean:
|
|
JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
|
|
break;
|
|
case value_t::number_float:
|
|
JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
|
|
break;
|
|
case value_t::number_integer:
|
|
JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
|
|
break;
|
|
case value_t::number_unsigned:
|
|
JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
|
|
break;
|
|
case value_t::string:
|
|
JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
|
|
break;
|
|
case value_t::object:
|
|
JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
|
|
break;
|
|
case value_t::array:
|
|
JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
|
|
break;
|
|
case value_t::binary:
|
|
JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
|
|
break;
|
|
case value_t::null:
|
|
*this = nullptr;
|
|
break;
|
|
case value_t::discarded:
|
|
m_type = value_t::discarded;
|
|
break;
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief create a container (array or object) from an initializer list
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
basic_json(initializer_list_t init,
|
|
bool type_deduction = true,
|
|
value_t manual_type = value_t::array)
|
|
{
|
|
// check if each element is an array with two elements whose first
|
|
// element is a string
|
|
bool is_an_object = std::all_of(init.begin(), init.end(),
|
|
[](const detail::json_ref<basic_json>& element_ref)
|
|
{
|
|
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
|
|
});
|
|
|
|
// adjust type if type deduction is not wanted
|
|
if (!type_deduction)
|
|
{
|
|
// if array is wanted, do not create an object though possible
|
|
if (manual_type == value_t::array)
|
|
{
|
|
is_an_object = false;
|
|
}
|
|
|
|
// if object is wanted but impossible, throw an exception
|
|
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
|
|
{
|
|
JSON_THROW(type_error::create(301, "cannot create object from initializer list", basic_json()));
|
|
}
|
|
}
|
|
|
|
if (is_an_object)
|
|
{
|
|
// the initializer list is a list of pairs -> create object
|
|
m_type = value_t::object;
|
|
m_value = value_t::object;
|
|
|
|
for (auto& element_ref : init)
|
|
{
|
|
auto element = element_ref.moved_or_copied();
|
|
m_value.object->emplace(
|
|
std::move(*((*element.m_value.array)[0].m_value.string)),
|
|
std::move((*element.m_value.array)[1]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// the initializer list describes an array -> create array
|
|
m_type = value_t::array;
|
|
m_value.array = create<array_t>(init.begin(), init.end());
|
|
}
|
|
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief explicitly create a binary array (without subtype)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json binary(const typename binary_t::container_type& init)
|
|
{
|
|
auto res = basic_json();
|
|
res.m_type = value_t::binary;
|
|
res.m_value = init;
|
|
return res;
|
|
}
|
|
|
|
/// @brief explicitly create a binary array (with subtype)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
|
|
{
|
|
auto res = basic_json();
|
|
res.m_type = value_t::binary;
|
|
res.m_value = binary_t(init, subtype);
|
|
return res;
|
|
}
|
|
|
|
/// @brief explicitly create a binary array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json binary(typename binary_t::container_type&& init)
|
|
{
|
|
auto res = basic_json();
|
|
res.m_type = value_t::binary;
|
|
res.m_value = std::move(init);
|
|
return res;
|
|
}
|
|
|
|
/// @brief explicitly create a binary array (with subtype)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/binary/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
|
|
{
|
|
auto res = basic_json();
|
|
res.m_type = value_t::binary;
|
|
res.m_value = binary_t(std::move(init), subtype);
|
|
return res;
|
|
}
|
|
|
|
/// @brief explicitly create an array from an initializer list
|
|
/// @sa https://json.nlohmann.me/api/basic_json/array/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json array(initializer_list_t init = {})
|
|
{
|
|
return basic_json(init, false, value_t::array);
|
|
}
|
|
|
|
/// @brief explicitly create an object from an initializer list
|
|
/// @sa https://json.nlohmann.me/api/basic_json/object/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json object(initializer_list_t init = {})
|
|
{
|
|
return basic_json(init, false, value_t::object);
|
|
}
|
|
|
|
/// @brief construct an array with count copies of given value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
basic_json(size_type cnt, const basic_json& val)
|
|
: m_type(value_t::array)
|
|
{
|
|
m_value.array = create<array_t>(cnt, val);
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief construct a JSON container given an iterator range
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
template < class InputIT, typename std::enable_if <
|
|
std::is_same<InputIT, typename basic_json_t::iterator>::value ||
|
|
std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
|
|
basic_json(InputIT first, InputIT last)
|
|
{
|
|
JSON_ASSERT(first.m_object != nullptr);
|
|
JSON_ASSERT(last.m_object != nullptr);
|
|
|
|
// make sure iterator fits the current value
|
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", basic_json()));
|
|
}
|
|
|
|
// copy type from first iterator
|
|
m_type = first.m_object->m_type;
|
|
|
|
// check if iterator range is complete for primitive values
|
|
switch (m_type)
|
|
{
|
|
case value_t::boolean:
|
|
case value_t::number_float:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::string:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
|
|
|| !last.m_it.primitive_iterator.is_end()))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(204, "iterators out of range", *first.m_object));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::object:
|
|
case value_t::array:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (m_type)
|
|
{
|
|
case value_t::number_integer:
|
|
{
|
|
m_value.number_integer = first.m_object->m_value.number_integer;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
m_value.number_unsigned = first.m_object->m_value.number_unsigned;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
m_value.number_float = first.m_object->m_value.number_float;
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
m_value.boolean = first.m_object->m_value.boolean;
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
m_value = *first.m_object->m_value.string;
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
m_value.object = create<object_t>(first.m_it.object_iterator,
|
|
last.m_it.object_iterator);
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
m_value.array = create<array_t>(first.m_it.array_iterator,
|
|
last.m_it.array_iterator);
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
m_value = *first.m_object->m_value.binary;
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " + std::string(first.m_object->type_name()), *first.m_object));
|
|
}
|
|
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////
|
|
// other constructors and destructor //
|
|
///////////////////////////////////////
|
|
|
|
template<typename JsonRef,
|
|
detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
|
|
std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
|
|
basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
|
|
|
|
/// @brief copy constructor
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
basic_json(const basic_json& other)
|
|
: m_type(other.m_type)
|
|
{
|
|
// check of passed value is valid
|
|
other.assert_invariant();
|
|
|
|
switch (m_type)
|
|
{
|
|
case value_t::object:
|
|
{
|
|
m_value = *other.m_value.object;
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
m_value = *other.m_value.array;
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
m_value = *other.m_value.string;
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
m_value = other.m_value.boolean;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_integer:
|
|
{
|
|
m_value = other.m_value.number_integer;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
m_value = other.m_value.number_unsigned;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
m_value = other.m_value.number_float;
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
m_value = *other.m_value.binary;
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief move constructor
|
|
/// @sa https://json.nlohmann.me/api/basic_json/basic_json/
|
|
basic_json(basic_json&& other) noexcept
|
|
: m_type(std::move(other.m_type)),
|
|
m_value(std::move(other.m_value))
|
|
{
|
|
// check that passed value is valid
|
|
other.assert_invariant(false);
|
|
|
|
// invalidate payload
|
|
other.m_type = value_t::null;
|
|
other.m_value = {};
|
|
|
|
set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief copy assignment
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator=/
|
|
basic_json& operator=(basic_json other) noexcept (
|
|
std::is_nothrow_move_constructible<value_t>::value&&
|
|
std::is_nothrow_move_assignable<value_t>::value&&
|
|
std::is_nothrow_move_constructible<json_value>::value&&
|
|
std::is_nothrow_move_assignable<json_value>::value
|
|
)
|
|
{
|
|
// check that passed value is valid
|
|
other.assert_invariant();
|
|
|
|
using std::swap;
|
|
swap(m_type, other.m_type);
|
|
swap(m_value, other.m_value);
|
|
|
|
set_parents();
|
|
assert_invariant();
|
|
return *this;
|
|
}
|
|
|
|
/// @brief destructor
|
|
/// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
|
|
~basic_json() noexcept
|
|
{
|
|
assert_invariant(false);
|
|
m_value.destroy(m_type);
|
|
}
|
|
|
|
/// @}
|
|
|
|
public:
|
|
///////////////////////
|
|
// object inspection //
|
|
///////////////////////
|
|
|
|
/// @name object inspection
|
|
/// Functions to inspect the type of a JSON value.
|
|
/// @{
|
|
|
|
/// @brief serialization
|
|
/// @sa https://json.nlohmann.me/api/basic_json/dump/
|
|
string_t dump(const int indent = -1,
|
|
const char indent_char = ' ',
|
|
const bool ensure_ascii = false,
|
|
const error_handler_t error_handler = error_handler_t::strict) const
|
|
{
|
|
string_t result;
|
|
serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
|
|
|
|
if (indent >= 0)
|
|
{
|
|
s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
|
|
}
|
|
else
|
|
{
|
|
s.dump(*this, false, ensure_ascii, 0);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @brief return the type of the JSON value (explicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/type/
|
|
constexpr value_t type() const noexcept
|
|
{
|
|
return m_type;
|
|
}
|
|
|
|
/// @brief return whether type is primitive
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
|
|
constexpr bool is_primitive() const noexcept
|
|
{
|
|
return is_null() || is_string() || is_boolean() || is_number() || is_binary();
|
|
}
|
|
|
|
/// @brief return whether type is structured
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_structured/
|
|
constexpr bool is_structured() const noexcept
|
|
{
|
|
return is_array() || is_object();
|
|
}
|
|
|
|
/// @brief return whether value is null
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_null/
|
|
constexpr bool is_null() const noexcept
|
|
{
|
|
return m_type == value_t::null;
|
|
}
|
|
|
|
/// @brief return whether value is a boolean
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
|
|
constexpr bool is_boolean() const noexcept
|
|
{
|
|
return m_type == value_t::boolean;
|
|
}
|
|
|
|
/// @brief return whether value is a number
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number/
|
|
constexpr bool is_number() const noexcept
|
|
{
|
|
return is_number_integer() || is_number_float();
|
|
}
|
|
|
|
/// @brief return whether value is an integer number
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
|
|
constexpr bool is_number_integer() const noexcept
|
|
{
|
|
return m_type == value_t::number_integer || m_type == value_t::number_unsigned;
|
|
}
|
|
|
|
/// @brief return whether value is an unsigned integer number
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
|
|
constexpr bool is_number_unsigned() const noexcept
|
|
{
|
|
return m_type == value_t::number_unsigned;
|
|
}
|
|
|
|
/// @brief return whether value is a floating-point number
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
|
|
constexpr bool is_number_float() const noexcept
|
|
{
|
|
return m_type == value_t::number_float;
|
|
}
|
|
|
|
/// @brief return whether value is an object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_object/
|
|
constexpr bool is_object() const noexcept
|
|
{
|
|
return m_type == value_t::object;
|
|
}
|
|
|
|
/// @brief return whether value is an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_array/
|
|
constexpr bool is_array() const noexcept
|
|
{
|
|
return m_type == value_t::array;
|
|
}
|
|
|
|
/// @brief return whether value is a string
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_string/
|
|
constexpr bool is_string() const noexcept
|
|
{
|
|
return m_type == value_t::string;
|
|
}
|
|
|
|
/// @brief return whether value is a binary array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_binary/
|
|
constexpr bool is_binary() const noexcept
|
|
{
|
|
return m_type == value_t::binary;
|
|
}
|
|
|
|
/// @brief return whether value is discarded
|
|
/// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
|
|
constexpr bool is_discarded() const noexcept
|
|
{
|
|
return m_type == value_t::discarded;
|
|
}
|
|
|
|
/// @brief return the type of the JSON value (implicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
|
|
constexpr operator value_t() const noexcept
|
|
{
|
|
return m_type;
|
|
}
|
|
|
|
/// @}
|
|
|
|
private:
|
|
//////////////////
|
|
// value access //
|
|
//////////////////
|
|
|
|
/// get a boolean (explicit)
|
|
boolean_t get_impl(boolean_t* /*unused*/) const
|
|
{
|
|
if (JSON_HEDLEY_LIKELY(is_boolean()))
|
|
{
|
|
return m_value.boolean;
|
|
}
|
|
|
|
JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// get a pointer to the value (object)
|
|
object_t* get_impl_ptr(object_t* /*unused*/) noexcept
|
|
{
|
|
return is_object() ? m_value.object : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (object)
|
|
constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
|
|
{
|
|
return is_object() ? m_value.object : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (array)
|
|
array_t* get_impl_ptr(array_t* /*unused*/) noexcept
|
|
{
|
|
return is_array() ? m_value.array : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (array)
|
|
constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
|
|
{
|
|
return is_array() ? m_value.array : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (string)
|
|
string_t* get_impl_ptr(string_t* /*unused*/) noexcept
|
|
{
|
|
return is_string() ? m_value.string : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (string)
|
|
constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
|
|
{
|
|
return is_string() ? m_value.string : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (boolean)
|
|
boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
|
|
{
|
|
return is_boolean() ? &m_value.boolean : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (boolean)
|
|
constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
|
|
{
|
|
return is_boolean() ? &m_value.boolean : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (integer number)
|
|
number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
|
|
{
|
|
return is_number_integer() ? &m_value.number_integer : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (integer number)
|
|
constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
|
|
{
|
|
return is_number_integer() ? &m_value.number_integer : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (unsigned number)
|
|
number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
|
|
{
|
|
return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (unsigned number)
|
|
constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
|
|
{
|
|
return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (floating-point number)
|
|
number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
|
|
{
|
|
return is_number_float() ? &m_value.number_float : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (floating-point number)
|
|
constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
|
|
{
|
|
return is_number_float() ? &m_value.number_float : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (binary)
|
|
binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
|
|
{
|
|
return is_binary() ? m_value.binary : nullptr;
|
|
}
|
|
|
|
/// get a pointer to the value (binary)
|
|
constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
|
|
{
|
|
return is_binary() ? m_value.binary : nullptr;
|
|
}
|
|
|
|
/*!
|
|
@brief helper function to implement get_ref()
|
|
|
|
This function helps to implement get_ref() without code duplication for
|
|
const and non-const overloads
|
|
|
|
@tparam ThisType will be deduced as `basic_json` or `const basic_json`
|
|
|
|
@throw type_error.303 if ReferenceType does not match underlying value
|
|
type of the current JSON
|
|
*/
|
|
template<typename ReferenceType, typename ThisType>
|
|
static ReferenceType get_ref_impl(ThisType& obj)
|
|
{
|
|
// delegate the call to get_ptr<>()
|
|
auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
|
|
|
|
if (JSON_HEDLEY_LIKELY(ptr != nullptr))
|
|
{
|
|
return *ptr;
|
|
}
|
|
|
|
JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name()), obj));
|
|
}
|
|
|
|
public:
|
|
/// @name value access
|
|
/// Direct access to the stored value of a JSON value.
|
|
/// @{
|
|
|
|
/// @brief get a pointer value (implicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
|
|
template<typename PointerType, typename std::enable_if<
|
|
std::is_pointer<PointerType>::value, int>::type = 0>
|
|
auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
|
|
{
|
|
// delegate the call to get_impl_ptr<>()
|
|
return get_impl_ptr(static_cast<PointerType>(nullptr));
|
|
}
|
|
|
|
/// @brief get a pointer value (implicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
|
|
template < typename PointerType, typename std::enable_if <
|
|
std::is_pointer<PointerType>::value&&
|
|
std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
|
|
constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
|
|
{
|
|
// delegate the call to get_impl_ptr<>() const
|
|
return get_impl_ptr(static_cast<PointerType>(nullptr));
|
|
}
|
|
|
|
private:
|
|
/*!
|
|
@brief get a value (explicit)
|
|
|
|
Explicit type conversion between the JSON value and a compatible value
|
|
which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
|
|
and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
|
|
The value is converted by calling the @ref json_serializer<ValueType>
|
|
`from_json()` method.
|
|
|
|
The function is equivalent to executing
|
|
@code {.cpp}
|
|
ValueType ret;
|
|
JSONSerializer<ValueType>::from_json(*this, ret);
|
|
return ret;
|
|
@endcode
|
|
|
|
This overloads is chosen if:
|
|
- @a ValueType is not @ref basic_json,
|
|
- @ref json_serializer<ValueType> has a `from_json()` method of the form
|
|
`void from_json(const basic_json&, ValueType&)`, and
|
|
- @ref json_serializer<ValueType> does not have a `from_json()` method of
|
|
the form `ValueType from_json(const basic_json&)`
|
|
|
|
@tparam ValueType the returned value type
|
|
|
|
@return copy of the JSON value, converted to @a ValueType
|
|
|
|
@throw what @ref json_serializer<ValueType> `from_json()` method throws
|
|
|
|
@liveexample{The example below shows several conversions from JSON values
|
|
to other types. There a few things to note: (1) Floating-point numbers can
|
|
be converted to integers\, (2) A JSON array can be converted to a standard
|
|
`std::vector<short>`\, (3) A JSON object can be converted to C++
|
|
associative containers such as `std::unordered_map<std::string\,
|
|
json>`.,get__ValueType_const}
|
|
|
|
@since version 2.1.0
|
|
*/
|
|
template < typename ValueType,
|
|
detail::enable_if_t <
|
|
detail::is_default_constructible<ValueType>::value&&
|
|
detail::has_from_json<basic_json_t, ValueType>::value,
|
|
int > = 0 >
|
|
ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
|
|
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
|
|
{
|
|
auto ret = ValueType();
|
|
JSONSerializer<ValueType>::from_json(*this, ret);
|
|
return ret;
|
|
}
|
|
|
|
/*!
|
|
@brief get a value (explicit); special case
|
|
|
|
Explicit type conversion between the JSON value and a compatible value
|
|
which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
|
|
and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
|
|
The value is converted by calling the @ref json_serializer<ValueType>
|
|
`from_json()` method.
|
|
|
|
The function is equivalent to executing
|
|
@code {.cpp}
|
|
return JSONSerializer<ValueType>::from_json(*this);
|
|
@endcode
|
|
|
|
This overloads is chosen if:
|
|
- @a ValueType is not @ref basic_json and
|
|
- @ref json_serializer<ValueType> has a `from_json()` method of the form
|
|
`ValueType from_json(const basic_json&)`
|
|
|
|
@note If @ref json_serializer<ValueType> has both overloads of
|
|
`from_json()`, this one is chosen.
|
|
|
|
@tparam ValueType the returned value type
|
|
|
|
@return copy of the JSON value, converted to @a ValueType
|
|
|
|
@throw what @ref json_serializer<ValueType> `from_json()` method throws
|
|
|
|
@since version 2.1.0
|
|
*/
|
|
template < typename ValueType,
|
|
detail::enable_if_t <
|
|
detail::has_non_default_from_json<basic_json_t, ValueType>::value,
|
|
int > = 0 >
|
|
ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
|
|
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
|
|
{
|
|
return JSONSerializer<ValueType>::from_json(*this);
|
|
}
|
|
|
|
/*!
|
|
@brief get special-case overload
|
|
|
|
This overloads converts the current @ref basic_json in a different
|
|
@ref basic_json type
|
|
|
|
@tparam BasicJsonType == @ref basic_json
|
|
|
|
@return a copy of *this, converted into @a BasicJsonType
|
|
|
|
@complexity Depending on the implementation of the called `from_json()`
|
|
method.
|
|
|
|
@since version 3.2.0
|
|
*/
|
|
template < typename BasicJsonType,
|
|
detail::enable_if_t <
|
|
detail::is_basic_json<BasicJsonType>::value,
|
|
int > = 0 >
|
|
BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
@brief get special-case overload
|
|
|
|
This overloads avoids a lot of template boilerplate, it can be seen as the
|
|
identity method
|
|
|
|
@tparam BasicJsonType == @ref basic_json
|
|
|
|
@return a copy of *this
|
|
|
|
@complexity Constant.
|
|
|
|
@since version 2.1.0
|
|
*/
|
|
template<typename BasicJsonType,
|
|
detail::enable_if_t<
|
|
std::is_same<BasicJsonType, basic_json_t>::value,
|
|
int> = 0>
|
|
basic_json get_impl(detail::priority_tag<3> /*unused*/) const
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
/*!
|
|
@brief get a pointer value (explicit)
|
|
@copydoc get()
|
|
*/
|
|
template<typename PointerType,
|
|
detail::enable_if_t<
|
|
std::is_pointer<PointerType>::value,
|
|
int> = 0>
|
|
constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
|
|
-> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
|
|
{
|
|
// delegate the call to get_ptr
|
|
return get_ptr<PointerType>();
|
|
}
|
|
|
|
public:
|
|
/*!
|
|
@brief get a (pointer) value (explicit)
|
|
|
|
Performs explicit type conversion between the JSON value and a compatible value if required.
|
|
|
|
- If the requested type is a pointer to the internally stored JSON value that pointer is returned.
|
|
No copies are made.
|
|
|
|
- If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
|
|
from the current @ref basic_json.
|
|
|
|
- Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
|
|
method.
|
|
|
|
@tparam ValueTypeCV the provided value type
|
|
@tparam ValueType the returned value type
|
|
|
|
@return copy of the JSON value, converted to @tparam ValueType if necessary
|
|
|
|
@throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
|
|
|
|
@since version 2.1.0
|
|
*/
|
|
template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
|
|
#if defined(JSON_HAS_CPP_14)
|
|
constexpr
|
|
#endif
|
|
auto get() const noexcept(
|
|
noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
|
|
-> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
|
|
{
|
|
// we cannot static_assert on ValueTypeCV being non-const, because
|
|
// there is support for get<const basic_json_t>(), which is why we
|
|
// still need the uncvref
|
|
static_assert(!std::is_reference<ValueTypeCV>::value,
|
|
"get() cannot be used with reference types, you might want to use get_ref()");
|
|
return get_impl<ValueType>(detail::priority_tag<4> {});
|
|
}
|
|
|
|
/*!
|
|
@brief get a pointer value (explicit)
|
|
|
|
Explicit pointer access to the internally stored JSON value. No copies are
|
|
made.
|
|
|
|
@warning The pointer becomes invalid if the underlying JSON object
|
|
changes.
|
|
|
|
@tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
|
|
object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
|
|
@ref number_unsigned_t, or @ref number_float_t.
|
|
|
|
@return pointer to the internally stored JSON value if the requested
|
|
pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
|
|
|
|
@complexity Constant.
|
|
|
|
@liveexample{The example below shows how pointers to internal values of a
|
|
JSON value can be requested. Note that no type conversions are made and a
|
|
`nullptr` is returned if the value and the requested pointer type does not
|
|
match.,get__PointerType}
|
|
|
|
@sa see @ref get_ptr() for explicit pointer-member access
|
|
|
|
@since version 1.0.0
|
|
*/
|
|
template<typename PointerType, typename std::enable_if<
|
|
std::is_pointer<PointerType>::value, int>::type = 0>
|
|
auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
|
|
{
|
|
// delegate the call to get_ptr
|
|
return get_ptr<PointerType>();
|
|
}
|
|
|
|
/// @brief get a value (explicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_to/
|
|
template < typename ValueType,
|
|
detail::enable_if_t <
|
|
!detail::is_basic_json<ValueType>::value&&
|
|
detail::has_from_json<basic_json_t, ValueType>::value,
|
|
int > = 0 >
|
|
ValueType & get_to(ValueType& v) const noexcept(noexcept(
|
|
JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
|
|
{
|
|
JSONSerializer<ValueType>::from_json(*this, v);
|
|
return v;
|
|
}
|
|
|
|
// specialization to allow calling get_to with a basic_json value
|
|
// see https://github.com/nlohmann/json/issues/2175
|
|
template<typename ValueType,
|
|
detail::enable_if_t <
|
|
detail::is_basic_json<ValueType>::value,
|
|
int> = 0>
|
|
ValueType & get_to(ValueType& v) const
|
|
{
|
|
v = *this;
|
|
return v;
|
|
}
|
|
|
|
template <
|
|
typename T, std::size_t N,
|
|
typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
detail::enable_if_t <
|
|
detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
|
|
Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
noexcept(noexcept(JSONSerializer<Array>::from_json(
|
|
std::declval<const basic_json_t&>(), v)))
|
|
{
|
|
JSONSerializer<Array>::from_json(*this, v);
|
|
return v;
|
|
}
|
|
|
|
/// @brief get a reference value (implicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ref/
|
|
template<typename ReferenceType, typename std::enable_if<
|
|
std::is_reference<ReferenceType>::value, int>::type = 0>
|
|
ReferenceType get_ref()
|
|
{
|
|
// delegate call to get_ref_impl
|
|
return get_ref_impl<ReferenceType>(*this);
|
|
}
|
|
|
|
/// @brief get a reference value (implicit)
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_ref/
|
|
template < typename ReferenceType, typename std::enable_if <
|
|
std::is_reference<ReferenceType>::value&&
|
|
std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
|
|
ReferenceType get_ref() const
|
|
{
|
|
// delegate call to get_ref_impl
|
|
return get_ref_impl<ReferenceType>(*this);
|
|
}
|
|
|
|
/*!
|
|
@brief get a value (implicit)
|
|
|
|
Implicit type conversion between the JSON value and a compatible value.
|
|
The call is realized by calling @ref get() const.
|
|
|
|
@tparam ValueType non-pointer type compatible to the JSON value, for
|
|
instance `int` for JSON integer numbers, `bool` for JSON booleans, or
|
|
`std::vector` types for JSON arrays. The character type of @ref string_t
|
|
as well as an initializer list of this type is excluded to avoid
|
|
ambiguities as these types implicitly convert to `std::string`.
|
|
|
|
@return copy of the JSON value, converted to type @a ValueType
|
|
|
|
@throw type_error.302 in case passed type @a ValueType is incompatible
|
|
to the JSON value type (e.g., the JSON value is of type boolean, but a
|
|
string is requested); see example below
|
|
|
|
@complexity Linear in the size of the JSON value.
|
|
|
|
@liveexample{The example below shows several conversions from JSON values
|
|
to other types. There a few things to note: (1) Floating-point numbers can
|
|
be converted to integers\, (2) A JSON array can be converted to a standard
|
|
`std::vector<short>`\, (3) A JSON object can be converted to C++
|
|
associative containers such as `std::unordered_map<std::string\,
|
|
json>`.,operator__ValueType}
|
|
|
|
@since version 1.0.0
|
|
*/
|
|
template < typename ValueType, typename std::enable_if <
|
|
detail::conjunction <
|
|
detail::negation<std::is_pointer<ValueType>>,
|
|
detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
|
|
detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
|
|
detail::negation<detail::is_basic_json<ValueType>>,
|
|
detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
|
|
|
|
#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
|
|
detail::negation<std::is_same<ValueType, std::string_view>>,
|
|
#endif
|
|
detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
|
|
>::value, int >::type = 0 >
|
|
JSON_EXPLICIT operator ValueType() const
|
|
{
|
|
// delegate the call to get<>() const
|
|
return get<ValueType>();
|
|
}
|
|
|
|
/// @brief get a binary value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_binary/
|
|
binary_t& get_binary()
|
|
{
|
|
if (!is_binary())
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
|
|
}
|
|
|
|
return *get_ptr<binary_t*>();
|
|
}
|
|
|
|
/// @brief get a binary value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/get_binary/
|
|
const binary_t& get_binary() const
|
|
{
|
|
if (!is_binary())
|
|
{
|
|
JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name()), *this));
|
|
}
|
|
|
|
return *get_ptr<const binary_t*>();
|
|
}
|
|
|
|
/// @}
|
|
|
|
|
|
////////////////////
|
|
// element access //
|
|
////////////////////
|
|
|
|
/// @name element access
|
|
/// Access to the JSON value.
|
|
/// @{
|
|
|
|
/// @brief access specified array element with bounds checking
|
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
|
reference at(size_type idx)
|
|
{
|
|
// at only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
JSON_TRY
|
|
{
|
|
return set_parent(m_value.array->at(idx));
|
|
}
|
|
JSON_CATCH (std::out_of_range&)
|
|
{
|
|
// create better exception explanation
|
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief access specified array element with bounds checking
|
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
|
const_reference at(size_type idx) const
|
|
{
|
|
// at only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
JSON_TRY
|
|
{
|
|
return m_value.array->at(idx);
|
|
}
|
|
JSON_CATCH (std::out_of_range&)
|
|
{
|
|
// create better exception explanation
|
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief access specified object element with bounds checking
|
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
|
reference at(const typename object_t::key_type& key)
|
|
{
|
|
// at only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
JSON_TRY
|
|
{
|
|
return set_parent(m_value.object->at(key));
|
|
}
|
|
JSON_CATCH (std::out_of_range&)
|
|
{
|
|
// create better exception explanation
|
|
JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief access specified object element with bounds checking
|
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
|
const_reference at(const typename object_t::key_type& key) const
|
|
{
|
|
// at only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
JSON_TRY
|
|
{
|
|
return m_value.object->at(key);
|
|
}
|
|
JSON_CATCH (std::out_of_range&)
|
|
{
|
|
// create better exception explanation
|
|
JSON_THROW(out_of_range::create(403, "key '" + key + "' not found", *this));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief access specified array element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
reference operator[](size_type idx)
|
|
{
|
|
// implicitly convert null value to an empty array
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::array;
|
|
m_value.array = create<array_t>();
|
|
assert_invariant();
|
|
}
|
|
|
|
// operator[] only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
// fill up array with null values if given idx is outside range
|
|
if (idx >= m_value.array->size())
|
|
{
|
|
#if JSON_DIAGNOSTICS
|
|
// remember array size & capacity before resizing
|
|
const auto old_size = m_value.array->size();
|
|
const auto old_capacity = m_value.array->capacity();
|
|
#endif
|
|
m_value.array->resize(idx + 1);
|
|
|
|
#if JSON_DIAGNOSTICS
|
|
if (JSON_HEDLEY_UNLIKELY(m_value.array->capacity() != old_capacity))
|
|
{
|
|
// capacity has changed: update all parents
|
|
set_parents();
|
|
}
|
|
else
|
|
{
|
|
// set parent for values added above
|
|
set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
|
|
}
|
|
#endif
|
|
assert_invariant();
|
|
}
|
|
|
|
return m_value.array->operator[](idx);
|
|
}
|
|
|
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified array element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
const_reference operator[](size_type idx) const
|
|
{
|
|
// const operator[] only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
return m_value.array->operator[](idx);
|
|
}
|
|
|
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
reference operator[](const typename object_t::key_type& key)
|
|
{
|
|
// implicitly convert null value to an empty object
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::object;
|
|
m_value.object = create<object_t>();
|
|
assert_invariant();
|
|
}
|
|
|
|
// operator[] only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
return set_parent(m_value.object->operator[](key));
|
|
}
|
|
|
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
const_reference operator[](const typename object_t::key_type& key) const
|
|
{
|
|
// const operator[] only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
|
|
return m_value.object->find(key)->second;
|
|
}
|
|
|
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
template<typename T>
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
reference operator[](T* key)
|
|
{
|
|
// implicitly convert null to object
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::object;
|
|
m_value = value_t::object;
|
|
assert_invariant();
|
|
}
|
|
|
|
// at only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
return set_parent(m_value.object->operator[](key));
|
|
}
|
|
|
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
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()))
|
|
{
|
|
JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
|
|
return m_value.object->find(key)->second;
|
|
}
|
|
|
|
JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element with default value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
|
/// using std::is_convertible in a std::enable_if will fail when using explicit conversions
|
|
template < class ValueType, typename std::enable_if <
|
|
detail::is_getable<basic_json_t, ValueType>::value
|
|
&& !std::is_same<value_t, ValueType>::value, int >::type = 0 >
|
|
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 key is found, return value and given default value otherwise
|
|
const auto it = find(key);
|
|
if (it != end())
|
|
{
|
|
return it->template get<ValueType>();
|
|
}
|
|
|
|
return default_value;
|
|
}
|
|
|
|
JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element with default value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
|
/// overload for a default value of type const char*
|
|
string_t value(const typename object_t::key_type& key, const char* default_value) const
|
|
{
|
|
return value(key, string_t(default_value));
|
|
}
|
|
|
|
/// @brief access specified object element via JSON Pointer with default value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
|
template<class ValueType, typename std::enable_if<
|
|
detail::is_getable<basic_json_t, ValueType>::value, int>::type = 0>
|
|
ValueType value(const json_pointer& ptr, const ValueType& default_value) const
|
|
{
|
|
// at only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
// if pointer resolves a value, return it or use default value
|
|
JSON_TRY
|
|
{
|
|
return ptr.get_checked(this).template get<ValueType>();
|
|
}
|
|
JSON_INTERNAL_CATCH (out_of_range&)
|
|
{
|
|
return default_value;
|
|
}
|
|
}
|
|
|
|
JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief access specified object element via JSON Pointer with default value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/value/
|
|
/// overload for a default value of type const char*
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
string_t value(const json_pointer& ptr, const char* default_value) const
|
|
{
|
|
return value(ptr, string_t(default_value));
|
|
}
|
|
|
|
/// @brief access the first element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/front/
|
|
reference front()
|
|
{
|
|
return *begin();
|
|
}
|
|
|
|
/// @brief access the first element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/front/
|
|
const_reference front() const
|
|
{
|
|
return *cbegin();
|
|
}
|
|
|
|
/// @brief access the last element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/back/
|
|
reference back()
|
|
{
|
|
auto tmp = end();
|
|
--tmp;
|
|
return *tmp;
|
|
}
|
|
|
|
/// @brief access the last element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/back/
|
|
const_reference back() const
|
|
{
|
|
auto tmp = cend();
|
|
--tmp;
|
|
return *tmp;
|
|
}
|
|
|
|
/// @brief remove element given an iterator
|
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
|
template < class IteratorType, typename std::enable_if <
|
|
std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
|
|
std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
|
|
= 0 >
|
|
IteratorType erase(IteratorType pos)
|
|
{
|
|
// make sure iterator fits the current value
|
|
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
|
}
|
|
|
|
IteratorType result = end();
|
|
|
|
switch (m_type)
|
|
{
|
|
case value_t::boolean:
|
|
case value_t::number_float:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::string:
|
|
case value_t::binary:
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(205, "iterator out of range", *this));
|
|
}
|
|
|
|
if (is_string())
|
|
{
|
|
AllocatorType<string_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
|
|
m_value.string = nullptr;
|
|
}
|
|
else if (is_binary())
|
|
{
|
|
AllocatorType<binary_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
|
|
m_value.binary = nullptr;
|
|
}
|
|
|
|
m_type = value_t::null;
|
|
assert_invariant();
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @brief remove elements given an iterator range
|
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
|
template < class IteratorType, typename std::enable_if <
|
|
std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
|
|
std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
|
|
= 0 >
|
|
IteratorType erase(IteratorType first, IteratorType last)
|
|
{
|
|
// make sure iterator fits the current value
|
|
if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", *this));
|
|
}
|
|
|
|
IteratorType result = end();
|
|
|
|
switch (m_type)
|
|
{
|
|
case value_t::boolean:
|
|
case value_t::number_float:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::string:
|
|
case value_t::binary:
|
|
{
|
|
if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
|
|
|| !last.m_it.primitive_iterator.is_end()))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(204, "iterators out of range", *this));
|
|
}
|
|
|
|
if (is_string())
|
|
{
|
|
AllocatorType<string_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
|
|
m_value.string = nullptr;
|
|
}
|
|
else if (is_binary())
|
|
{
|
|
AllocatorType<binary_t> alloc;
|
|
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
|
|
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
|
|
m_value.binary = nullptr;
|
|
}
|
|
|
|
m_type = value_t::null;
|
|
assert_invariant();
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
|
|
last.m_it.object_iterator);
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
|
|
last.m_it.array_iterator);
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::discarded:
|
|
default:
|
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @brief remove element from a JSON object given a key
|
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
|
size_type erase(const typename object_t::key_type& key)
|
|
{
|
|
// this erase only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
return m_value.object->erase(key);
|
|
}
|
|
|
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief remove element from a JSON array given an index
|
|
/// @sa https://json.nlohmann.me/api/basic_json/erase/
|
|
void erase(const size_type idx)
|
|
{
|
|
// this erase only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
if (JSON_HEDLEY_UNLIKELY(idx >= size()))
|
|
{
|
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", *this));
|
|
}
|
|
|
|
m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @}
|
|
|
|
|
|
////////////
|
|
// lookup //
|
|
////////////
|
|
|
|
/// @name lookup
|
|
/// @{
|
|
|
|
/// @brief find an element in a JSON object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/find/
|
|
template<typename KeyT>
|
|
iterator find(KeyT&& key)
|
|
{
|
|
auto result = end();
|
|
|
|
if (is_object())
|
|
{
|
|
result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @brief find an element in a JSON object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/find/
|
|
template<typename KeyT>
|
|
const_iterator find(KeyT&& key) const
|
|
{
|
|
auto result = cend();
|
|
|
|
if (is_object())
|
|
{
|
|
result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @brief returns the number of occurrences of a key in a JSON object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/count/
|
|
template<typename KeyT>
|
|
size_type count(KeyT&& key) const
|
|
{
|
|
// return 0 for all nonobject types
|
|
return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
|
|
}
|
|
|
|
/// @brief check the existence of an element in a JSON object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/contains/
|
|
template < typename KeyT, typename std::enable_if <
|
|
!std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
|
|
bool contains(KeyT && key) const
|
|
{
|
|
return is_object() && 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
|
|
/// @sa https://json.nlohmann.me/api/basic_json/contains/
|
|
bool contains(const json_pointer& ptr) const
|
|
{
|
|
return ptr.contains(this);
|
|
}
|
|
|
|
/// @}
|
|
|
|
|
|
///////////////
|
|
// iterators //
|
|
///////////////
|
|
|
|
/// @name iterators
|
|
/// @{
|
|
|
|
/// @brief returns an iterator to the first element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/begin/
|
|
iterator begin() noexcept
|
|
{
|
|
iterator result(this);
|
|
result.set_begin();
|
|
return result;
|
|
}
|
|
|
|
/// @brief returns an iterator to the first element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/begin/
|
|
const_iterator begin() const noexcept
|
|
{
|
|
return cbegin();
|
|
}
|
|
|
|
/// @brief returns a const iterator to the first element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/cbegin/
|
|
const_iterator cbegin() const noexcept
|
|
{
|
|
const_iterator result(this);
|
|
result.set_begin();
|
|
return result;
|
|
}
|
|
|
|
/// @brief returns an iterator to one past the last element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/end/
|
|
iterator end() noexcept
|
|
{
|
|
iterator result(this);
|
|
result.set_end();
|
|
return result;
|
|
}
|
|
|
|
/// @brief returns an iterator to one past the last element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/end/
|
|
const_iterator end() const noexcept
|
|
{
|
|
return cend();
|
|
}
|
|
|
|
/// @brief returns an iterator to one past the last element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/cend/
|
|
const_iterator cend() const noexcept
|
|
{
|
|
const_iterator result(this);
|
|
result.set_end();
|
|
return result;
|
|
}
|
|
|
|
/// @brief returns an iterator to the reverse-beginning
|
|
/// @sa https://json.nlohmann.me/api/basic_json/rbegin/
|
|
reverse_iterator rbegin() noexcept
|
|
{
|
|
return reverse_iterator(end());
|
|
}
|
|
|
|
/// @brief returns an iterator to the reverse-beginning
|
|
/// @sa https://json.nlohmann.me/api/basic_json/rbegin/
|
|
const_reverse_iterator rbegin() const noexcept
|
|
{
|
|
return crbegin();
|
|
}
|
|
|
|
/// @brief returns an iterator to the reverse-end
|
|
/// @sa https://json.nlohmann.me/api/basic_json/rend/
|
|
reverse_iterator rend() noexcept
|
|
{
|
|
return reverse_iterator(begin());
|
|
}
|
|
|
|
/// @brief returns an iterator to the reverse-end
|
|
/// @sa https://json.nlohmann.me/api/basic_json/rend/
|
|
const_reverse_iterator rend() const noexcept
|
|
{
|
|
return crend();
|
|
}
|
|
|
|
/// @brief returns a const reverse iterator to the last element
|
|
/// @sa https://json.nlohmann.me/api/basic_json/crbegin/
|
|
const_reverse_iterator crbegin() const noexcept
|
|
{
|
|
return const_reverse_iterator(cend());
|
|
}
|
|
|
|
/// @brief returns a const reverse iterator to one before the first
|
|
/// @sa https://json.nlohmann.me/api/basic_json/crend/
|
|
const_reverse_iterator crend() const noexcept
|
|
{
|
|
return const_reverse_iterator(cbegin());
|
|
}
|
|
|
|
public:
|
|
/// @brief wrapper to access iterator member functions in range-based for
|
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
|
/// @deprecated This function is deprecated since 3.1.0 and will be removed in
|
|
/// version 4.0.0 of the library. Please use @ref items() instead;
|
|
/// that is, replace `json::iterator_wrapper(j)` with `j.items()`.
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
|
|
static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
|
|
{
|
|
return ref.items();
|
|
}
|
|
|
|
/// @brief wrapper to access iterator member functions in range-based for
|
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
|
/// @deprecated This function is deprecated since 3.1.0 and will be removed in
|
|
/// version 4.0.0 of the library. Please use @ref items() instead;
|
|
/// that is, replace `json::iterator_wrapper(j)` with `j.items()`.
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
|
|
static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
|
|
{
|
|
return ref.items();
|
|
}
|
|
|
|
/// @brief helper to access iterator member functions in range-based for
|
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
|
iteration_proxy<iterator> items() noexcept
|
|
{
|
|
return iteration_proxy<iterator>(*this);
|
|
}
|
|
|
|
/// @brief helper to access iterator member functions in range-based for
|
|
/// @sa https://json.nlohmann.me/api/basic_json/items/
|
|
iteration_proxy<const_iterator> items() const noexcept
|
|
{
|
|
return iteration_proxy<const_iterator>(*this);
|
|
}
|
|
|
|
/// @}
|
|
|
|
|
|
//////////////
|
|
// capacity //
|
|
//////////////
|
|
|
|
/// @name capacity
|
|
/// @{
|
|
|
|
/// @brief checks whether the container is empty.
|
|
/// @sa https://json.nlohmann.me/api/basic_json/empty/
|
|
bool empty() const noexcept
|
|
{
|
|
switch (m_type)
|
|
{
|
|
case value_t::null:
|
|
{
|
|
// null values are empty
|
|
return true;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
// delegate call to array_t::empty()
|
|
return m_value.array->empty();
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
// delegate call to object_t::empty()
|
|
return m_value.object->empty();
|
|
}
|
|
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
// all other types are nonempty
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @brief returns the number of elements
|
|
/// @sa https://json.nlohmann.me/api/basic_json/size/
|
|
size_type size() const noexcept
|
|
{
|
|
switch (m_type)
|
|
{
|
|
case value_t::null:
|
|
{
|
|
// null values are empty
|
|
return 0;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
// delegate call to array_t::size()
|
|
return m_value.array->size();
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
// delegate call to object_t::size()
|
|
return m_value.object->size();
|
|
}
|
|
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
// all other types have size 1
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @brief returns the maximum possible number of elements
|
|
/// @sa https://json.nlohmann.me/api/basic_json/max_size/
|
|
size_type max_size() const noexcept
|
|
{
|
|
switch (m_type)
|
|
{
|
|
case value_t::array:
|
|
{
|
|
// delegate call to array_t::max_size()
|
|
return m_value.array->max_size();
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
// delegate call to object_t::max_size()
|
|
return m_value.object->max_size();
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
// all other types have max_size() == size()
|
|
return size();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @}
|
|
|
|
|
|
///////////////
|
|
// modifiers //
|
|
///////////////
|
|
|
|
/// @name modifiers
|
|
/// @{
|
|
|
|
/// @brief clears the contents
|
|
/// @sa https://json.nlohmann.me/api/basic_json/clear/
|
|
void clear() noexcept
|
|
{
|
|
switch (m_type)
|
|
{
|
|
case value_t::number_integer:
|
|
{
|
|
m_value.number_integer = 0;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_unsigned:
|
|
{
|
|
m_value.number_unsigned = 0;
|
|
break;
|
|
}
|
|
|
|
case value_t::number_float:
|
|
{
|
|
m_value.number_float = 0.0;
|
|
break;
|
|
}
|
|
|
|
case value_t::boolean:
|
|
{
|
|
m_value.boolean = false;
|
|
break;
|
|
}
|
|
|
|
case value_t::string:
|
|
{
|
|
m_value.string->clear();
|
|
break;
|
|
}
|
|
|
|
case value_t::binary:
|
|
{
|
|
m_value.binary->clear();
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
m_value.array->clear();
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
m_value.object->clear();
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::discarded:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// @brief add an object to an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
|
void push_back(basic_json&& val)
|
|
{
|
|
// push_back only works for null objects or arrays
|
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
|
{
|
|
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// transform null object into an array
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::array;
|
|
m_value = value_t::array;
|
|
assert_invariant();
|
|
}
|
|
|
|
// add element to array (move semantics)
|
|
const auto old_capacity = m_value.array->capacity();
|
|
m_value.array->push_back(std::move(val));
|
|
set_parent(m_value.array->back(), old_capacity);
|
|
// if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
|
|
}
|
|
|
|
/// @brief add an object to an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
|
reference operator+=(basic_json&& val)
|
|
{
|
|
push_back(std::move(val));
|
|
return *this;
|
|
}
|
|
|
|
/// @brief add an object to an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
|
void push_back(const basic_json& val)
|
|
{
|
|
// push_back only works for null objects or arrays
|
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
|
{
|
|
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// transform null object into an array
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::array;
|
|
m_value = value_t::array;
|
|
assert_invariant();
|
|
}
|
|
|
|
// add element to array
|
|
const auto old_capacity = m_value.array->capacity();
|
|
m_value.array->push_back(val);
|
|
set_parent(m_value.array->back(), old_capacity);
|
|
}
|
|
|
|
/// @brief add an object to an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
|
reference operator+=(const basic_json& val)
|
|
{
|
|
push_back(val);
|
|
return *this;
|
|
}
|
|
|
|
/// @brief add an object to an object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
|
void push_back(const typename object_t::value_type& val)
|
|
{
|
|
// push_back only works for null objects or objects
|
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
|
|
{
|
|
JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// transform null object into an object
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::object;
|
|
m_value = value_t::object;
|
|
assert_invariant();
|
|
}
|
|
|
|
// add element to object
|
|
auto res = m_value.object->insert(val);
|
|
set_parent(res.first->second);
|
|
}
|
|
|
|
/// @brief add an object to an object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
|
reference operator+=(const typename object_t::value_type& val)
|
|
{
|
|
push_back(val);
|
|
return *this;
|
|
}
|
|
|
|
/// @brief add an object to an object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/push_back/
|
|
void push_back(initializer_list_t init)
|
|
{
|
|
if (is_object() && init.size() == 2 && (*init.begin())->is_string())
|
|
{
|
|
basic_json&& key = init.begin()->moved_or_copied();
|
|
push_back(typename object_t::value_type(
|
|
std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
|
|
}
|
|
else
|
|
{
|
|
push_back(basic_json(init));
|
|
}
|
|
}
|
|
|
|
/// @brief add an object to an object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator+=/
|
|
reference operator+=(initializer_list_t init)
|
|
{
|
|
push_back(init);
|
|
return *this;
|
|
}
|
|
|
|
/// @brief add an object to an array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
|
|
template<class... Args>
|
|
reference emplace_back(Args&& ... args)
|
|
{
|
|
// emplace_back only works for null objects or arrays
|
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
|
|
{
|
|
JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// transform null object into an array
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::array;
|
|
m_value = value_t::array;
|
|
assert_invariant();
|
|
}
|
|
|
|
// add element to array (perfect forwarding)
|
|
const auto old_capacity = m_value.array->capacity();
|
|
m_value.array->emplace_back(std::forward<Args>(args)...);
|
|
return set_parent(m_value.array->back(), old_capacity);
|
|
}
|
|
|
|
/// @brief add an object to an object if key does not exist
|
|
/// @sa https://json.nlohmann.me/api/basic_json/emplace/
|
|
template<class... Args>
|
|
std::pair<iterator, bool> emplace(Args&& ... args)
|
|
{
|
|
// emplace only works for null objects or arrays
|
|
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
|
|
{
|
|
JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// transform null object into an object
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::object;
|
|
m_value = value_t::object;
|
|
assert_invariant();
|
|
}
|
|
|
|
// add element to array (perfect forwarding)
|
|
auto res = m_value.object->emplace(std::forward<Args>(args)...);
|
|
set_parent(res.first->second);
|
|
|
|
// create result iterator and set iterator to the result of emplace
|
|
auto it = begin();
|
|
it.m_it.object_iterator = res.first;
|
|
|
|
// return pair of iterator and boolean
|
|
return {it, res.second};
|
|
}
|
|
|
|
/// Helper for insertion of an iterator
|
|
/// @note: This uses std::distance to support GCC 4.8,
|
|
/// see https://github.com/nlohmann/json/pull/1257
|
|
template<typename... Args>
|
|
iterator insert_iterator(const_iterator pos, Args&& ... args)
|
|
{
|
|
iterator result(this);
|
|
JSON_ASSERT(m_value.array != nullptr);
|
|
|
|
auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
|
|
m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
|
|
result.m_it.array_iterator = m_value.array->begin() + insert_pos;
|
|
|
|
// This could have been written as:
|
|
// result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
|
|
// but the return value of insert is missing in GCC 4.8, so it is written this way instead.
|
|
|
|
set_parents();
|
|
return result;
|
|
}
|
|
|
|
/// @brief inserts element into array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
|
iterator insert(const_iterator pos, const basic_json& val)
|
|
{
|
|
// insert only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
// check if iterator pos fits to this JSON value
|
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
|
}
|
|
|
|
// insert to array and return iterator
|
|
return insert_iterator(pos, val);
|
|
}
|
|
|
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief inserts element into array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
|
iterator insert(const_iterator pos, basic_json&& val)
|
|
{
|
|
return insert(pos, val);
|
|
}
|
|
|
|
/// @brief inserts copies of element into array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
|
iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
|
|
{
|
|
// insert only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
// check if iterator pos fits to this JSON value
|
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
|
}
|
|
|
|
// insert to array and return iterator
|
|
return insert_iterator(pos, cnt, val);
|
|
}
|
|
|
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
/// @brief inserts range of elements into array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
|
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
|
|
{
|
|
// insert only works for arrays
|
|
if (JSON_HEDLEY_UNLIKELY(!is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// check if iterator pos fits to this JSON value
|
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
|
}
|
|
|
|
// check if range iterators belong to the same JSON object
|
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", *this));
|
|
}
|
|
|
|
// insert to array and return iterator
|
|
return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
|
|
}
|
|
|
|
/// @brief inserts elements from initializer list into array
|
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
|
iterator insert(const_iterator pos, initializer_list_t ilist)
|
|
{
|
|
// insert only works for arrays
|
|
if (JSON_HEDLEY_UNLIKELY(!is_array()))
|
|
{
|
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// check if iterator pos fits to this JSON value
|
|
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", *this));
|
|
}
|
|
|
|
// insert to array and return iterator
|
|
return insert_iterator(pos, ilist.begin(), ilist.end());
|
|
}
|
|
|
|
/// @brief inserts range of elements into object
|
|
/// @sa https://json.nlohmann.me/api/basic_json/insert/
|
|
void insert(const_iterator first, const_iterator last)
|
|
{
|
|
// insert only works for objects
|
|
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
|
{
|
|
JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// check if range iterators belong to the same JSON object
|
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
|
|
}
|
|
|
|
// passed iterators must belong to objects
|
|
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", *this));
|
|
}
|
|
|
|
m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
|
|
}
|
|
|
|
/// @brief updates a JSON object from another object, overwriting existing keys
|
|
/// @sa https://json.nlohmann.me/api/basic_json/update/
|
|
void update(const_reference j, bool merge_objects = false)
|
|
{
|
|
update(j.begin(), j.end(), merge_objects);
|
|
}
|
|
|
|
/// @brief updates a JSON object from another object, overwriting existing keys
|
|
/// @sa https://json.nlohmann.me/api/basic_json/update/
|
|
void update(const_iterator first, const_iterator last, bool merge_objects = false)
|
|
{
|
|
// implicitly convert null value to an empty object
|
|
if (is_null())
|
|
{
|
|
m_type = value_t::object;
|
|
m_value.object = create<object_t>();
|
|
assert_invariant();
|
|
}
|
|
|
|
if (JSON_HEDLEY_UNLIKELY(!is_object()))
|
|
{
|
|
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name()), *this));
|
|
}
|
|
|
|
// check if range iterators belong to the same JSON object
|
|
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
|
|
{
|
|
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", *this));
|
|
}
|
|
|
|
// passed iterators must belong to objects
|
|
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
|
|
{
|
|
JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(first.m_object->type_name()), *first.m_object));
|
|
}
|
|
|
|
for (auto it = first; it != last; ++it)
|
|
{
|
|
if (merge_objects && it.value().is_object())
|
|
{
|
|
auto it2 = m_value.object->find(it.key());
|
|
if (it2 != m_value.object->end())
|
|
{
|
|
it2->second.update(it.value(), true);
|
|
continue;
|
|
}
|
|
}
|
|
m_value.object->operator[](it.key()) = it.value();
|
|
#if JSON_DIAGNOSTICS
|
|
m_value.object->operator[](it.key()).m_parent = this;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
void swap(reference other) noexcept (
|
|
std::is_nothrow_move_constructible<value_t>::value&&
|
|
std::is_nothrow_move_assignable<value_t>::value&&
|
|
std::is_nothrow_move_constructible<json_value>::value&&
|
|
std::is_nothrow_move_assignable<json_value>::value
|
|
)
|
|
{
|
|
std::swap(m_type, other.m_type);
|
|
std::swap(m_value, other.m_value);
|
|
|
|
set_parents();
|
|
other.set_parents();
|
|
assert_invariant();
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
friend void swap(reference left, reference right) noexcept (
|
|
std::is_nothrow_move_constructible<value_t>::value&&
|
|
std::is_nothrow_move_assignable<value_t>::value&&
|
|
std::is_nothrow_move_constructible<json_value>::value&&
|
|
std::is_nothrow_move_assignable<json_value>::value
|
|
)
|
|
{
|
|
left.swap(right);
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
void swap(array_t& other) // NOLINT(bugprone-exception-escape)
|
|
{
|
|
// swap only works for arrays
|
|
if (JSON_HEDLEY_LIKELY(is_array()))
|
|
{
|
|
std::swap(*(m_value.array), other);
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
void swap(object_t& other) // NOLINT(bugprone-exception-escape)
|
|
{
|
|
// swap only works for objects
|
|
if (JSON_HEDLEY_LIKELY(is_object()))
|
|
{
|
|
std::swap(*(m_value.object), other);
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
void swap(string_t& other) // NOLINT(bugprone-exception-escape)
|
|
{
|
|
// swap only works for strings
|
|
if (JSON_HEDLEY_LIKELY(is_string()))
|
|
{
|
|
std::swap(*(m_value.string), other);
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
void swap(binary_t& other) // NOLINT(bugprone-exception-escape)
|
|
{
|
|
// swap only works for strings
|
|
if (JSON_HEDLEY_LIKELY(is_binary()))
|
|
{
|
|
std::swap(*(m_value.binary), other);
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @brief exchanges the values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/swap/
|
|
void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
|
|
{
|
|
// swap only works for strings
|
|
if (JSON_HEDLEY_LIKELY(is_binary()))
|
|
{
|
|
std::swap(*(m_value.binary), other);
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name()), *this));
|
|
}
|
|
}
|
|
|
|
/// @}
|
|
|
|
public:
|
|
//////////////////////////////////////////
|
|
// lexicographical comparison operators //
|
|
//////////////////////////////////////////
|
|
|
|
/// @name lexicographical comparison operators
|
|
/// @{
|
|
|
|
/// @brief comparison: equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
|
|
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
|
|
{
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wfloat-equal"
|
|
#endif
|
|
const auto lhs_type = lhs.type();
|
|
const auto rhs_type = rhs.type();
|
|
|
|
if (lhs_type == rhs_type)
|
|
{
|
|
switch (lhs_type)
|
|
{
|
|
case value_t::array:
|
|
return *lhs.m_value.array == *rhs.m_value.array;
|
|
|
|
case value_t::object:
|
|
return *lhs.m_value.object == *rhs.m_value.object;
|
|
|
|
case value_t::null:
|
|
return true;
|
|
|
|
case value_t::string:
|
|
return *lhs.m_value.string == *rhs.m_value.string;
|
|
|
|
case value_t::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;
|
|
|
|
case value_t::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;
|
|
|
|
case value_t::binary:
|
|
return *lhs.m_value.binary == *rhs.m_value.binary;
|
|
|
|
case value_t::discarded:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
|
|
{
|
|
return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
|
|
}
|
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
|
|
{
|
|
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
|
|
}
|
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
|
|
{
|
|
return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
|
|
}
|
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
|
|
{
|
|
return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
|
|
}
|
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
|
|
{
|
|
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
|
|
}
|
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
|
|
{
|
|
return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
|
|
}
|
|
|
|
return false;
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
}
|
|
|
|
/// @brief comparison: equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
|
|
{
|
|
return lhs == basic_json(rhs);
|
|
}
|
|
|
|
/// @brief comparison: equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
|
|
{
|
|
return basic_json(lhs) == rhs;
|
|
}
|
|
|
|
/// @brief comparison: not equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
|
|
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
|
|
{
|
|
return !(lhs == rhs);
|
|
}
|
|
|
|
/// @brief comparison: not equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
|
|
{
|
|
return lhs != basic_json(rhs);
|
|
}
|
|
|
|
/// @brief comparison: not equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
|
|
{
|
|
return basic_json(lhs) != rhs;
|
|
}
|
|
|
|
/// @brief comparison: less than
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
|
|
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
|
|
{
|
|
const auto lhs_type = lhs.type();
|
|
const auto rhs_type = rhs.type();
|
|
|
|
if (lhs_type == rhs_type)
|
|
{
|
|
switch (lhs_type)
|
|
{
|
|
case value_t::array:
|
|
// note parentheses are necessary, see
|
|
// https://github.com/nlohmann/json/issues/1530
|
|
return (*lhs.m_value.array) < (*rhs.m_value.array);
|
|
|
|
case value_t::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);
|
|
|
|
case value_t::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);
|
|
|
|
case value_t::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);
|
|
|
|
case value_t::binary:
|
|
return (*lhs.m_value.binary) < (*rhs.m_value.binary);
|
|
|
|
case value_t::discarded:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
|
|
{
|
|
return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
|
|
}
|
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
|
|
{
|
|
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
|
|
}
|
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
|
|
{
|
|
return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
|
|
}
|
|
else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
|
|
{
|
|
return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
|
|
}
|
|
else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
|
|
{
|
|
return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
|
|
}
|
|
else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
|
|
{
|
|
return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
|
|
}
|
|
|
|
// We only reach this line if we cannot compare values. In that case,
|
|
// we compare types. Note we have to call the operator explicitly,
|
|
// because MSVC has problems otherwise.
|
|
return operator<(lhs_type, rhs_type);
|
|
}
|
|
|
|
/// @brief comparison: less than
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
|
|
{
|
|
return lhs < basic_json(rhs);
|
|
}
|
|
|
|
/// @brief comparison: less than
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
|
|
{
|
|
return basic_json(lhs) < rhs;
|
|
}
|
|
|
|
/// @brief comparison: less than or equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
|
|
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
|
|
{
|
|
return !(rhs < lhs);
|
|
}
|
|
|
|
/// @brief comparison: less than or equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
|
|
{
|
|
return lhs <= basic_json(rhs);
|
|
}
|
|
|
|
/// @brief comparison: less than or equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_le/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
|
|
{
|
|
return basic_json(lhs) <= rhs;
|
|
}
|
|
|
|
/// @brief comparison: greater than
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
|
|
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
|
|
{
|
|
return !(lhs <= rhs);
|
|
}
|
|
|
|
/// @brief comparison: greater than
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
|
|
{
|
|
return lhs > basic_json(rhs);
|
|
}
|
|
|
|
/// @brief comparison: greater than
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
|
|
{
|
|
return basic_json(lhs) > rhs;
|
|
}
|
|
|
|
/// @brief comparison: greater than or equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
|
|
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
|
|
{
|
|
return !(lhs < rhs);
|
|
}
|
|
|
|
/// @brief comparison: greater than or equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
|
|
{
|
|
return lhs >= basic_json(rhs);
|
|
}
|
|
|
|
/// @brief comparison: greater than or equal
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
|
|
template<typename ScalarType, typename std::enable_if<
|
|
std::is_scalar<ScalarType>::value, int>::type = 0>
|
|
friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
|
|
{
|
|
return basic_json(lhs) >= rhs;
|
|
}
|
|
|
|
/// @}
|
|
|
|
///////////////////
|
|
// serialization //
|
|
///////////////////
|
|
|
|
/// @name serialization
|
|
/// @{
|
|
#ifndef JSON_NO_IO
|
|
/// @brief serialize to stream
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
|
|
friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
|
|
{
|
|
// read width member and use it as indentation parameter if nonzero
|
|
const bool pretty_print = o.width() > 0;
|
|
const auto indentation = pretty_print ? o.width() : 0;
|
|
|
|
// reset width to 0 for subsequent calls to this stream
|
|
o.width(0);
|
|
|
|
// do the actual serialization
|
|
serializer s(detail::output_adapter<char>(o), o.fill());
|
|
s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
|
|
return o;
|
|
}
|
|
|
|
/// @brief serialize to stream
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
|
|
/// @deprecated This function is deprecated since 3.0.0 and will be removed in
|
|
/// version 4.0.0 of the library. Please use
|
|
/// operator<<(std::ostream&, const basic_json&) instead; that is,
|
|
/// replace calls like `j >> o;` with `o << j;`.
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
|
|
friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
|
|
{
|
|
return o << j;
|
|
}
|
|
#endif // JSON_NO_IO
|
|
/// @}
|
|
|
|
|
|
/////////////////////
|
|
// deserialization //
|
|
/////////////////////
|
|
|
|
/// @name deserialization
|
|
/// @{
|
|
|
|
/// @brief deserialize from a compatible input
|
|
/// @sa https://json.nlohmann.me/api/basic_json/parse/
|
|
template<typename InputType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json parse(InputType&& i,
|
|
const parser_callback_t cb = nullptr,
|
|
const bool allow_exceptions = true,
|
|
const bool ignore_comments = false)
|
|
{
|
|
basic_json result;
|
|
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
|
|
return result;
|
|
}
|
|
|
|
/// @brief deserialize from a pair of character iterators
|
|
/// @sa https://json.nlohmann.me/api/basic_json/parse/
|
|
template<typename IteratorType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json parse(IteratorType first,
|
|
IteratorType last,
|
|
const parser_callback_t cb = nullptr,
|
|
const bool allow_exceptions = true,
|
|
const bool ignore_comments = false)
|
|
{
|
|
basic_json result;
|
|
parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
|
|
return result;
|
|
}
|
|
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
|
|
static basic_json parse(detail::span_input_adapter&& i,
|
|
const parser_callback_t cb = nullptr,
|
|
const bool allow_exceptions = true,
|
|
const bool ignore_comments = false)
|
|
{
|
|
basic_json result;
|
|
parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
|
|
return result;
|
|
}
|
|
|
|
/// @brief check if the input is valid JSON
|
|
/// @sa https://json.nlohmann.me/api/basic_json/accept/
|
|
template<typename InputType>
|
|
static bool accept(InputType&& i,
|
|
const bool ignore_comments = false)
|
|
{
|
|
return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
|
|
}
|
|
|
|
/// @brief check if the input is valid JSON
|
|
/// @sa https://json.nlohmann.me/api/basic_json/accept/
|
|
template<typename IteratorType>
|
|
static bool accept(IteratorType first, IteratorType last,
|
|
const bool ignore_comments = false)
|
|
{
|
|
return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
|
|
}
|
|
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
|
|
static bool accept(detail::span_input_adapter&& i,
|
|
const bool ignore_comments = false)
|
|
{
|
|
return parser(i.get(), nullptr, false, ignore_comments).accept(true);
|
|
}
|
|
|
|
/// @brief generate SAX events
|
|
/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
|
|
template <typename InputType, typename SAX>
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
static bool sax_parse(InputType&& i, SAX* sax,
|
|
input_format_t format = input_format_t::json,
|
|
const bool strict = true,
|
|
const bool ignore_comments = false)
|
|
{
|
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
|
return format == input_format_t::json
|
|
? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
|
|
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
|
|
}
|
|
|
|
/// @brief generate SAX events
|
|
/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
|
|
template<class IteratorType, class SAX>
|
|
JSON_HEDLEY_NON_NULL(3)
|
|
static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
|
|
input_format_t format = input_format_t::json,
|
|
const bool strict = true,
|
|
const bool ignore_comments = false)
|
|
{
|
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
|
return format == input_format_t::json
|
|
? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
|
|
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
|
|
}
|
|
|
|
/// @brief generate SAX events
|
|
/// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
|
|
/// @deprecated This function is deprecated since 3.8.0 and will be removed in
|
|
/// version 4.0.0 of the library. Please use
|
|
/// sax_parse(ptr, ptr + len) instead.
|
|
template <typename SAX>
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
|
|
JSON_HEDLEY_NON_NULL(2)
|
|
static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
|
|
input_format_t format = input_format_t::json,
|
|
const bool strict = true,
|
|
const bool ignore_comments = false)
|
|
{
|
|
auto ia = i.get();
|
|
return format == input_format_t::json
|
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
|
? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
|
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
|
: detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
|
|
}
|
|
#ifndef JSON_NO_IO
|
|
/// @brief deserialize from stream
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
|
|
/// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
|
|
/// version 4.0.0 of the library. Please use
|
|
/// operator>>(std::istream&, basic_json&) instead; that is,
|
|
/// replace calls like `j << i;` with `i >> j;`.
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
|
|
friend std::istream& operator<<(basic_json& j, std::istream& i)
|
|
{
|
|
return operator>>(i, j);
|
|
}
|
|
|
|
/// @brief deserialize from stream
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
|
|
friend std::istream& operator>>(std::istream& i, basic_json& j)
|
|
{
|
|
parser(detail::input_adapter(i)).parse(false, j);
|
|
return i;
|
|
}
|
|
#endif // JSON_NO_IO
|
|
/// @}
|
|
|
|
///////////////////////////
|
|
// convenience functions //
|
|
///////////////////////////
|
|
|
|
/// @brief return the type as string
|
|
/// @sa https://json.nlohmann.me/api/basic_json/type_name/
|
|
JSON_HEDLEY_RETURNS_NON_NULL
|
|
const char* type_name() const noexcept
|
|
{
|
|
switch (m_type)
|
|
{
|
|
case value_t::null:
|
|
return "null";
|
|
case value_t::object:
|
|
return "object";
|
|
case value_t::array:
|
|
return "array";
|
|
case value_t::string:
|
|
return "string";
|
|
case value_t::boolean:
|
|
return "boolean";
|
|
case value_t::binary:
|
|
return "binary";
|
|
case value_t::discarded:
|
|
return "discarded";
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
default:
|
|
return "number";
|
|
}
|
|
}
|
|
|
|
|
|
JSON_PRIVATE_UNLESS_TESTED:
|
|
//////////////////////
|
|
// member variables //
|
|
//////////////////////
|
|
|
|
/// the type of the current element
|
|
value_t m_type = value_t::null;
|
|
|
|
/// the value of the current element
|
|
json_value m_value = {};
|
|
|
|
#if JSON_DIAGNOSTICS
|
|
/// a pointer to a parent value (for debugging purposes)
|
|
basic_json* m_parent = nullptr;
|
|
#endif
|
|
|
|
//////////////////////////////////////////
|
|
// binary serialization/deserialization //
|
|
//////////////////////////////////////////
|
|
|
|
/// @name binary serialization/deserialization support
|
|
/// @{
|
|
|
|
public:
|
|
/// @brief create a CBOR serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
|
|
static std::vector<std::uint8_t> to_cbor(const basic_json& j)
|
|
{
|
|
std::vector<std::uint8_t> result;
|
|
to_cbor(j, result);
|
|
return result;
|
|
}
|
|
|
|
/// @brief create a CBOR serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
|
|
static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
|
|
{
|
|
binary_writer<std::uint8_t>(o).write_cbor(j);
|
|
}
|
|
|
|
/// @brief create a CBOR serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
|
|
static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
|
|
{
|
|
binary_writer<char>(o).write_cbor(j);
|
|
}
|
|
|
|
/// @brief create a MessagePack serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
|
|
static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
|
|
{
|
|
std::vector<std::uint8_t> result;
|
|
to_msgpack(j, result);
|
|
return result;
|
|
}
|
|
|
|
/// @brief create a MessagePack serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
|
|
static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
|
|
{
|
|
binary_writer<std::uint8_t>(o).write_msgpack(j);
|
|
}
|
|
|
|
/// @brief create a MessagePack serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
|
|
static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
|
|
{
|
|
binary_writer<char>(o).write_msgpack(j);
|
|
}
|
|
|
|
/// @brief create a UBJSON serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
|
|
static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
|
|
const bool use_size = false,
|
|
const bool use_type = false)
|
|
{
|
|
std::vector<std::uint8_t> result;
|
|
to_ubjson(j, result, use_size, use_type);
|
|
return result;
|
|
}
|
|
|
|
/// @brief create a UBJSON serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
|
|
static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
|
|
const bool use_size = false, const bool use_type = false)
|
|
{
|
|
binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
|
|
}
|
|
|
|
/// @brief create a UBJSON serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
|
|
static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
|
|
const bool use_size = false, const bool use_type = false)
|
|
{
|
|
binary_writer<char>(o).write_ubjson(j, use_size, use_type);
|
|
}
|
|
|
|
/// @brief create a BSON serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
|
|
static std::vector<std::uint8_t> to_bson(const basic_json& j)
|
|
{
|
|
std::vector<std::uint8_t> result;
|
|
to_bson(j, result);
|
|
return result;
|
|
}
|
|
|
|
/// @brief create a BSON serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
|
|
static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
|
|
{
|
|
binary_writer<std::uint8_t>(o).write_bson(j);
|
|
}
|
|
|
|
/// @brief create a BSON serialization of a given JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_bson/
|
|
static void to_bson(const basic_json& j, detail::output_adapter<char> o)
|
|
{
|
|
binary_writer<char>(o).write_bson(j);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in CBOR format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
|
|
template<typename InputType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_cbor(InputType&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true,
|
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in CBOR format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
|
|
template<typename IteratorType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_cbor(IteratorType first, IteratorType last,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true,
|
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
template<typename T>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
|
|
static basic_json from_cbor(const T* ptr, std::size_t len,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true,
|
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
|
{
|
|
return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
|
|
}
|
|
|
|
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
|
|
static basic_json from_cbor(detail::span_input_adapter&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true,
|
|
const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = i.get();
|
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in MessagePack format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
|
|
template<typename InputType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_msgpack(InputType&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in MessagePack format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
|
|
template<typename IteratorType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_msgpack(IteratorType first, IteratorType last,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
template<typename T>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
|
|
static basic_json from_msgpack(const T* ptr, std::size_t len,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
|
|
}
|
|
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
|
|
static basic_json from_msgpack(detail::span_input_adapter&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = i.get();
|
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in UBJSON format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
|
|
template<typename InputType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_ubjson(InputType&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in UBJSON format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
|
|
template<typename IteratorType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_ubjson(IteratorType first, IteratorType last,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
template<typename T>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
|
|
static basic_json from_ubjson(const T* ptr, std::size_t len,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
|
|
}
|
|
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
|
|
static basic_json from_ubjson(detail::span_input_adapter&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = i.get();
|
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in BSON format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_bson/
|
|
template<typename InputType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_bson(InputType&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::forward<InputType>(i));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
/// @brief create a JSON value from an input in BSON format
|
|
/// @sa https://json.nlohmann.me/api/basic_json/from_bson/
|
|
template<typename IteratorType>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json from_bson(IteratorType first, IteratorType last,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = detail::input_adapter(std::move(first), std::move(last));
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
|
|
template<typename T>
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
|
|
static basic_json from_bson(const T* ptr, std::size_t len,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
return from_bson(ptr, ptr + len, strict, allow_exceptions);
|
|
}
|
|
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
|
|
static basic_json from_bson(detail::span_input_adapter&& i,
|
|
const bool strict = true,
|
|
const bool allow_exceptions = true)
|
|
{
|
|
basic_json result;
|
|
detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
|
|
auto ia = i.get();
|
|
// NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
|
|
const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
|
|
return res ? result : basic_json(value_t::discarded);
|
|
}
|
|
/// @}
|
|
|
|
//////////////////////////
|
|
// JSON Pointer support //
|
|
//////////////////////////
|
|
|
|
/// @name JSON Pointer functions
|
|
/// @{
|
|
|
|
/// @brief access specified element via JSON Pointer
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
reference operator[](const json_pointer& ptr)
|
|
{
|
|
return ptr.get_unchecked(this);
|
|
}
|
|
|
|
/// @brief access specified element via JSON Pointer
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
|
|
const_reference operator[](const json_pointer& ptr) const
|
|
{
|
|
return ptr.get_unchecked(this);
|
|
}
|
|
|
|
/// @brief access specified element via JSON Pointer
|
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
|
reference at(const json_pointer& ptr)
|
|
{
|
|
return ptr.get_checked(this);
|
|
}
|
|
|
|
/// @brief access specified element via JSON Pointer
|
|
/// @sa https://json.nlohmann.me/api/basic_json/at/
|
|
const_reference at(const json_pointer& ptr) const
|
|
{
|
|
return ptr.get_checked(this);
|
|
}
|
|
|
|
/// @brief return flattened JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/flatten/
|
|
basic_json flatten() const
|
|
{
|
|
basic_json result(value_t::object);
|
|
json_pointer::flatten("", *this, result);
|
|
return result;
|
|
}
|
|
|
|
/// @brief unflatten a previously flattened JSON value
|
|
/// @sa https://json.nlohmann.me/api/basic_json/unflatten/
|
|
basic_json unflatten() const
|
|
{
|
|
return json_pointer::unflatten(*this);
|
|
}
|
|
|
|
/// @}
|
|
|
|
//////////////////////////
|
|
// JSON Patch functions //
|
|
//////////////////////////
|
|
|
|
/// @name JSON Patch functions
|
|
/// @{
|
|
|
|
/// @brief applies a JSON patch
|
|
/// @sa https://json.nlohmann.me/api/basic_json/patch/
|
|
basic_json patch(const basic_json& json_patch) const
|
|
{
|
|
// make a working copy to apply the patch to
|
|
basic_json result = *this;
|
|
|
|
// the valid JSON Patch operations
|
|
enum class patch_operations {add, remove, replace, move, copy, test, invalid};
|
|
|
|
const auto get_op = [](const std::string & op)
|
|
{
|
|
if (op == "add")
|
|
{
|
|
return patch_operations::add;
|
|
}
|
|
if (op == "remove")
|
|
{
|
|
return patch_operations::remove;
|
|
}
|
|
if (op == "replace")
|
|
{
|
|
return patch_operations::replace;
|
|
}
|
|
if (op == "move")
|
|
{
|
|
return patch_operations::move;
|
|
}
|
|
if (op == "copy")
|
|
{
|
|
return patch_operations::copy;
|
|
}
|
|
if (op == "test")
|
|
{
|
|
return patch_operations::test;
|
|
}
|
|
|
|
return patch_operations::invalid;
|
|
};
|
|
|
|
// wrapper for "add" operation; add value at ptr
|
|
const auto operation_add = [&result](json_pointer & ptr, basic_json val)
|
|
{
|
|
// adding to the root of the target document means replacing it
|
|
if (ptr.empty())
|
|
{
|
|
result = val;
|
|
return;
|
|
}
|
|
|
|
// make sure the top element of the pointer exists
|
|
json_pointer top_pointer = ptr.top();
|
|
if (top_pointer != ptr)
|
|
{
|
|
result.at(top_pointer);
|
|
}
|
|
|
|
// get reference to parent of JSON pointer ptr
|
|
const auto last_path = ptr.back();
|
|
ptr.pop_back();
|
|
basic_json& parent = result[ptr];
|
|
|
|
switch (parent.m_type)
|
|
{
|
|
case value_t::null:
|
|
case value_t::object:
|
|
{
|
|
// use operator[] to add value
|
|
parent[last_path] = val;
|
|
break;
|
|
}
|
|
|
|
case value_t::array:
|
|
{
|
|
if (last_path == "-")
|
|
{
|
|
// special case: append to back
|
|
parent.push_back(val);
|
|
}
|
|
else
|
|
{
|
|
const auto idx = json_pointer::array_index(last_path);
|
|
if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
|
|
{
|
|
// avoid undefined behavior
|
|
JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range", parent));
|
|
}
|
|
|
|
// default case: insert add offset
|
|
parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// if there exists a parent it cannot be primitive
|
|
case value_t::string: // LCOV_EXCL_LINE
|
|
case value_t::boolean: // LCOV_EXCL_LINE
|
|
case value_t::number_integer: // LCOV_EXCL_LINE
|
|
case value_t::number_unsigned: // LCOV_EXCL_LINE
|
|
case value_t::number_float: // LCOV_EXCL_LINE
|
|
case value_t::binary: // LCOV_EXCL_LINE
|
|
case value_t::discarded: // LCOV_EXCL_LINE
|
|
default: // LCOV_EXCL_LINE
|
|
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
|
|
}
|
|
};
|
|
|
|
// wrapper for "remove" operation; remove value at ptr
|
|
const auto operation_remove = [this, &result](json_pointer & ptr)
|
|
{
|
|
// get reference to parent of JSON pointer ptr
|
|
const auto last_path = ptr.back();
|
|
ptr.pop_back();
|
|
basic_json& parent = result.at(ptr);
|
|
|
|
// remove child
|
|
if (parent.is_object())
|
|
{
|
|
// perform range check
|
|
auto it = parent.find(last_path);
|
|
if (JSON_HEDLEY_LIKELY(it != parent.end()))
|
|
{
|
|
parent.erase(it);
|
|
}
|
|
else
|
|
{
|
|
JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found", *this));
|
|
}
|
|
}
|
|
else if (parent.is_array())
|
|
{
|
|
// note erase performs range check
|
|
parent.erase(json_pointer::array_index(last_path));
|
|
}
|
|
};
|
|
|
|
// type check: top level value must be an array
|
|
if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
|
|
{
|
|
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", json_patch));
|
|
}
|
|
|
|
// iterate and apply the operations
|
|
for (const auto& val : json_patch)
|
|
{
|
|
// wrapper to get a value for an operation
|
|
const auto get_value = [&val](const std::string & op,
|
|
const std::string & member,
|
|
bool string_type) -> basic_json &
|
|
{
|
|
// find value
|
|
auto it = val.m_value.object->find(member);
|
|
|
|
// context-sensitive error message
|
|
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()))
|
|
{
|
|
// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
|
|
JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'", val));
|
|
}
|
|
|
|
// check if result is of type string
|
|
if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
|
|
{
|
|
// NOLINTNEXTLINE(performance-inefficient-string-concatenation)
|
|
JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'", val));
|
|
}
|
|
|
|
// no error: return value
|
|
return it->second;
|
|
};
|
|
|
|
// type check: every element of the array must be an object
|
|
if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
|
|
{
|
|
JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", val));
|
|
}
|
|
|
|
// collect mandatory members
|
|
const auto op = get_value("op", "op", true).template get<std::string>();
|
|
const auto path = get_value(op, "path", true).template get<std::string>();
|
|
json_pointer ptr(path);
|
|
|
|
switch (get_op(op))
|
|
{
|
|
case patch_operations::add:
|
|
{
|
|
operation_add(ptr, get_value("add", "value", false));
|
|
break;
|
|
}
|
|
|
|
case patch_operations::remove:
|
|
{
|
|
operation_remove(ptr);
|
|
break;
|
|
}
|
|
|
|
case patch_operations::replace:
|
|
{
|
|
// the "path" location must exist - use at()
|
|
result.at(ptr) = get_value("replace", "value", false);
|
|
break;
|
|
}
|
|
|
|
case patch_operations::move:
|
|
{
|
|
const auto from_path = get_value("move", "from", true).template get<std::string>();
|
|
json_pointer from_ptr(from_path);
|
|
|
|
// the "from" location must exist - use at()
|
|
basic_json v = result.at(from_ptr);
|
|
|
|
// The move operation is functionally identical to a
|
|
// "remove" operation on the "from" location, followed
|
|
// immediately by an "add" operation at the target
|
|
// location with the value that was just removed.
|
|
operation_remove(from_ptr);
|
|
operation_add(ptr, v);
|
|
break;
|
|
}
|
|
|
|
case patch_operations::copy:
|
|
{
|
|
const auto from_path = get_value("copy", "from", true).template get<std::string>();
|
|
const json_pointer from_ptr(from_path);
|
|
|
|
// the "from" location must exist - use at()
|
|
basic_json v = result.at(from_ptr);
|
|
|
|
// The copy is functionally identical to an "add"
|
|
// operation at the target location using the value
|
|
// specified in the "from" member.
|
|
operation_add(ptr, v);
|
|
break;
|
|
}
|
|
|
|
case patch_operations::test:
|
|
{
|
|
bool success = false;
|
|
JSON_TRY
|
|
{
|
|
// check if "value" matches the one at "path"
|
|
// the "path" location must exist - use at()
|
|
success = (result.at(ptr) == get_value("test", "value", false));
|
|
}
|
|
JSON_INTERNAL_CATCH (out_of_range&)
|
|
{
|
|
// ignore out of range errors: success remains false
|
|
}
|
|
|
|
// throw an exception if test fails
|
|
if (JSON_HEDLEY_UNLIKELY(!success))
|
|
{
|
|
JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump(), val));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case patch_operations::invalid:
|
|
default:
|
|
{
|
|
// op must be "add", "remove", "replace", "move", "copy", or
|
|
// "test"
|
|
JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid", val));
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @brief creates a diff as a JSON patch
|
|
/// @sa https://json.nlohmann.me/api/basic_json/diff/
|
|
JSON_HEDLEY_WARN_UNUSED_RESULT
|
|
static basic_json diff(const basic_json& source, const basic_json& target,
|
|
const std::string& path = "")
|
|
{
|
|
// the patch
|
|
basic_json result(value_t::array);
|
|
|
|
// if the values are the same, return empty patch
|
|
if (source == target)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
if (source.type() != target.type())
|
|
{
|
|
// different types: replace value
|
|
result.push_back(
|
|
{
|
|
{"op", "replace"}, {"path", path}, {"value", target}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
switch (source.type())
|
|
{
|
|
case value_t::array:
|
|
{
|
|
// first pass: traverse common elements
|
|
std::size_t i = 0;
|
|
while (i < source.size() && i < target.size())
|
|
{
|
|
// recursive call to compare array values at index i
|
|
auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
|
|
result.insert(result.end(), temp_diff.begin(), temp_diff.end());
|
|
++i;
|
|
}
|
|
|
|
// We now reached the end of at least one array
|
|
// in a second pass, traverse the remaining elements
|
|
|
|
// remove my remaining elements
|
|
const auto end_index = static_cast<difference_type>(result.size());
|
|
while (i < source.size())
|
|
{
|
|
// add operations in reverse order to avoid invalid
|
|
// indices
|
|
result.insert(result.begin() + end_index, object(
|
|
{
|
|
{"op", "remove"},
|
|
{"path", path + "/" + std::to_string(i)}
|
|
}));
|
|
++i;
|
|
}
|
|
|
|
// add other remaining elements
|
|
while (i < target.size())
|
|
{
|
|
result.push_back(
|
|
{
|
|
{"op", "add"},
|
|
{"path", path + "/-"},
|
|
{"value", target[i]}
|
|
});
|
|
++i;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::object:
|
|
{
|
|
// first pass: traverse this object's elements
|
|
for (auto it = source.cbegin(); it != source.cend(); ++it)
|
|
{
|
|
// escape the key name to be used in a JSON patch
|
|
const auto path_key = path + "/" + detail::escape(it.key());
|
|
|
|
if (target.find(it.key()) != target.end())
|
|
{
|
|
// recursive call to compare object values at key it
|
|
auto temp_diff = diff(it.value(), target[it.key()], path_key);
|
|
result.insert(result.end(), temp_diff.begin(), temp_diff.end());
|
|
}
|
|
else
|
|
{
|
|
// found a key that is not in o -> remove it
|
|
result.push_back(object(
|
|
{
|
|
{"op", "remove"}, {"path", path_key}
|
|
}));
|
|
}
|
|
}
|
|
|
|
// second pass: traverse other object's elements
|
|
for (auto it = target.cbegin(); it != target.cend(); ++it)
|
|
{
|
|
if (source.find(it.key()) == source.end())
|
|
{
|
|
// found a key that is not in this -> add it
|
|
const auto path_key = path + "/" + detail::escape(it.key());
|
|
result.push_back(
|
|
{
|
|
{"op", "add"}, {"path", path_key},
|
|
{"value", it.value()}
|
|
});
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case value_t::null:
|
|
case value_t::string:
|
|
case value_t::boolean:
|
|
case value_t::number_integer:
|
|
case value_t::number_unsigned:
|
|
case value_t::number_float:
|
|
case value_t::binary:
|
|
case value_t::discarded:
|
|
default:
|
|
{
|
|
// both primitive type: replace value
|
|
result.push_back(
|
|
{
|
|
{"op", "replace"}, {"path", path}, {"value", target}
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// @}
|
|
|
|
////////////////////////////////
|
|
// JSON Merge Patch functions //
|
|
////////////////////////////////
|
|
|
|
/// @name JSON Merge Patch functions
|
|
/// @{
|
|
|
|
/// @brief applies a JSON Merge Patch
|
|
/// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
|
|
void merge_patch(const basic_json& apply_patch)
|
|
{
|
|
if (apply_patch.is_object())
|
|
{
|
|
if (!is_object())
|
|
{
|
|
*this = object();
|
|
}
|
|
for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
|
|
{
|
|
if (it.value().is_null())
|
|
{
|
|
erase(it.key());
|
|
}
|
|
else
|
|
{
|
|
operator[](it.key()).merge_patch(it.value());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*this = apply_patch;
|
|
}
|
|
}
|
|
|
|
/// @}
|
|
};
|
|
|
|
/// @brief user-defined to_string function for JSON values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/to_string/
|
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
|
|
{
|
|
return j.dump();
|
|
}
|
|
|
|
} // namespace nlohmann
|
|
|
|
///////////////////////
|
|
// nonmember support //
|
|
///////////////////////
|
|
|
|
namespace std // NOLINT(cert-dcl58-cpp)
|
|
{
|
|
|
|
/// @brief hash value for JSON objects
|
|
/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
|
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL>
|
|
{
|
|
std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
|
|
{
|
|
return nlohmann::detail::hash(j);
|
|
}
|
|
};
|
|
|
|
// specialization for std::less<value_t>
|
|
template<>
|
|
struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
|
|
{
|
|
/*!
|
|
@brief compare two value_t enum values
|
|
@since version 3.0.0
|
|
*/
|
|
bool operator()(nlohmann::detail::value_t lhs,
|
|
nlohmann::detail::value_t rhs) const noexcept
|
|
{
|
|
return nlohmann::detail::operator<(lhs, rhs);
|
|
}
|
|
};
|
|
|
|
// C++20 prohibit function specialization in the std namespace.
|
|
#ifndef JSON_HAS_CPP_20
|
|
|
|
/// @brief exchanges the values of two JSON objects
|
|
/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
|
|
NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept( // NOLINT(readability-inconsistent-declaration-parameter-name)
|
|
is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&& // NOLINT(misc-redundant-expression)
|
|
is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
|
|
{
|
|
j1.swap(j2);
|
|
}
|
|
|
|
#endif
|
|
|
|
} // namespace std
|
|
|
|
/// @brief user-defined string literal for JSON values
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
|
|
JSON_HEDLEY_NON_NULL(1)
|
|
inline nlohmann::json operator "" _json(const char* s, std::size_t n)
|
|
{
|
|
return nlohmann::json::parse(s, s + n);
|
|
}
|
|
|
|
/// @brief user-defined string literal for JSON pointer
|
|
/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
|
|
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));
|
|
}
|
|
|
|
// #include <nlohmann/detail/macro_unscope.hpp>
|
|
|
|
|
|
// restore clang diagnostic settings
|
|
#if defined(__clang__)
|
|
#pragma clang diagnostic pop
|
|
#endif
|
|
|
|
// clean up
|
|
#undef JSON_ASSERT
|
|
#undef JSON_INTERNAL_CATCH
|
|
#undef JSON_CATCH
|
|
#undef JSON_THROW
|
|
#undef JSON_TRY
|
|
#undef JSON_PRIVATE_UNLESS_TESTED
|
|
#undef JSON_HAS_CPP_11
|
|
#undef JSON_HAS_CPP_14
|
|
#undef JSON_HAS_CPP_17
|
|
#undef JSON_HAS_CPP_20
|
|
#undef JSON_HAS_FILESYSTEM
|
|
#undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
|
|
#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
|
|
#undef NLOHMANN_BASIC_JSON_TPL
|
|
#undef JSON_EXPLICIT
|
|
#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
|
|
|
|
// #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_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_CONCAT3
|
|
#undef JSON_HEDLEY_CONCAT3_EX
|
|
#undef JSON_HEDLEY_CONCAT_EX
|
|
#undef JSON_HEDLEY_CONST
|
|
#undef JSON_HEDLEY_CONSTEXPR
|
|
#undef JSON_HEDLEY_CONST_CAST
|
|
#undef JSON_HEDLEY_CPP_CAST
|
|
#undef JSON_HEDLEY_CRAY_VERSION
|
|
#undef JSON_HEDLEY_CRAY_VERSION_CHECK
|
|
#undef JSON_HEDLEY_C_DECL
|
|
#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_DISABLE_UNUSED_FUNCTION
|
|
#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_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_CL_VERSION
|
|
#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
|
|
#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_MCST_LCC_VERSION
|
|
#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
|
|
#undef JSON_HEDLEY_MESSAGE
|
|
#undef JSON_HEDLEY_MSVC_VERSION
|
|
#undef JSON_HEDLEY_MSVC_VERSION_CHECK
|
|
#undef JSON_HEDLEY_NEVER_INLINE
|
|
#undef JSON_HEDLEY_NON_NULL
|
|
#undef JSON_HEDLEY_NO_ESCAPE
|
|
#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_ARMCL_VERSION
|
|
#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
|
|
#undef JSON_HEDLEY_TI_CL2000_VERSION
|
|
#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
|
|
#undef JSON_HEDLEY_TI_CL430_VERSION
|
|
#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
|
|
#undef JSON_HEDLEY_TI_CL6X_VERSION
|
|
#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
|
|
#undef JSON_HEDLEY_TI_CL7X_VERSION
|
|
#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
|
|
#undef JSON_HEDLEY_TI_CLPRU_VERSION
|
|
#undef JSON_HEDLEY_TI_CLPRU_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
|
|
#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
|
|
#undef JSON_HEDLEY_FALL_THROUGH
|
|
|
|
|
|
|
|
#endif // INCLUDE_NLOHMANN_JSON_HPP_
|