+/*\r
+ __ _____ _____ _____\r
+ __| | __| | | | JSON for Modern C++\r
+| | |__ | | | | | | version 2.1.1\r
+|_____|_____|_____|_|___| https://github.com/nlohmann/json\r
+\r
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.\r
+Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.\r
+\r
+Permission is hereby granted, free of charge, to any person obtaining a copy\r
+of this software and associated documentation files (the "Software"), to deal\r
+in the Software without restriction, including without limitation the rights\r
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
+copies of the Software, and to permit persons to whom the Software is\r
+furnished to do so, subject to the following conditions:\r
+\r
+The above copyright notice and this permission notice shall be included in all\r
+copies or substantial portions of the Software.\r
+\r
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+SOFTWARE.\r
+*/\r
+\r
+#ifndef NLOHMANN_JSON_HPP\r
+#define NLOHMANN_JSON_HPP\r
+\r
+#include <algorithm> // all_of, copy, fill, find, for_each, none_of, remove, reverse, transform\r
+#include <array> // array\r
+#include <cassert> // assert\r
+#include <cctype> // isdigit\r
+#include <ciso646> // and, not, or\r
+#include <cmath> // isfinite, labs, ldexp, signbit\r
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t\r
+#include <cstdint> // int64_t, uint64_t\r
+#include <cstdlib> // abort, strtod, strtof, strtold, strtoul, strtoll, strtoull\r
+#include <cstring> // strlen\r
+#include <forward_list> // forward_list\r
+#include <functional> // function, hash, less\r
+#include <initializer_list> // initializer_list\r
+#include <iomanip> // setw\r
+#include <iostream> // istream, ostream\r
+#include <iterator> // advance, begin, back_inserter, bidirectional_iterator_tag, distance, end, inserter, iterator, iterator_traits, next, random_access_iterator_tag, reverse_iterator\r
+#include <limits> // numeric_limits\r
+#include <locale> // locale\r
+#include <map> // map\r
+#include <memory> // addressof, allocator, allocator_traits, unique_ptr\r
+#include <numeric> // accumulate\r
+#include <sstream> // stringstream\r
+#include <stdexcept> // domain_error, invalid_argument, out_of_range\r
+#include <string> // getline, stoi, string, to_string\r
+#include <type_traits> // add_pointer, conditional, decay, enable_if, false_type, integral_constant, is_arithmetic, is_base_of, is_const, is_constructible, is_convertible, is_default_constructible, is_enum, is_floating_point, is_integral, is_nothrow_move_assignable, is_nothrow_move_constructible, is_pointer, is_reference, is_same, is_scalar, is_signed, remove_const, remove_cv, remove_pointer, remove_reference, true_type, underlying_type\r
+#include <utility> // declval, forward, make_pair, move, pair, swap\r
+#include <vector> // vector\r
+\r
+// allow for portable deprecation warnings\r
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)\r
+ #define JSON_DEPRECATED __attribute__((deprecated))\r
+#elif defined(_MSC_VER)\r
+ #define JSON_DEPRECATED __declspec(deprecated)\r
+#else\r
+ #define JSON_DEPRECATED\r
+#endif\r
+\r
+// allow to disable exceptions\r
+#if not defined(JSON_NOEXCEPTION) || defined(__EXCEPTIONS)\r
+ #define JSON_THROW(exception) throw exception\r
+ #define JSON_TRY try\r
+ #define JSON_CATCH(exception) catch(exception)\r
+#else\r
+ #define JSON_THROW(exception) std::abort()\r
+ #define JSON_TRY if(true)\r
+ #define JSON_CATCH(exception) if(false)\r
+#endif\r
+\r
+/*!\r
+@brief namespace for Niels Lohmann\r
+@see https://github.com/nlohmann\r
+@since version 1.0.0\r
+*/\r
+namespace nlohmann\r
+{\r
+\r
+/*!\r
+@brief unnamed namespace with internal helper functions\r
+\r
+This namespace collects some functions that could not be defined inside the\r
+@ref basic_json class.\r
+\r
+@since version 2.1.0\r
+*/\r
+namespace detail\r
+{\r
+///////////////////////////\r
+// JSON type enumeration //\r
+///////////////////////////\r
+\r
+/*!\r
+@brief the JSON type enumeration\r
+\r
+This enumeration collects the different JSON types. It is internally used to\r
+distinguish the stored values, and the functions @ref basic_json::is_null(),\r
+@ref basic_json::is_object(), @ref basic_json::is_array(),\r
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),\r
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),\r
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),\r
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and\r
+@ref basic_json::is_structured() rely on it.\r
+\r
+@note There are three enumeration entries (number_integer, number_unsigned, and\r
+number_float), because the library distinguishes these three types for numbers:\r
+@ref basic_json::number_unsigned_t is used for unsigned integers,\r
+@ref basic_json::number_integer_t is used for signed integers, and\r
+@ref basic_json::number_float_t is used for floating-point numbers or to\r
+approximate integers which do not fit in the limits of their respective type.\r
+\r
+@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON\r
+value with the default value for a given type\r
+\r
+@since version 1.0.0\r
+*/\r
+enum class value_t : uint8_t\r
+{\r
+ null, ///< null value\r
+ object, ///< object (unordered set of name/value pairs)\r
+ array, ///< array (ordered collection of values)\r
+ string, ///< string value\r
+ boolean, ///< boolean value\r
+ number_integer, ///< number value (signed integer)\r
+ number_unsigned, ///< number value (unsigned integer)\r
+ number_float, ///< number value (floating-point)\r
+ discarded ///< discarded by the the parser callback function\r
+};\r
+\r
+/*!\r
+@brief comparison operator for JSON types\r
+\r
+Returns an ordering that is similar to Python:\r
+- order: null < boolean < number < object < array < string\r
+- furthermore, each type is not smaller than itself\r
+\r
+@since version 1.0.0\r
+*/\r
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept\r
+{\r
+ static constexpr std::array<uint8_t, 8> order = {{\r
+ 0, // null\r
+ 3, // object\r
+ 4, // array\r
+ 5, // string\r
+ 1, // boolean\r
+ 2, // integer\r
+ 2, // unsigned\r
+ 2, // float\r
+ }\r
+ };\r
+\r
+ // discarded values are not comparable\r
+ if (lhs == value_t::discarded or rhs == value_t::discarded)\r
+ {\r
+ return false;\r
+ }\r
+\r
+ return order[static_cast<std::size_t>(lhs)] <\r
+ order[static_cast<std::size_t>(rhs)];\r
+}\r
+\r
+\r
+/////////////\r
+// helpers //\r
+/////////////\r
+\r
+// alias templates to reduce boilerplate\r
+template<bool B, typename T = void>\r
+using enable_if_t = typename std::enable_if<B, T>::type;\r
+\r
+template<typename T>\r
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;\r
+\r
+// taken from http://stackoverflow.com/a/26936864/266378\r
+template<typename T>\r
+using is_unscoped_enum =\r
+ std::integral_constant<bool, std::is_convertible<T, int>::value and\r
+ std::is_enum<T>::value>;\r
+\r
+/*\r
+Implementation of two C++17 constructs: conjunction, negation. This is needed\r
+to avoid evaluating all the traits in a condition\r
+\r
+For example: not std::is_same<void, T>::value and has_value_type<T>::value\r
+will not compile when T = void (on MSVC at least). Whereas\r
+conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value will\r
+stop evaluating if negation<...>::value == false\r
+\r
+Please note that those constructs must be used with caution, since symbols can\r
+become very long quickly (which can slow down compilation and cause MSVC\r
+internal compiler errors). Only use it when you have to (see example ahead).\r
+*/\r
+template<class...> struct conjunction : std::true_type {};\r
+template<class B1> struct conjunction<B1> : B1 {};\r
+template<class B1, class... Bn>\r
+struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};\r
+\r
+template<class B> struct negation : std::integral_constant < bool, !B::value > {};\r
+\r
+// dispatch utility (taken from ranges-v3)\r
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};\r
+template<> struct priority_tag<0> {};\r
+\r
+\r
+//////////////////\r
+// constructors //\r
+//////////////////\r
+\r
+template<value_t> struct external_constructor;\r
+\r
+template<>\r
+struct external_constructor<value_t::boolean>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept\r
+ {\r
+ j.m_type = value_t::boolean;\r
+ j.m_value = b;\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+template<>\r
+struct external_constructor<value_t::string>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)\r
+ {\r
+ j.m_type = value_t::string;\r
+ j.m_value = s;\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+template<>\r
+struct external_constructor<value_t::number_float>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept\r
+ {\r
+ // replace infinity and NAN by null\r
+ if (not std::isfinite(val))\r
+ {\r
+ j = BasicJsonType{};\r
+ }\r
+ else\r
+ {\r
+ j.m_type = value_t::number_float;\r
+ j.m_value = val;\r
+ }\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+template<>\r
+struct external_constructor<value_t::number_unsigned>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept\r
+ {\r
+ j.m_type = value_t::number_unsigned;\r
+ j.m_value = val;\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+template<>\r
+struct external_constructor<value_t::number_integer>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept\r
+ {\r
+ j.m_type = value_t::number_integer;\r
+ j.m_value = val;\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+template<>\r
+struct external_constructor<value_t::array>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)\r
+ {\r
+ j.m_type = value_t::array;\r
+ j.m_value = arr;\r
+ j.assert_invariant();\r
+ }\r
+\r
+ template<typename BasicJsonType, typename CompatibleArrayType,\r
+ enable_if_t<not std::is_same<CompatibleArrayType,\r
+ typename BasicJsonType::array_t>::value,\r
+ int> = 0>\r
+ static void construct(BasicJsonType& j, const CompatibleArrayType& arr)\r
+ {\r
+ using std::begin;\r
+ using std::end;\r
+ j.m_type = value_t::array;\r
+ j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+template<>\r
+struct external_constructor<value_t::object>\r
+{\r
+ template<typename BasicJsonType>\r
+ static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)\r
+ {\r
+ j.m_type = value_t::object;\r
+ j.m_value = obj;\r
+ j.assert_invariant();\r
+ }\r
+\r
+ template<typename BasicJsonType, typename CompatibleObjectType,\r
+ enable_if_t<not std::is_same<CompatibleObjectType,\r
+ typename BasicJsonType::object_t>::value,\r
+ int> = 0>\r
+ static void construct(BasicJsonType& j, const CompatibleObjectType& obj)\r
+ {\r
+ using std::begin;\r
+ using std::end;\r
+\r
+ j.m_type = value_t::object;\r
+ j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));\r
+ j.assert_invariant();\r
+ }\r
+};\r
+\r
+\r
+////////////////////////\r
+// has_/is_ functions //\r
+////////////////////////\r
+\r
+/*!\r
+@brief Helper to determine whether there's a key_type for T.\r
+\r
+This helper is used to tell associative containers apart from other containers\r
+such as sequence containers. For instance, `std::map` passes the test as it\r
+contains a `mapped_type`, whereas `std::vector` fails the test.\r
+\r
+@sa http://stackoverflow.com/a/7728728/266378\r
+@since version 1.0.0, overworked in version 2.0.6\r
+*/\r
+#define NLOHMANN_JSON_HAS_HELPER(type) \\r
+ template<typename T> struct has_##type { \\r
+ private: \\r
+ template<typename U, typename = typename U::type> \\r
+ static int detect(U &&); \\r
+ static void detect(...); \\r
+ public: \\r
+ static constexpr bool value = \\r
+ std::is_integral<decltype(detect(std::declval<T>()))>::value; \\r
+ }\r
+\r
+NLOHMANN_JSON_HAS_HELPER(mapped_type);\r
+NLOHMANN_JSON_HAS_HELPER(key_type);\r
+NLOHMANN_JSON_HAS_HELPER(value_type);\r
+NLOHMANN_JSON_HAS_HELPER(iterator);\r
+\r
+#undef NLOHMANN_JSON_HAS_HELPER\r
+\r
+\r
+template<bool B, class RealType, class CompatibleObjectType>\r
+struct is_compatible_object_type_impl : std::false_type {};\r
+\r
+template<class RealType, class CompatibleObjectType>\r
+struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>\r
+{\r
+ static constexpr auto value =\r
+ std::is_constructible<typename RealType::key_type,\r
+ typename CompatibleObjectType::key_type>::value and\r
+ std::is_constructible<typename RealType::mapped_type,\r
+ typename CompatibleObjectType::mapped_type>::value;\r
+};\r
+\r
+template<class BasicJsonType, class CompatibleObjectType>\r
+struct is_compatible_object_type\r
+{\r
+ static auto constexpr value = is_compatible_object_type_impl <\r
+ conjunction<negation<std::is_same<void, CompatibleObjectType>>,\r
+ has_mapped_type<CompatibleObjectType>,\r
+ has_key_type<CompatibleObjectType>>::value,\r
+ typename BasicJsonType::object_t, CompatibleObjectType >::value;\r
+};\r
+\r
+template<typename BasicJsonType, typename T>\r
+struct is_basic_json_nested_type\r
+{\r
+ static auto constexpr value = std::is_same<T, typename BasicJsonType::iterator>::value or\r
+ std::is_same<T, typename BasicJsonType::const_iterator>::value or\r
+ std::is_same<T, typename BasicJsonType::reverse_iterator>::value or\r
+ std::is_same<T, typename BasicJsonType::const_reverse_iterator>::value or\r
+ std::is_same<T, typename BasicJsonType::json_pointer>::value;\r
+};\r
+\r
+template<class BasicJsonType, class CompatibleArrayType>\r
+struct is_compatible_array_type\r
+{\r
+ static auto constexpr value =\r
+ conjunction<negation<std::is_same<void, CompatibleArrayType>>,\r
+ negation<is_compatible_object_type<\r
+ BasicJsonType, CompatibleArrayType>>,\r
+ negation<std::is_constructible<typename BasicJsonType::string_t,\r
+ CompatibleArrayType>>,\r
+ negation<is_basic_json_nested_type<BasicJsonType, CompatibleArrayType>>,\r
+ has_value_type<CompatibleArrayType>,\r
+ has_iterator<CompatibleArrayType>>::value;\r
+};\r
+\r
+template<bool, typename, typename>\r
+struct is_compatible_integer_type_impl : std::false_type {};\r
+\r
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>\r
+struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType>\r
+{\r
+ // is there an assert somewhere on overflows?\r
+ using RealLimits = std::numeric_limits<RealIntegerType>;\r
+ using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;\r
+\r
+ static constexpr auto value =\r
+ std::is_constructible<RealIntegerType,\r
+ CompatibleNumberIntegerType>::value and\r
+ CompatibleLimits::is_integer and\r
+ RealLimits::is_signed == CompatibleLimits::is_signed;\r
+};\r
+\r
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>\r
+struct is_compatible_integer_type\r
+{\r
+ static constexpr auto value =\r
+ is_compatible_integer_type_impl <\r
+ std::is_integral<CompatibleNumberIntegerType>::value and\r
+ not std::is_same<bool, CompatibleNumberIntegerType>::value,\r
+ RealIntegerType, CompatibleNumberIntegerType > ::value;\r
+};\r
+\r
+\r
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists\r
+template<typename BasicJsonType, typename T>\r
+struct has_from_json\r
+{\r
+ private:\r
+ // also check the return type of from_json\r
+ template<typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(\r
+ std::declval<BasicJsonType>(), std::declval<T&>()))>::value>>\r
+ static int detect(U&&);\r
+ static void detect(...);\r
+\r
+ public:\r
+ static constexpr bool value = std::is_integral<decltype(\r
+ detect(std::declval<typename BasicJsonType::template json_serializer<T, void > >()))>::value;\r
+};\r
+\r
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists\r
+// this overload is used for non-default-constructible user-defined-types\r
+template<typename BasicJsonType, typename T>\r
+struct has_non_default_from_json\r
+{\r
+ private:\r
+ template <\r
+ typename U,\r
+ typename = enable_if_t<std::is_same<\r
+ T, decltype(uncvref_t<U>::from_json(std::declval<BasicJsonType>()))>::value >>\r
+ static int detect(U&&);\r
+ static void detect(...);\r
+\r
+ public:\r
+ static constexpr bool value = std::is_integral<decltype(detect(\r
+ std::declval<typename BasicJsonType::template json_serializer<T, void> >()))>::value;\r
+};\r
+\r
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists\r
+template<typename BasicJsonType, typename T>\r
+struct has_to_json\r
+{\r
+ private:\r
+ template<typename U, typename = decltype(uncvref_t<U>::to_json(\r
+ std::declval<BasicJsonType&>(), std::declval<T>()))>\r
+ static int detect(U&&);\r
+ static void detect(...);\r
+\r
+ public:\r
+ static constexpr bool value = std::is_integral<decltype(detect(\r
+ std::declval<typename BasicJsonType::template json_serializer<T, void> >()))>::value;\r
+};\r
+\r
+\r
+/////////////\r
+// to_json //\r
+/////////////\r
+\r
+template<typename BasicJsonType, typename T, enable_if_t<\r
+ std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>\r
+void to_json(BasicJsonType& j, T b) noexcept\r
+{\r
+ external_constructor<value_t::boolean>::construct(j, b);\r
+}\r
+\r
+template<typename BasicJsonType, typename CompatibleString,\r
+ enable_if_t<std::is_constructible<typename BasicJsonType::string_t,\r
+ CompatibleString>::value, int> = 0>\r
+void to_json(BasicJsonType& j, const CompatibleString& s)\r
+{\r
+ external_constructor<value_t::string>::construct(j, s);\r
+}\r
+\r
+template<typename BasicJsonType, typename FloatType,\r
+ enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>\r
+void to_json(BasicJsonType& j, FloatType val) noexcept\r
+{\r
+ external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));\r
+}\r
+\r
+template <\r
+ typename BasicJsonType, typename CompatibleNumberUnsignedType,\r
+ enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t,\r
+ CompatibleNumberUnsignedType>::value, int> = 0 >\r
+void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept\r
+{\r
+ external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));\r
+}\r
+\r
+template <\r
+ typename BasicJsonType, typename CompatibleNumberIntegerType,\r
+ enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t,\r
+ CompatibleNumberIntegerType>::value, int> = 0 >\r
+void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept\r
+{\r
+ external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));\r
+}\r
+\r
+template<typename BasicJsonType, typename UnscopedEnumType,\r
+ enable_if_t<is_unscoped_enum<UnscopedEnumType>::value, int> = 0>\r
+void to_json(BasicJsonType& j, UnscopedEnumType e) noexcept\r
+{\r
+ external_constructor<value_t::number_integer>::construct(j, e);\r
+}\r
+\r
+template <\r
+ typename BasicJsonType, typename CompatibleArrayType,\r
+ enable_if_t <\r
+ is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value or\r
+ std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value,\r
+ int > = 0 >\r
+void to_json(BasicJsonType& j, const CompatibleArrayType& arr)\r
+{\r
+ external_constructor<value_t::array>::construct(j, arr);\r
+}\r
+\r
+template <\r
+ typename BasicJsonType, typename CompatibleObjectType,\r
+ enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value,\r
+ int> = 0 >\r
+void to_json(BasicJsonType& j, const CompatibleObjectType& arr)\r
+{\r
+ external_constructor<value_t::object>::construct(j, arr);\r
+}\r
+\r
+\r
+///////////////\r
+// from_json //\r
+///////////////\r
+\r
+// overloads for basic_json template parameters\r
+template<typename BasicJsonType, typename ArithmeticType,\r
+ enable_if_t<std::is_arithmetic<ArithmeticType>::value and\r
+ not std::is_same<ArithmeticType,\r
+ typename BasicJsonType::boolean_t>::value,\r
+ int> = 0>\r
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)\r
+{\r
+ switch (static_cast<value_t>(j))\r
+ {\r
+ case value_t::number_unsigned:\r
+ {\r
+ val = static_cast<ArithmeticType>(\r
+ *j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());\r
+ break;\r
+ }\r
+ case value_t::number_integer:\r
+ {\r
+ val = static_cast<ArithmeticType>(\r
+ *j.template get_ptr<const typename BasicJsonType::number_integer_t*>());\r
+ break;\r
+ }\r
+ case value_t::number_float:\r
+ {\r
+ val = static_cast<ArithmeticType>(\r
+ *j.template get_ptr<const typename BasicJsonType::number_float_t*>());\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ JSON_THROW(\r
+ std::domain_error("type must be number, but is " + j.type_name()));\r
+ }\r
+ }\r
+}\r
+\r
+template<typename BasicJsonType>\r
+void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)\r
+{\r
+ if (not j.is_boolean())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be boolean, but is " + j.type_name()));\r
+ }\r
+ b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();\r
+}\r
+\r
+template<typename BasicJsonType>\r
+void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)\r
+{\r
+ if (not j.is_string())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be string, but is " + j.type_name()));\r
+ }\r
+ s = *j.template get_ptr<const typename BasicJsonType::string_t*>();\r
+}\r
+\r
+template<typename BasicJsonType>\r
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)\r
+{\r
+ get_arithmetic_value(j, val);\r
+}\r
+\r
+template<typename BasicJsonType>\r
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)\r
+{\r
+ get_arithmetic_value(j, val);\r
+}\r
+\r
+template<typename BasicJsonType>\r
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)\r
+{\r
+ get_arithmetic_value(j, val);\r
+}\r
+\r
+template<typename BasicJsonType, typename UnscopedEnumType,\r
+ enable_if_t<is_unscoped_enum<UnscopedEnumType>::value, int> = 0>\r
+void from_json(const BasicJsonType& j, UnscopedEnumType& e)\r
+{\r
+ typename std::underlying_type<UnscopedEnumType>::type val;\r
+ get_arithmetic_value(j, val);\r
+ e = static_cast<UnscopedEnumType>(val);\r
+}\r
+\r
+template<typename BasicJsonType>\r
+void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr)\r
+{\r
+ if (not j.is_array())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));\r
+ }\r
+ arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();\r
+}\r
+\r
+// forward_list doesn't have an insert method\r
+template<typename BasicJsonType, typename T, typename Allocator>\r
+void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)\r
+{\r
+ // do not perform the check when user wants to retrieve jsons\r
+ // (except when it's null.. ?)\r
+ if (j.is_null())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));\r
+ }\r
+ if (not std::is_same<T, BasicJsonType>::value)\r
+ {\r
+ if (not j.is_array())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));\r
+ }\r
+ }\r
+ for (auto it = j.rbegin(), end = j.rend(); it != end; ++it)\r
+ {\r
+ l.push_front(it->template get<T>());\r
+ }\r
+}\r
+\r
+template<typename BasicJsonType, typename CompatibleArrayType>\r
+void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0>)\r
+{\r
+ using std::begin;\r
+ using std::end;\r
+\r
+ std::transform(j.begin(), j.end(),\r
+ std::inserter(arr, end(arr)), [](const BasicJsonType & i)\r
+ {\r
+ // get<BasicJsonType>() returns *this, this won't call a from_json\r
+ // method when value_type is BasicJsonType\r
+ return i.template get<typename CompatibleArrayType::value_type>();\r
+ });\r
+}\r
+\r
+template<typename BasicJsonType, typename CompatibleArrayType>\r
+auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1>)\r
+-> decltype(\r
+ arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),\r
+ void())\r
+{\r
+ using std::begin;\r
+ using std::end;\r
+\r
+ arr.reserve(j.size());\r
+ std::transform(\r
+ j.begin(), j.end(), std::inserter(arr, end(arr)), [](const BasicJsonType & i)\r
+ {\r
+ // get<BasicJsonType>() returns *this, this won't call a from_json\r
+ // method when value_type is BasicJsonType\r
+ return i.template get<typename CompatibleArrayType::value_type>();\r
+ });\r
+}\r
+\r
+template<typename BasicJsonType, typename CompatibleArrayType,\r
+ enable_if_t<is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and\r
+ not std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value, int> = 0>\r
+void from_json(const BasicJsonType& j, CompatibleArrayType& arr)\r
+{\r
+ if (j.is_null())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));\r
+ }\r
+\r
+ // when T == BasicJsonType, do not check if value_t is correct\r
+ if (not std::is_same<typename CompatibleArrayType::value_type, BasicJsonType>::value)\r
+ {\r
+ if (not j.is_array())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be array, but is " + j.type_name()));\r
+ }\r
+ }\r
+ from_json_array_impl(j, arr, priority_tag<1> {});\r
+}\r
+\r
+template<typename BasicJsonType, typename CompatibleObjectType,\r
+ enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>\r
+void from_json(const BasicJsonType& j, CompatibleObjectType& obj)\r
+{\r
+ if (not j.is_object())\r
+ {\r
+ JSON_THROW(std::domain_error("type must be object, but is " + j.type_name()));\r
+ }\r
+\r
+ auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();\r
+ using std::begin;\r
+ using std::end;\r
+ // we could avoid the assignment, but this might require a for loop, which\r
+ // might be less efficient than the container constructor for some\r
+ // containers (would it?)\r
+ obj = CompatibleObjectType(begin(*inner_object), end(*inner_object));\r
+}\r
+\r
+// overload for arithmetic types, not chosen for basic_json template arguments\r
+// (BooleanType, etc..); note: Is it really necessary to provide explicit\r
+// overloads for boolean_t etc. in case of a custom BooleanType which is not\r
+// an arithmetic type?\r
+template<typename BasicJsonType, typename ArithmeticType,\r
+ enable_if_t <\r
+ std::is_arithmetic<ArithmeticType>::value and\r
+ not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and\r
+ not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and\r
+ not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and\r
+ not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,\r
+ int> = 0>\r
+void from_json(const BasicJsonType& j, ArithmeticType& val)\r
+{\r
+ switch (static_cast<value_t>(j))\r
+ {\r
+ case value_t::number_unsigned:\r
+ {\r
+ val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());\r
+ break;\r
+ }\r
+ case value_t::number_integer:\r
+ {\r
+ val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());\r
+ break;\r
+ }\r
+ case value_t::number_float:\r
+ {\r
+ val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());\r
+ break;\r
+ }\r
+ case value_t::boolean:\r
+ {\r
+ val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ JSON_THROW(std::domain_error("type must be number, but is " + j.type_name()));\r
+ }\r
+ }\r
+}\r
+\r
+struct to_json_fn\r
+{\r
+ private:\r
+ template<typename BasicJsonType, typename T>\r
+ auto call(BasicJsonType& j, T&& val, priority_tag<1>) const noexcept(noexcept(to_json(j, std::forward<T>(val))))\r
+ -> decltype(to_json(j, std::forward<T>(val)), void())\r
+ {\r
+ return to_json(j, std::forward<T>(val));\r
+ }\r
+\r
+ template<typename BasicJsonType, typename T>\r
+ void call(BasicJsonType&, T&&, priority_tag<0>) const noexcept\r
+ {\r
+ static_assert(sizeof(BasicJsonType) == 0,\r
+ "could not find to_json() method in T's namespace");\r
+ }\r
+\r
+ public:\r
+ template<typename BasicJsonType, typename T>\r
+ void operator()(BasicJsonType& j, T&& val) const\r
+ noexcept(noexcept(std::declval<to_json_fn>().call(j, std::forward<T>(val), priority_tag<1> {})))\r
+ {\r
+ return call(j, std::forward<T>(val), priority_tag<1> {});\r
+ }\r
+};\r
+\r
+struct from_json_fn\r
+{\r
+ private:\r
+ template<typename BasicJsonType, typename T>\r
+ auto call(const BasicJsonType& j, T& val, priority_tag<1>) const\r
+ noexcept(noexcept(from_json(j, val)))\r
+ -> decltype(from_json(j, val), void())\r
+ {\r
+ return from_json(j, val);\r
+ }\r
+\r
+ template<typename BasicJsonType, typename T>\r
+ void call(const BasicJsonType&, T&, priority_tag<0>) const noexcept\r
+ {\r
+ static_assert(sizeof(BasicJsonType) == 0,\r
+ "could not find from_json() method in T's namespace");\r
+ }\r
+\r
+ public:\r
+ template<typename BasicJsonType, typename T>\r
+ void operator()(const BasicJsonType& j, T& val) const\r
+ noexcept(noexcept(std::declval<from_json_fn>().call(j, val, priority_tag<1> {})))\r
+ {\r
+ return call(j, val, priority_tag<1> {});\r
+ }\r
+};\r
+\r
+// taken from ranges-v3\r
+template<typename T>\r
+struct static_const\r
+{\r
+ static constexpr T value{};\r
+};\r
+\r
+template<typename T>\r
+constexpr T static_const<T>::value;\r
+} // namespace detail\r
+\r
+\r
+/// namespace to hold default `to_json` / `from_json` functions\r
+namespace\r
+{\r
+constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;\r
+constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;\r
+}\r
+\r
+\r
+/*!\r
+@brief default JSONSerializer template argument\r
+\r
+This serializer ignores the template arguments and uses ADL\r
+([argument-dependent lookup](http://en.cppreference.com/w/cpp/language/adl))\r
+for serialization.\r
+*/\r
+template<typename = void, typename = void>\r
+struct adl_serializer\r
+{\r
+ /*!\r
+ @brief convert a JSON value to any value type\r
+\r
+ This function is usually called by the `get()` function of the\r
+ @ref basic_json class (either explicit or via conversion operators).\r
+\r
+ @param[in] j JSON value to read from\r
+ @param[in,out] val value to write to\r
+ */\r
+ template<typename BasicJsonType, typename ValueType>\r
+ static void from_json(BasicJsonType&& j, ValueType& val) noexcept(\r
+ noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))\r
+ {\r
+ ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);\r
+ }\r
+\r
+ /*!\r
+ @brief convert any value type to a JSON value\r
+\r
+ This function is usually called by the constructors of the @ref basic_json\r
+ class.\r
+\r
+ @param[in,out] j JSON value to write to\r
+ @param[in] val value to read from\r
+ */\r
+ template<typename BasicJsonType, typename ValueType>\r
+ static void to_json(BasicJsonType& j, ValueType&& val) noexcept(\r
+ noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))\r
+ {\r
+ ::nlohmann::to_json(j, std::forward<ValueType>(val));\r
+ }\r
+};\r
+\r
+\r
+/*!\r
+@brief a class to store JSON values\r
+\r
+@tparam ObjectType type for JSON objects (`std::map` by default; will be used\r
+in @ref object_t)\r
+@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used\r
+in @ref array_t)\r
+@tparam StringType type for JSON strings and object keys (`std::string` by\r
+default; will be used in @ref string_t)\r
+@tparam BooleanType type for JSON booleans (`bool` by default; will be used\r
+in @ref boolean_t)\r
+@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by\r
+default; will be used in @ref number_integer_t)\r
+@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c\r
+`uint64_t` by default; will be used in @ref number_unsigned_t)\r
+@tparam NumberFloatType type for JSON floating-point numbers (`double` by\r
+default; will be used in @ref number_float_t)\r
+@tparam AllocatorType type of the allocator to use (`std::allocator` by\r
+default)\r
+@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`\r
+and `from_json()` (@ref adl_serializer by default)\r
+\r
+@requirement The class satisfies the following concept requirements:\r
+- Basic\r
+ - [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible):\r
+ JSON values can be default constructed. The result will be a JSON null\r
+ value.\r
+ - [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible):\r
+ A JSON value can be constructed from an rvalue argument.\r
+ - [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible):\r
+ A JSON value can be copy-constructed from an lvalue expression.\r
+ - [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable):\r
+ A JSON value van be assigned from an rvalue argument.\r
+ - [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable):\r
+ A JSON value can be copy-assigned from an lvalue expression.\r
+ - [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible):\r
+ JSON values can be destructed.\r
+- Layout\r
+ - [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType):\r
+ JSON values have\r
+ [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout):\r
+ All non-static data members are private and standard layout types, the\r
+ class has no virtual functions or (virtual) base classes.\r
+- Library-wide\r
+ - [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable):\r
+ JSON values can be compared with `==`, see @ref\r
+ operator==(const_reference,const_reference).\r
+ - [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable):\r
+ JSON values can be compared with `<`, see @ref\r
+ operator<(const_reference,const_reference).\r
+ - [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable):\r
+ Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of\r
+ other compatible types, using unqualified function call @ref swap().\r
+ - [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer):\r
+ JSON values can be compared against `std::nullptr_t` objects which are used\r
+ to model the `null` value.\r
+- Container\r
+ - [Container](http://en.cppreference.com/w/cpp/concept/Container):\r
+ JSON values can be used like STL containers and provide iterator access.\r
+ - [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer);\r
+ JSON values can be used like STL containers and provide reverse iterator\r
+ access.\r
+\r
+@invariant The member variables @a m_value and @a m_type have the following\r
+relationship:\r
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.\r
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.\r
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.\r
+The invariants are checked by member function assert_invariant().\r
+\r
+@internal\r
+@note ObjectType trick from http://stackoverflow.com/a/9860911\r
+@endinternal\r
+\r
+@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange\r
+Format](http://rfc7159.net/rfc7159)\r
+\r
+@since version 1.0.0\r
+\r
+@nosubgrouping\r
+*/\r
+template <\r
+ template<typename U, typename V, typename... Args> class ObjectType = std::map,\r
+ template<typename U, typename... Args> class ArrayType = std::vector,\r
+ class StringType = std::string,\r
+ class BooleanType = bool,\r
+ class NumberIntegerType = std::int64_t,\r
+ class NumberUnsignedType = std::uint64_t,\r
+ class NumberFloatType = double,\r
+ template<typename U> class AllocatorType = std::allocator,\r
+ template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer\r
+ >\r
+class basic_json\r
+{\r
+ private:\r
+ template<detail::value_t> friend struct detail::external_constructor;\r
+ /// workaround type for MSVC\r
+ using basic_json_t = basic_json<ObjectType, ArrayType, StringType,\r
+ BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType,\r
+ AllocatorType, JSONSerializer>;\r
+\r
+ public:\r
+ using value_t = detail::value_t;\r
+ // forward declarations\r
+ template<typename U> class iter_impl;\r
+ template<typename Base> class json_reverse_iterator;\r
+ class json_pointer;\r
+ template<typename T, typename SFINAE>\r
+ using json_serializer = JSONSerializer<T, SFINAE>;\r
+\r
+ /////////////////////\r
+ // container types //\r
+ /////////////////////\r
+\r
+ /// @name container types\r
+ /// The canonic container types to use @ref basic_json like any other STL\r
+ /// container.\r
+ /// @{\r
+\r
+ /// the type of elements in a basic_json container\r
+ using value_type = basic_json;\r
+\r
+ /// the type of an element reference\r
+ using reference = value_type&;\r
+ /// the type of an element const reference\r
+ using const_reference = const value_type&;\r
+\r
+ /// a type to represent differences between iterators\r
+ using difference_type = std::ptrdiff_t;\r
+ /// a type to represent container sizes\r
+ using size_type = std::size_t;\r
+\r
+ /// the allocator type\r
+ using allocator_type = AllocatorType<basic_json>;\r
+\r
+ /// the type of an element pointer\r
+ using pointer = typename std::allocator_traits<allocator_type>::pointer;\r
+ /// the type of an element const pointer\r
+ using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;\r
+\r
+ /// an iterator for a basic_json container\r
+ using iterator = iter_impl<basic_json>;\r
+ /// a const iterator for a basic_json container\r
+ using const_iterator = iter_impl<const basic_json>;\r
+ /// a reverse iterator for a basic_json container\r
+ using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;\r
+ /// a const reverse iterator for a basic_json container\r
+ using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;\r
+\r
+ /// @}\r
+\r
+\r
+ /*!\r
+ @brief returns the allocator associated with the container\r
+ */\r
+ static allocator_type get_allocator()\r
+ {\r
+ return allocator_type();\r
+ }\r
+\r
+ /*!\r
+ @brief returns version information on the library\r
+\r
+ This function returns a JSON object with information about the library,\r
+ including the version number and information on the platform and compiler.\r
+\r
+ @return JSON object holding version information\r
+ key | description\r
+ ----------- | ---------------\r
+ `compiler` | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).\r
+ `copyright` | The copyright line for the library as string.\r
+ `name` | The name of the library as string.\r
+ `platform` | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.\r
+ `url` | The URL of the project as string.\r
+ `version` | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).\r
+\r
+ @liveexample{The following code shows an example output of the `meta()`\r
+ function.,meta}\r
+\r
+ @complexity Constant.\r
+\r
+ @since 2.1.0\r
+ */\r
+ static basic_json meta()\r
+ {\r
+ basic_json result;\r
+\r
+ result["copyright"] = "(C) 2013-2017 Niels Lohmann";\r
+ result["name"] = "JSON for Modern C++";\r
+ result["url"] = "https://github.com/nlohmann/json";\r
+ result["version"] =\r
+ {\r
+ {"string", "2.1.1"},\r
+ {"major", 2},\r
+ {"minor", 1},\r
+ {"patch", 1}\r
+ };\r
+\r
+#ifdef _WIN32\r
+ result["platform"] = "win32";\r
+#elif defined __linux__\r
+ result["platform"] = "linux";\r
+#elif defined __APPLE__\r
+ result["platform"] = "apple";\r
+#elif defined __unix__\r
+ result["platform"] = "unix";\r
+#else\r
+ result["platform"] = "unknown";\r
+#endif\r
+\r
+#if defined(__clang__)\r
+ result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};\r
+#elif defined(__ICC) || defined(__INTEL_COMPILER)\r
+ result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};\r
+#elif defined(__GNUC__) || defined(__GNUG__)\r
+ result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};\r
+#elif defined(__HP_cc) || defined(__HP_aCC)\r
+ result["compiler"] = "hp"\r
+#elif defined(__IBMCPP__)\r
+ result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};\r
+#elif defined(_MSC_VER)\r
+ result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};\r
+#elif defined(__PGI)\r
+ result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};\r
+#elif defined(__SUNPRO_CC)\r
+ result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};\r
+#else\r
+ result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};\r
+#endif\r
+\r
+#ifdef __cplusplus\r
+ result["compiler"]["c++"] = std::to_string(__cplusplus);\r
+#else\r
+ result["compiler"]["c++"] = "unknown";\r
+#endif\r
+ return result;\r
+ }\r
+\r
+\r
+ ///////////////////////////\r
+ // JSON value data types //\r
+ ///////////////////////////\r
+\r
+ /// @name JSON value data types\r
+ /// The data types to store a JSON value. These types are derived from\r
+ /// the template arguments passed to class @ref basic_json.\r
+ /// @{\r
+\r
+ /*!\r
+ @brief a type for an object\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:\r
+ > An object is an unordered collection of zero or more name/value pairs,\r
+ > where a name is a string and a value is a string, number, boolean, null,\r
+ > object, or array.\r
+\r
+ To store objects in C++, a type is defined by the template parameters\r
+ described below.\r
+\r
+ @tparam ObjectType the container to store objects (e.g., `std::map` or\r
+ `std::unordered_map`)\r
+ @tparam StringType the type of the keys or names (e.g., `std::string`).\r
+ The comparison function `std::less<StringType>` is used to order elements\r
+ inside the container.\r
+ @tparam AllocatorType the allocator to use for objects (e.g.,\r
+ `std::allocator`)\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a ObjectType (`std::map`), @a StringType\r
+ (`std::string`), and @a AllocatorType (`std::allocator`), the default\r
+ value for @a object_t is:\r
+\r
+ @code {.cpp}\r
+ std::map<\r
+ std::string, // key_type\r
+ basic_json, // value_type\r
+ std::less<std::string>, // key_compare\r
+ std::allocator<std::pair<const std::string, basic_json>> // allocator_type\r
+ >\r
+ @endcode\r
+\r
+ #### Behavior\r
+\r
+ The choice of @a object_t influences the behavior of the JSON class. With\r
+ the default type, objects have the following behavior:\r
+\r
+ - When all names are unique, objects will be interoperable in the sense\r
+ that all software implementations receiving that object will agree on\r
+ the name-value mappings.\r
+ - When the names within an object are not unique, later stored name/value\r
+ pairs overwrite previously stored name/value pairs, leaving the used\r
+ names unique. For instance, `{"key": 1}` and `{"key": 2, "key": 1}` will\r
+ be treated as equal and both stored as `{"key": 1}`.\r
+ - Internally, name/value pairs are stored in lexicographical order of the\r
+ names. Objects will also be serialized (see @ref dump) in this order.\r
+ For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored\r
+ and serialized as `{"a": 2, "b": 1}`.\r
+ - When comparing objects, the order of the name/value pairs is irrelevant.\r
+ This makes objects interoperable in the sense that they will not be\r
+ affected by these differences. For instance, `{"b": 1, "a": 2}` and\r
+ `{"a": 2, "b": 1}` will be treated as equal.\r
+\r
+ #### Limits\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:\r
+ > An implementation may set limits on the maximum depth of nesting.\r
+\r
+ In this class, the object's limit of nesting is not constraint explicitly.\r
+ However, a maximum depth of nesting may be introduced by the compiler or\r
+ runtime environment. A theoretical limit can be queried by calling the\r
+ @ref max_size function of a JSON object.\r
+\r
+ #### Storage\r
+\r
+ Objects are stored as pointers in a @ref basic_json type. That is, for any\r
+ access to object values, a pointer of type `object_t*` must be\r
+ dereferenced.\r
+\r
+ @sa @ref array_t -- type for an array value\r
+\r
+ @since version 1.0.0\r
+\r
+ @note The order name/value pairs are added to the object is *not*\r
+ preserved by the library. Therefore, iterating an object may return\r
+ name/value pairs in a different order than they were originally stored. In\r
+ fact, keys will be traversed in alphabetical order as `std::map` with\r
+ `std::less` is used by default. Please note this behavior conforms to [RFC\r
+ 7159](http://rfc7159.net/rfc7159), because any order implements the\r
+ specified "unordered" nature of JSON objects.\r
+ */\r
+ using object_t = ObjectType<StringType,\r
+ basic_json,\r
+ std::less<StringType>,\r
+ AllocatorType<std::pair<const StringType,\r
+ basic_json>>>;\r
+\r
+ /*!\r
+ @brief a type for an array\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:\r
+ > An array is an ordered sequence of zero or more values.\r
+\r
+ To store objects in C++, a type is defined by the template parameters\r
+ explained below.\r
+\r
+ @tparam ArrayType container type to store arrays (e.g., `std::vector` or\r
+ `std::list`)\r
+ @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a ArrayType (`std::vector`) and @a\r
+ AllocatorType (`std::allocator`), the default value for @a array_t is:\r
+\r
+ @code {.cpp}\r
+ std::vector<\r
+ basic_json, // value_type\r
+ std::allocator<basic_json> // allocator_type\r
+ >\r
+ @endcode\r
+\r
+ #### Limits\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:\r
+ > An implementation may set limits on the maximum depth of nesting.\r
+\r
+ In this class, the array's limit of nesting is not constraint explicitly.\r
+ However, a maximum depth of nesting may be introduced by the compiler or\r
+ runtime environment. A theoretical limit can be queried by calling the\r
+ @ref max_size function of a JSON array.\r
+\r
+ #### Storage\r
+\r
+ Arrays are stored as pointers in a @ref basic_json type. That is, for any\r
+ access to array values, a pointer of type `array_t*` must be dereferenced.\r
+\r
+ @sa @ref object_t -- type for an object value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;\r
+\r
+ /*!\r
+ @brief a type for a string\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:\r
+ > A string is a sequence of zero or more Unicode characters.\r
+\r
+ To store objects in C++, a type is defined by the template parameter\r
+ described below. Unicode values are split by the JSON class into\r
+ byte-sized characters during deserialization.\r
+\r
+ @tparam StringType the container to store strings (e.g., `std::string`).\r
+ Note this container is used for keys/names in objects, see @ref object_t.\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a StringType (`std::string`), the default\r
+ value for @a string_t is:\r
+\r
+ @code {.cpp}\r
+ std::string\r
+ @endcode\r
+\r
+ #### Encoding\r
+\r
+ Strings are stored in UTF-8 encoding. Therefore, functions like\r
+ `std::string::size()` or `std::string::length()` return the number of\r
+ bytes in the string rather than the number of characters or glyphs.\r
+\r
+ #### String comparison\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) states:\r
+ > Software implementations are typically required to test names of object\r
+ > members for equality. Implementations that transform the textual\r
+ > representation into sequences of Unicode code units and then perform the\r
+ > comparison numerically, code unit by code unit, are interoperable in the\r
+ > sense that implementations will agree in all cases on equality or\r
+ > inequality of two strings. For example, implementations that compare\r
+ > strings with escaped characters unconverted may incorrectly find that\r
+ > `"a\\b"` and `"a\u005Cb"` are not equal.\r
+\r
+ This implementation is interoperable as it does compare strings code unit\r
+ by code unit.\r
+\r
+ #### Storage\r
+\r
+ String values are stored as pointers in a @ref basic_json type. That is,\r
+ for any access to string values, a pointer of type `string_t*` must be\r
+ dereferenced.\r
+\r
+ @since version 1.0.0\r
+ */\r
+ using string_t = StringType;\r
+\r
+ /*!\r
+ @brief a type for a boolean\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a\r
+ type which differentiates the two literals `true` and `false`.\r
+\r
+ To store objects in C++, a type is defined by the template parameter @a\r
+ BooleanType which chooses the type to use.\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a BooleanType (`bool`), the default value for\r
+ @a boolean_t is:\r
+\r
+ @code {.cpp}\r
+ bool\r
+ @endcode\r
+\r
+ #### Storage\r
+\r
+ Boolean values are stored directly inside a @ref basic_json type.\r
+\r
+ @since version 1.0.0\r
+ */\r
+ using boolean_t = BooleanType;\r
+\r
+ /*!\r
+ @brief a type for a number (integer)\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:\r
+ > The representation of numbers is similar to that used in most\r
+ > programming languages. A number is represented in base 10 using decimal\r
+ > digits. It contains an integer component that may be prefixed with an\r
+ > optional minus sign, which may be followed by a fraction part and/or an\r
+ > exponent part. Leading zeros are not allowed. (...) Numeric values that\r
+ > cannot be represented in the grammar below (such as Infinity and NaN)\r
+ > are not permitted.\r
+\r
+ This description includes both integer and floating-point numbers.\r
+ However, C++ allows more precise storage if it is known whether the number\r
+ is a signed integer, an unsigned integer or a floating-point number.\r
+ Therefore, three different types, @ref number_integer_t, @ref\r
+ number_unsigned_t and @ref number_float_t are used.\r
+\r
+ To store integer numbers in C++, a type is defined by the template\r
+ parameter @a NumberIntegerType which chooses the type to use.\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a NumberIntegerType (`int64_t`), the default\r
+ value for @a number_integer_t is:\r
+\r
+ @code {.cpp}\r
+ int64_t\r
+ @endcode\r
+\r
+ #### Default behavior\r
+\r
+ - The restrictions about leading zeros is not enforced in C++. Instead,\r
+ leading zeros in integer literals lead to an interpretation as octal\r
+ number. Internally, the value will be stored as decimal number. For\r
+ instance, the C++ integer literal `010` will be serialized to `8`.\r
+ During deserialization, leading zeros yield an error.\r
+ - Not-a-number (NaN) values will be serialized to `null`.\r
+\r
+ #### Limits\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:\r
+ > An implementation may set limits on the range and precision of numbers.\r
+\r
+ When the default type is used, the maximal integer number that can be\r
+ stored is `9223372036854775807` (INT64_MAX) and the minimal integer number\r
+ that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers\r
+ that are out of range will yield over/underflow when used in a\r
+ constructor. During deserialization, too large or small integer numbers\r
+ will be automatically be stored as @ref number_unsigned_t or @ref\r
+ number_float_t.\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) further states:\r
+ > Note that when such software is used, numbers that are integers and are\r
+ > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense\r
+ > that implementations will agree exactly on their numeric values.\r
+\r
+ As this range is a subrange of the exactly supported range [INT64_MIN,\r
+ INT64_MAX], this class's integer type is interoperable.\r
+\r
+ #### Storage\r
+\r
+ Integer number values are stored directly inside a @ref basic_json type.\r
+\r
+ @sa @ref number_float_t -- type for number values (floating-point)\r
+\r
+ @sa @ref number_unsigned_t -- type for number values (unsigned integer)\r
+\r
+ @since version 1.0.0\r
+ */\r
+ using number_integer_t = NumberIntegerType;\r
+\r
+ /*!\r
+ @brief a type for a number (unsigned)\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:\r
+ > The representation of numbers is similar to that used in most\r
+ > programming languages. A number is represented in base 10 using decimal\r
+ > digits. It contains an integer component that may be prefixed with an\r
+ > optional minus sign, which may be followed by a fraction part and/or an\r
+ > exponent part. Leading zeros are not allowed. (...) Numeric values that\r
+ > cannot be represented in the grammar below (such as Infinity and NaN)\r
+ > are not permitted.\r
+\r
+ This description includes both integer and floating-point numbers.\r
+ However, C++ allows more precise storage if it is known whether the number\r
+ is a signed integer, an unsigned integer or a floating-point number.\r
+ Therefore, three different types, @ref number_integer_t, @ref\r
+ number_unsigned_t and @ref number_float_t are used.\r
+\r
+ To store unsigned integer numbers in C++, a type is defined by the\r
+ template parameter @a NumberUnsignedType which chooses the type to use.\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a NumberUnsignedType (`uint64_t`), the\r
+ default value for @a number_unsigned_t is:\r
+\r
+ @code {.cpp}\r
+ uint64_t\r
+ @endcode\r
+\r
+ #### Default behavior\r
+\r
+ - The restrictions about leading zeros is not enforced in C++. Instead,\r
+ leading zeros in integer literals lead to an interpretation as octal\r
+ number. Internally, the value will be stored as decimal number. For\r
+ instance, the C++ integer literal `010` will be serialized to `8`.\r
+ During deserialization, leading zeros yield an error.\r
+ - Not-a-number (NaN) values will be serialized to `null`.\r
+\r
+ #### Limits\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) specifies:\r
+ > An implementation may set limits on the range and precision of numbers.\r
+\r
+ When the default type is used, the maximal integer number that can be\r
+ stored is `18446744073709551615` (UINT64_MAX) and the minimal integer\r
+ number that can be stored is `0`. Integer numbers that are out of range\r
+ will yield over/underflow when used in a constructor. During\r
+ deserialization, too large or small integer numbers will be automatically\r
+ be stored as @ref number_integer_t or @ref number_float_t.\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) further states:\r
+ > Note that when such software is used, numbers that are integers and are\r
+ > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense\r
+ > that implementations will agree exactly on their numeric values.\r
+\r
+ As this range is a subrange (when considered in conjunction with the\r
+ number_integer_t type) of the exactly supported range [0, UINT64_MAX],\r
+ this class's integer type is interoperable.\r
+\r
+ #### Storage\r
+\r
+ Integer number values are stored directly inside a @ref basic_json type.\r
+\r
+ @sa @ref number_float_t -- type for number values (floating-point)\r
+ @sa @ref number_integer_t -- type for number values (integer)\r
+\r
+ @since version 2.0.0\r
+ */\r
+ using number_unsigned_t = NumberUnsignedType;\r
+\r
+ /*!\r
+ @brief a type for a number (floating-point)\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:\r
+ > The representation of numbers is similar to that used in most\r
+ > programming languages. A number is represented in base 10 using decimal\r
+ > digits. It contains an integer component that may be prefixed with an\r
+ > optional minus sign, which may be followed by a fraction part and/or an\r
+ > exponent part. Leading zeros are not allowed. (...) Numeric values that\r
+ > cannot be represented in the grammar below (such as Infinity and NaN)\r
+ > are not permitted.\r
+\r
+ This description includes both integer and floating-point numbers.\r
+ However, C++ allows more precise storage if it is known whether the number\r
+ is a signed integer, an unsigned integer or a floating-point number.\r
+ Therefore, three different types, @ref number_integer_t, @ref\r
+ number_unsigned_t and @ref number_float_t are used.\r
+\r
+ To store floating-point numbers in C++, a type is defined by the template\r
+ parameter @a NumberFloatType which chooses the type to use.\r
+\r
+ #### Default type\r
+\r
+ With the default values for @a NumberFloatType (`double`), the default\r
+ value for @a number_float_t is:\r
+\r
+ @code {.cpp}\r
+ double\r
+ @endcode\r
+\r
+ #### Default behavior\r
+\r
+ - The restrictions about leading zeros is not enforced in C++. Instead,\r
+ leading zeros in floating-point literals will be ignored. Internally,\r
+ the value will be stored as decimal number. For instance, the C++\r
+ floating-point literal `01.2` will be serialized to `1.2`. During\r
+ deserialization, leading zeros yield an error.\r
+ - Not-a-number (NaN) values will be serialized to `null`.\r
+\r
+ #### Limits\r
+\r
+ [RFC 7159](http://rfc7159.net/rfc7159) states:\r
+ > This specification allows implementations to set limits on the range and\r
+ > precision of numbers accepted. Since software that implements IEEE\r
+ > 754-2008 binary64 (double precision) numbers is generally available and\r
+ > widely used, good interoperability can be achieved by implementations\r
+ > that expect no more precision or range than these provide, in the sense\r
+ > that implementations will approximate JSON numbers within the expected\r
+ > precision.\r
+\r
+ This implementation does exactly follow this approach, as it uses double\r
+ precision floating-point numbers. Note values smaller than\r
+ `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`\r
+ will be stored as NaN internally and be serialized to `null`.\r
+\r
+ #### Storage\r
+\r
+ Floating-point number values are stored directly inside a @ref basic_json\r
+ type.\r
+\r
+ @sa @ref number_integer_t -- type for number values (integer)\r
+\r
+ @sa @ref number_unsigned_t -- type for number values (unsigned integer)\r
+\r
+ @since version 1.0.0\r
+ */\r
+ using number_float_t = NumberFloatType;\r
+\r
+ /// @}\r
+\r
+ private:\r
+\r
+ /// helper for exception-safe object creation\r
+ template<typename T, typename... Args>\r
+ static T* create(Args&& ... args)\r
+ {\r
+ AllocatorType<T> alloc;\r
+ auto deleter = [&](T * object)\r
+ {\r
+ alloc.deallocate(object, 1);\r
+ };\r
+ std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);\r
+ alloc.construct(object.get(), std::forward<Args>(args)...);\r
+ assert(object != nullptr);\r
+ return object.release();\r
+ }\r
+\r
+ ////////////////////////\r
+ // JSON value storage //\r
+ ////////////////////////\r
+\r
+ /*!\r
+ @brief a JSON value\r
+\r
+ The actual storage for a JSON value of the @ref basic_json class. This\r
+ union combines the different storage types for the JSON value types\r
+ defined in @ref value_t.\r
+\r
+ JSON type | value_t type | used type\r
+ --------- | --------------- | ------------------------\r
+ object | object | pointer to @ref object_t\r
+ array | array | pointer to @ref array_t\r
+ string | string | pointer to @ref string_t\r
+ boolean | boolean | @ref boolean_t\r
+ number | number_integer | @ref number_integer_t\r
+ number | number_unsigned | @ref number_unsigned_t\r
+ number | number_float | @ref number_float_t\r
+ null | null | *no value is stored*\r
+\r
+ @note Variable-length types (objects, arrays, and strings) are stored as\r
+ pointers. The size of the union should not exceed 64 bits if the default\r
+ value types are used.\r
+\r
+ @since version 1.0.0\r
+ */\r
+ union json_value\r
+ {\r
+ /// object (stored with pointer to save storage)\r
+ object_t* object;\r
+ /// array (stored with pointer to save storage)\r
+ array_t* array;\r
+ /// string (stored with pointer to save storage)\r
+ string_t* string;\r
+ /// boolean\r
+ boolean_t boolean;\r
+ /// number (integer)\r
+ number_integer_t number_integer;\r
+ /// number (unsigned integer)\r
+ number_unsigned_t number_unsigned;\r
+ /// number (floating-point)\r
+ number_float_t number_float;\r
+\r
+ /// default constructor (for null values)\r
+ json_value() = default;\r
+ /// constructor for booleans\r
+ json_value(boolean_t v) noexcept : boolean(v) {}\r
+ /// constructor for numbers (integer)\r
+ json_value(number_integer_t v) noexcept : number_integer(v) {}\r
+ /// constructor for numbers (unsigned)\r
+ json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}\r
+ /// constructor for numbers (floating-point)\r
+ json_value(number_float_t v) noexcept : number_float(v) {}\r
+ /// constructor for empty values of a given type\r
+ json_value(value_t t)\r
+ {\r
+ switch (t)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ object = create<object_t>();\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ array = create<array_t>();\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ string = create<string_t>("");\r
+ break;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ boolean = boolean_t(false);\r
+ break;\r
+ }\r
+\r
+ case value_t::number_integer:\r
+ {\r
+ number_integer = number_integer_t(0);\r
+ break;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ number_unsigned = number_unsigned_t(0);\r
+ break;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ number_float = number_float_t(0.0);\r
+ break;\r
+ }\r
+\r
+ case value_t::null:\r
+ {\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ if (t == value_t::null)\r
+ {\r
+ JSON_THROW(std::domain_error("961c151d2e87f2686a955a9be24d316f1362bf21 2.1.1")); // LCOV_EXCL_LINE\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /// constructor for strings\r
+ json_value(const string_t& value)\r
+ {\r
+ string = create<string_t>(value);\r
+ }\r
+\r
+ /// constructor for objects\r
+ json_value(const object_t& value)\r
+ {\r
+ object = create<object_t>(value);\r
+ }\r
+\r
+ /// constructor for arrays\r
+ json_value(const array_t& value)\r
+ {\r
+ array = create<array_t>(value);\r
+ }\r
+ };\r
+\r
+ /*!\r
+ @brief checks the class invariants\r
+\r
+ This function asserts the class invariants. It needs to be called at the\r
+ end of every constructor to make sure that created objects respect the\r
+ invariant. Furthermore, it has to be called each time the type of a JSON\r
+ value is changed, because the invariant expresses a relationship between\r
+ @a m_type and @a m_value.\r
+ */\r
+ void assert_invariant() const\r
+ {\r
+ assert(m_type != value_t::object or m_value.object != nullptr);\r
+ assert(m_type != value_t::array or m_value.array != nullptr);\r
+ assert(m_type != value_t::string or m_value.string != nullptr);\r
+ }\r
+\r
+ public:\r
+ //////////////////////////\r
+ // JSON parser callback //\r
+ //////////////////////////\r
+\r
+ /*!\r
+ @brief JSON callback events\r
+\r
+ This enumeration lists the parser events that can trigger calling a\r
+ callback function of type @ref parser_callback_t during parsing.\r
+\r
+ @image html callback_events.png "Example when certain parse events are triggered"\r
+\r
+ @since version 1.0.0\r
+ */\r
+ enum class parse_event_t : uint8_t\r
+ {\r
+ /// the parser read `{` and started to process a JSON object\r
+ object_start,\r
+ /// the parser read `}` and finished processing a JSON object\r
+ object_end,\r
+ /// the parser read `[` and started to process a JSON array\r
+ array_start,\r
+ /// the parser read `]` and finished processing a JSON array\r
+ array_end,\r
+ /// the parser read a key of a value in an object\r
+ key,\r
+ /// the parser finished reading a JSON value\r
+ value\r
+ };\r
+\r
+ /*!\r
+ @brief per-element parser callback type\r
+\r
+ With a parser callback function, the result of parsing a JSON text can be\r
+ influenced. When passed to @ref parse(std::istream&, const\r
+ parser_callback_t) or @ref parse(const CharT, const parser_callback_t),\r
+ it is called on certain events (passed as @ref parse_event_t via parameter\r
+ @a event) with a set recursion depth @a depth and context JSON value\r
+ @a parsed. The return value of the callback function is a boolean\r
+ indicating whether the element that emitted the callback shall be kept or\r
+ not.\r
+\r
+ We distinguish six scenarios (determined by the event type) in which the\r
+ callback function can be called. The following table describes the values\r
+ of the parameters @a depth, @a event, and @a parsed.\r
+\r
+ parameter @a event | description | parameter @a depth | parameter @a parsed\r
+ ------------------ | ----------- | ------------------ | -------------------\r
+ parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded\r
+ parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key\r
+ parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object\r
+ parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded\r
+ parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array\r
+ parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value\r
+\r
+ @image html callback_events.png "Example when certain parse events are triggered"\r
+\r
+ Discarding a value (i.e., returning `false`) has different effects\r
+ depending on the context in which function was called:\r
+\r
+ - Discarded values in structured types are skipped. That is, the parser\r
+ will behave as if the discarded value was never read.\r
+ - In case a value outside a structured type is skipped, it is replaced\r
+ with `null`. This case happens if the top-level element is skipped.\r
+\r
+ @param[in] depth the depth of the recursion during parsing\r
+\r
+ @param[in] event an event of type parse_event_t indicating the context in\r
+ the callback function has been called\r
+\r
+ @param[in,out] parsed the current intermediate parse result; note that\r
+ writing to this value has no effect for parse_event_t::key events\r
+\r
+ @return Whether the JSON value which called the function during parsing\r
+ should be kept (`true`) or not (`false`). In the latter case, it is either\r
+ skipped completely or replaced by an empty discarded object.\r
+\r
+ @sa @ref parse(std::istream&, parser_callback_t) or\r
+ @ref parse(const CharT, const parser_callback_t) for examples\r
+\r
+ @since version 1.0.0\r
+ */\r
+ using parser_callback_t = std::function<bool(int depth,\r
+ parse_event_t event,\r
+ basic_json& parsed)>;\r
+\r
+\r
+ //////////////////\r
+ // constructors //\r
+ //////////////////\r
+\r
+ /// @name constructors and destructors\r
+ /// Constructors of class @ref basic_json, copy/move constructor, copy\r
+ /// assignment, static functions creating objects, and the destructor.\r
+ /// @{\r
+\r
+ /*!\r
+ @brief create an empty value with a given type\r
+\r
+ Create an empty JSON value with a given type. The value will be default\r
+ initialized with an empty value which depends on the type:\r
+\r
+ Value type | initial value\r
+ ----------- | -------------\r
+ null | `null`\r
+ boolean | `false`\r
+ string | `""`\r
+ number | `0`\r
+ object | `{}`\r
+ array | `[]`\r
+\r
+ @param[in] value_type the type of the value to create\r
+\r
+ @complexity Constant.\r
+\r
+ @throw std::bad_alloc if allocation for object, array, or string value\r
+ fails\r
+\r
+ @liveexample{The following code shows the constructor for different @ref\r
+ value_t values,basic_json__value_t}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ basic_json(const value_t value_type)\r
+ : m_type(value_type), m_value(value_type)\r
+ {\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief create a null object\r
+\r
+ Create a `null` JSON value. It either takes a null pointer as parameter\r
+ (explicitly creating `null`) or no parameter (implicitly creating `null`).\r
+ The passed null pointer itself is not read -- it is only used to choose\r
+ the right constructor.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this constructor never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code shows the constructor with and without a\r
+ null pointer parameter.,basic_json__nullptr_t}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ basic_json(std::nullptr_t = nullptr) noexcept\r
+ : basic_json(value_t::null)\r
+ {\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief create a JSON value\r
+\r
+ This is a "catch all" constructor for all compatible JSON types; that is,\r
+ types for which a `to_json()` method exsits. The constructor forwards the\r
+ parameter @a val to that method (to `json_serializer<U>::to_json` method\r
+ with `U = uncvref_t<CompatibleType>`, to be exact).\r
+\r
+ Template type @a CompatibleType includes, but is not limited to, the\r
+ following types:\r
+ - **arrays**: @ref array_t and all kinds of compatible containers such as\r
+ `std::vector`, `std::deque`, `std::list`, `std::forward_list`,\r
+ `std::array`, `std::set`, `std::unordered_set`, `std::multiset`, and\r
+ `unordered_multiset` with a `value_type` from which a @ref basic_json\r
+ value can be constructed.\r
+ - **objects**: @ref object_t and all kinds of compatible associative\r
+ containers such as `std::map`, `std::unordered_map`, `std::multimap`,\r
+ and `std::unordered_multimap` with a `key_type` compatible to\r
+ @ref string_t and a `value_type` from which a @ref basic_json value can\r
+ be constructed.\r
+ - **strings**: @ref string_t, string literals, and all compatible string\r
+ containers can be used.\r
+ - **numbers**: @ref number_integer_t, @ref number_unsigned_t,\r
+ @ref number_float_t, and all convertible number types such as `int`,\r
+ `size_t`, `int64_t`, `float` or `double` can be used.\r
+ - **boolean**: @ref boolean_t / `bool` can be used.\r
+\r
+ See the examples below.\r
+\r
+ @tparam CompatibleType a type such that:\r
+ - @a CompatibleType is not derived from `std::istream`,\r
+ - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move\r
+ constructors),\r
+ - @a CompatibleType is not a @ref basic_json nested type (e.g.,\r
+ @ref json_pointer, @ref iterator, etc ...)\r
+ - @ref @ref json_serializer<U> has a\r
+ `to_json(basic_json_t&, CompatibleType&&)` method\r
+\r
+ @tparam U = `uncvref_t<CompatibleType>`\r
+\r
+ @param[in] val the value to be forwarded\r
+\r
+ @complexity Usually linear in the size of the passed @a val, also\r
+ depending on the implementation of the called `to_json()`\r
+ method.\r
+\r
+ @throw what `json_serializer<U>::to_json()` throws\r
+\r
+ @liveexample{The following code shows the constructor with several\r
+ compatible types.,basic_json__CompatibleType}\r
+\r
+ @since version 2.1.0\r
+ */\r
+ template<typename CompatibleType, typename U = detail::uncvref_t<CompatibleType>,\r
+ detail::enable_if_t<not std::is_base_of<std::istream, U>::value and\r
+ not std::is_same<U, basic_json_t>::value and\r
+ not detail::is_basic_json_nested_type<\r
+ basic_json_t, U>::value and\r
+ detail::has_to_json<basic_json, U>::value,\r
+ int> = 0>\r
+ basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer<U>::to_json(\r
+ std::declval<basic_json_t&>(), std::forward<CompatibleType>(val))))\r
+ {\r
+ JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief create a container (array or object) from an initializer list\r
+\r
+ Creates a JSON value of type array or object from the passed initializer\r
+ list @a init. In case @a type_deduction is `true` (default), the type of\r
+ the JSON value to be created is deducted from the initializer list @a init\r
+ according to the following rules:\r
+\r
+ 1. If the list is empty, an empty JSON object value `{}` is created.\r
+ 2. If the list consists of pairs whose first element is a string, a JSON\r
+ object value is created where the first elements of the pairs are\r
+ treated as keys and the second elements are as values.\r
+ 3. In all other cases, an array is created.\r
+\r
+ The rules aim to create the best fit between a C++ initializer list and\r
+ JSON values. The rationale is as follows:\r
+\r
+ 1. The empty initializer list is written as `{}` which is exactly an empty\r
+ JSON object.\r
+ 2. C++ has now way of describing mapped types other than to list a list of\r
+ pairs. As JSON requires that keys must be of type string, rule 2 is the\r
+ weakest constraint one can pose on initializer lists to interpret them\r
+ as an object.\r
+ 3. In all other cases, the initializer list could not be interpreted as\r
+ JSON object type, so interpreting it as JSON array type is safe.\r
+\r
+ With the rules described above, the following JSON values cannot be\r
+ expressed by an initializer list:\r
+\r
+ - the empty array (`[]`): use @ref array(std::initializer_list<basic_json>)\r
+ with an empty initializer list in this case\r
+ - arrays whose elements satisfy rule 2: use @ref\r
+ array(std::initializer_list<basic_json>) with the same initializer list\r
+ in this case\r
+\r
+ @note When used without parentheses around an empty initializer list, @ref\r
+ basic_json() is called instead of this function, yielding the JSON null\r
+ value.\r
+\r
+ @param[in] init initializer list with JSON values\r
+\r
+ @param[in] type_deduction internal parameter; when set to `true`, the type\r
+ of the JSON value is deducted from the initializer list @a init; when set\r
+ to `false`, the type provided via @a manual_type is forced. This mode is\r
+ used by the functions @ref array(std::initializer_list<basic_json>) and\r
+ @ref object(std::initializer_list<basic_json>).\r
+\r
+ @param[in] manual_type internal parameter; when @a type_deduction is set\r
+ to `false`, the created JSON value will use the provided type (only @ref\r
+ value_t::array and @ref value_t::object are valid); when @a type_deduction\r
+ is set to `true`, this parameter has no effect\r
+\r
+ @throw std::domain_error if @a type_deduction is `false`, @a manual_type\r
+ is `value_t::object`, but @a init contains an element which is not a pair\r
+ whose first element is a string; example: `"cannot create object from\r
+ initializer list"`\r
+\r
+ @complexity Linear in the size of the initializer list @a init.\r
+\r
+ @liveexample{The example below shows how JSON values are created from\r
+ initializer lists.,basic_json__list_init_t}\r
+\r
+ @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array\r
+ value from an initializer list\r
+ @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object\r
+ value from an initializer list\r
+\r
+ @since version 1.0.0\r
+ */\r
+ basic_json(std::initializer_list<basic_json> init,\r
+ bool type_deduction = true,\r
+ value_t manual_type = value_t::array)\r
+ {\r
+ // check if each element is an array with two elements whose first\r
+ // element is a string\r
+ bool is_an_object = std::all_of(init.begin(), init.end(),\r
+ [](const basic_json & element)\r
+ {\r
+ return element.is_array() and element.size() == 2 and element[0].is_string();\r
+ });\r
+\r
+ // adjust type if type deduction is not wanted\r
+ if (not type_deduction)\r
+ {\r
+ // if array is wanted, do not create an object though possible\r
+ if (manual_type == value_t::array)\r
+ {\r
+ is_an_object = false;\r
+ }\r
+\r
+ // if object is wanted but impossible, throw an exception\r
+ if (manual_type == value_t::object and not is_an_object)\r
+ {\r
+ JSON_THROW(std::domain_error("cannot create object from initializer list"));\r
+ }\r
+ }\r
+\r
+ if (is_an_object)\r
+ {\r
+ // the initializer list is a list of pairs -> create object\r
+ m_type = value_t::object;\r
+ m_value = value_t::object;\r
+\r
+ std::for_each(init.begin(), init.end(), [this](const basic_json & element)\r
+ {\r
+ m_value.object->emplace(*(element[0].m_value.string), element[1]);\r
+ });\r
+ }\r
+ else\r
+ {\r
+ // the initializer list describes an array -> create array\r
+ m_type = value_t::array;\r
+ m_value.array = create<array_t>(init);\r
+ }\r
+\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief explicitly create an array from an initializer list\r
+\r
+ Creates a JSON array value from a given initializer list. That is, given a\r
+ list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the\r
+ initializer list is empty, the empty array `[]` is created.\r
+\r
+ @note This function is only needed to express two edge cases that cannot\r
+ be realized with the initializer list constructor (@ref\r
+ basic_json(std::initializer_list<basic_json>, bool, value_t)). These cases\r
+ are:\r
+ 1. creating an array whose elements are all pairs whose first element is a\r
+ string -- in this case, the initializer list constructor would create an\r
+ object, taking the first elements as keys\r
+ 2. creating an empty array -- passing the empty initializer list to the\r
+ initializer list constructor yields an empty object\r
+\r
+ @param[in] init initializer list with JSON values to create an array from\r
+ (optional)\r
+\r
+ @return JSON array value\r
+\r
+ @complexity Linear in the size of @a init.\r
+\r
+ @liveexample{The following code shows an example for the `array`\r
+ function.,array}\r
+\r
+ @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --\r
+ create a JSON value from an initializer list\r
+ @sa @ref object(std::initializer_list<basic_json>) -- create a JSON object\r
+ value from an initializer list\r
+\r
+ @since version 1.0.0\r
+ */\r
+ static basic_json array(std::initializer_list<basic_json> init =\r
+ std::initializer_list<basic_json>())\r
+ {\r
+ return basic_json(init, false, value_t::array);\r
+ }\r
+\r
+ /*!\r
+ @brief explicitly create an object from an initializer list\r
+\r
+ Creates a JSON object value from a given initializer list. The initializer\r
+ lists elements must be pairs, and their first elements must be strings. If\r
+ the initializer list is empty, the empty object `{}` is created.\r
+\r
+ @note This function is only added for symmetry reasons. In contrast to the\r
+ related function @ref array(std::initializer_list<basic_json>), there are\r
+ no cases which can only be expressed by this function. That is, any\r
+ initializer list @a init can also be passed to the initializer list\r
+ constructor @ref basic_json(std::initializer_list<basic_json>, bool,\r
+ value_t).\r
+\r
+ @param[in] init initializer list to create an object from (optional)\r
+\r
+ @return JSON object value\r
+\r
+ @throw std::domain_error if @a init is not a pair whose first elements are\r
+ strings; thrown by\r
+ @ref basic_json(std::initializer_list<basic_json>, bool, value_t)\r
+\r
+ @complexity Linear in the size of @a init.\r
+\r
+ @liveexample{The following code shows an example for the `object`\r
+ function.,object}\r
+\r
+ @sa @ref basic_json(std::initializer_list<basic_json>, bool, value_t) --\r
+ create a JSON value from an initializer list\r
+ @sa @ref array(std::initializer_list<basic_json>) -- create a JSON array\r
+ value from an initializer list\r
+\r
+ @since version 1.0.0\r
+ */\r
+ static basic_json object(std::initializer_list<basic_json> init =\r
+ std::initializer_list<basic_json>())\r
+ {\r
+ return basic_json(init, false, value_t::object);\r
+ }\r
+\r
+ /*!\r
+ @brief construct an array with count copies of given value\r
+\r
+ Constructs a JSON array value by creating @a cnt copies of a passed value.\r
+ In case @a cnt is `0`, an empty array is created. As postcondition,\r
+ `std::distance(begin(),end()) == cnt` holds.\r
+\r
+ @param[in] cnt the number of JSON copies of @a val to create\r
+ @param[in] val the JSON value to copy\r
+\r
+ @complexity Linear in @a cnt.\r
+\r
+ @liveexample{The following code shows examples for the @ref\r
+ basic_json(size_type\, const basic_json&)\r
+ constructor.,basic_json__size_type_basic_json}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ basic_json(size_type cnt, const basic_json& val)\r
+ : m_type(value_t::array)\r
+ {\r
+ m_value.array = create<array_t>(cnt, val);\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief construct a JSON container given an iterator range\r
+\r
+ Constructs the JSON value with the contents of the range `[first, last)`.\r
+ The semantics depends on the different types a JSON value can have:\r
+ - In case of primitive types (number, boolean, or string), @a first must\r
+ be `begin()` and @a last must be `end()`. In this case, the value is\r
+ copied. Otherwise, std::out_of_range is thrown.\r
+ - In case of structured types (array, object), the constructor behaves as\r
+ similar versions for `std::vector`.\r
+ - In case of a null type, std::domain_error is thrown.\r
+\r
+ @tparam InputIT an input iterator type (@ref iterator or @ref\r
+ const_iterator)\r
+\r
+ @param[in] first begin of the range to copy from (included)\r
+ @param[in] last end of the range to copy from (excluded)\r
+\r
+ @pre Iterators @a first and @a last must be initialized. **This\r
+ precondition is enforced with an assertion.**\r
+\r
+ @throw std::domain_error if iterators are not compatible; that is, do not\r
+ belong to the same JSON value; example: `"iterators are not compatible"`\r
+ @throw std::out_of_range if iterators are for a primitive type (number,\r
+ boolean, or string) where an out of range error can be detected easily;\r
+ example: `"iterators out of range"`\r
+ @throw std::bad_alloc if allocation for object, array, or string fails\r
+ @throw std::domain_error if called with a null value; example: `"cannot\r
+ use construct with iterators from null"`\r
+\r
+ @complexity Linear in distance between @a first and @a last.\r
+\r
+ @liveexample{The example below shows several ways to create JSON values by\r
+ specifying a subrange with iterators.,basic_json__InputIt_InputIt}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<class InputIT, typename std::enable_if<\r
+ std::is_same<InputIT, typename basic_json_t::iterator>::value or\r
+ std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>\r
+ basic_json(InputIT first, InputIT last)\r
+ {\r
+ assert(first.m_object != nullptr);\r
+ assert(last.m_object != nullptr);\r
+\r
+ // make sure iterator fits the current value\r
+ if (first.m_object != last.m_object)\r
+ {\r
+ JSON_THROW(std::domain_error("iterators are not compatible"));\r
+ }\r
+\r
+ // copy type from first iterator\r
+ m_type = first.m_object->m_type;\r
+\r
+ // check if iterator range is complete for primitive values\r
+ switch (m_type)\r
+ {\r
+ case value_t::boolean:\r
+ case value_t::number_float:\r
+ case value_t::number_integer:\r
+ case value_t::number_unsigned:\r
+ case value_t::string:\r
+ {\r
+ if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())\r
+ {\r
+ JSON_THROW(std::out_of_range("iterators out of range"));\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ break;\r
+ }\r
+ }\r
+\r
+ switch (m_type)\r
+ {\r
+ case value_t::number_integer:\r
+ {\r
+ m_value.number_integer = first.m_object->m_value.number_integer;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ m_value.number_unsigned = first.m_object->m_value.number_unsigned;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ m_value.number_float = first.m_object->m_value.number_float;\r
+ break;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ m_value.boolean = first.m_object->m_value.boolean;\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ m_value = *first.m_object->m_value.string;\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ m_value.object = create<object_t>(first.m_it.object_iterator,\r
+ last.m_it.object_iterator);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ m_value.array = create<array_t>(first.m_it.array_iterator,\r
+ last.m_it.array_iterator);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use construct with iterators from " + first.m_object->type_name()));\r
+ }\r
+ }\r
+\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief construct a JSON value given an input stream\r
+\r
+ @param[in,out] i stream to read a serialized JSON value from\r
+ @param[in] cb a parser callback function of type @ref parser_callback_t\r
+ which is used to control the deserialization by filtering unwanted values\r
+ (optional)\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser. The complexity can be higher if the parser callback function\r
+ @a cb has a super-linear complexity.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+\r
+ @deprecated This constructor is deprecated and will be removed in version\r
+ 3.0.0 to unify the interface of the library. Deserialization will be\r
+ done by stream operators or by calling one of the `parse` functions,\r
+ e.g. @ref parse(std::istream&, const parser_callback_t). That is, calls\r
+ like `json j(i);` for an input stream @a i need to be replaced by\r
+ `json j = json::parse(i);`. See the example below.\r
+\r
+ @liveexample{The example below demonstrates constructing a JSON value from\r
+ a `std::stringstream` with and without callback\r
+ function.,basic_json__istream}\r
+\r
+ @since version 2.0.0, deprecated in version 2.0.3, to be removed in\r
+ version 3.0.0\r
+ */\r
+ JSON_DEPRECATED\r
+ explicit basic_json(std::istream& i, const parser_callback_t cb = nullptr)\r
+ {\r
+ *this = parser(i, cb).parse();\r
+ assert_invariant();\r
+ }\r
+\r
+ ///////////////////////////////////////\r
+ // other constructors and destructor //\r
+ ///////////////////////////////////////\r
+\r
+ /*!\r
+ @brief copy constructor\r
+\r
+ Creates a copy of a given JSON value.\r
+\r
+ @param[in] other the JSON value to copy\r
+\r
+ @complexity Linear in the size of @a other.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is linear.\r
+ - As postcondition, it holds: `other == basic_json(other)`.\r
+\r
+ @throw std::bad_alloc if allocation for object, array, or string fails.\r
+\r
+ @liveexample{The following code shows an example for the copy\r
+ constructor.,basic_json__basic_json}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ basic_json(const basic_json& other)\r
+ : m_type(other.m_type)\r
+ {\r
+ // check of passed value is valid\r
+ other.assert_invariant();\r
+\r
+ switch (m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ m_value = *other.m_value.object;\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ m_value = *other.m_value.array;\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ m_value = *other.m_value.string;\r
+ break;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ m_value = other.m_value.boolean;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_integer:\r
+ {\r
+ m_value = other.m_value.number_integer;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ m_value = other.m_value.number_unsigned;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ m_value = other.m_value.number_float;\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ break;\r
+ }\r
+ }\r
+\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief move constructor\r
+\r
+ Move constructor. Constructs a JSON value with the contents of the given\r
+ value @a other using move semantics. It "steals" the resources from @a\r
+ other and leaves it as JSON null value.\r
+\r
+ @param[in,out] other value to move to this object\r
+\r
+ @post @a other is a JSON null value\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The code below shows the move constructor explicitly called\r
+ via std::move.,basic_json__moveconstructor}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ basic_json(basic_json&& other) noexcept\r
+ : m_type(std::move(other.m_type)),\r
+ m_value(std::move(other.m_value))\r
+ {\r
+ // check that passed value is valid\r
+ other.assert_invariant();\r
+\r
+ // invalidate payload\r
+ other.m_type = value_t::null;\r
+ other.m_value = {};\r
+\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief copy assignment\r
+\r
+ Copy assignment operator. Copies a JSON value via the "copy and swap"\r
+ strategy: It is expressed in terms of the copy constructor, destructor,\r
+ and the swap() member function.\r
+\r
+ @param[in] other value to copy from\r
+\r
+ @complexity Linear.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is linear.\r
+\r
+ @liveexample{The code below shows and example for the copy assignment. It\r
+ creates a copy of value `a` which is then swapped with `b`. Finally\, the\r
+ copy of `a` (which is the null value after the swap) is\r
+ destroyed.,basic_json__copyassignment}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference& operator=(basic_json other) noexcept (\r
+ std::is_nothrow_move_constructible<value_t>::value and\r
+ std::is_nothrow_move_assignable<value_t>::value and\r
+ std::is_nothrow_move_constructible<json_value>::value and\r
+ std::is_nothrow_move_assignable<json_value>::value\r
+ )\r
+ {\r
+ // check that passed value is valid\r
+ other.assert_invariant();\r
+\r
+ using std::swap;\r
+ swap(m_type, other.m_type);\r
+ swap(m_value, other.m_value);\r
+\r
+ assert_invariant();\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief destructor\r
+\r
+ Destroys the JSON value and frees all allocated memory.\r
+\r
+ @complexity Linear.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is linear.\r
+ - All stored elements are destroyed and all memory is freed.\r
+\r
+ @since version 1.0.0\r
+ */\r
+ ~basic_json()\r
+ {\r
+ assert_invariant();\r
+\r
+ switch (m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ AllocatorType<object_t> alloc;\r
+ alloc.destroy(m_value.object);\r
+ alloc.deallocate(m_value.object, 1);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ AllocatorType<array_t> alloc;\r
+ alloc.destroy(m_value.array);\r
+ alloc.deallocate(m_value.array, 1);\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ AllocatorType<string_t> alloc;\r
+ alloc.destroy(m_value.string);\r
+ alloc.deallocate(m_value.string, 1);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ // all other types need no specific destructor\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /// @}\r
+\r
+ public:\r
+ ///////////////////////\r
+ // object inspection //\r
+ ///////////////////////\r
+\r
+ /// @name object inspection\r
+ /// Functions to inspect the type of a JSON value.\r
+ /// @{\r
+\r
+ /*!\r
+ @brief serialization\r
+\r
+ Serialization function for JSON values. The function tries to mimic\r
+ Python's `json.dumps()` function, and currently supports its @a indent\r
+ parameter.\r
+\r
+ @param[in] indent If indent is nonnegative, then array elements and object\r
+ members will be pretty-printed with that indent level. An indent level of\r
+ `0` will only insert newlines. `-1` (the default) selects the most compact\r
+ representation.\r
+\r
+ @return string containing the serialization of the JSON value\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The following example shows the effect of different @a indent\r
+ parameters to the result of the serialization.,dump}\r
+\r
+ @see https://docs.python.org/2/library/json.html#json.dump\r
+\r
+ @since version 1.0.0\r
+ */\r
+ string_t dump(const int indent = -1) const\r
+ {\r
+ std::stringstream ss;\r
+\r
+ if (indent >= 0)\r
+ {\r
+ dump(ss, true, static_cast<unsigned int>(indent));\r
+ }\r
+ else\r
+ {\r
+ dump(ss, false, 0);\r
+ }\r
+\r
+ return ss.str();\r
+ }\r
+\r
+ /*!\r
+ @brief return the type of the JSON value (explicit)\r
+\r
+ Return the type of the JSON value as a value from the @ref value_t\r
+ enumeration.\r
+\r
+ @return the type of the JSON value\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `type()` for all JSON\r
+ types.,type}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr value_t type() const noexcept\r
+ {\r
+ return m_type;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether type is primitive\r
+\r
+ This function returns true iff the JSON type is primitive (string, number,\r
+ boolean, or null).\r
+\r
+ @return `true` if type is primitive (string, number, boolean, or null),\r
+ `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_primitive()` for all JSON\r
+ types.,is_primitive}\r
+\r
+ @sa @ref is_structured() -- returns whether JSON value is structured\r
+ @sa @ref is_null() -- returns whether JSON value is `null`\r
+ @sa @ref is_string() -- returns whether JSON value is a string\r
+ @sa @ref is_boolean() -- returns whether JSON value is a boolean\r
+ @sa @ref is_number() -- returns whether JSON value is a number\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_primitive() const noexcept\r
+ {\r
+ return is_null() or is_string() or is_boolean() or is_number();\r
+ }\r
+\r
+ /*!\r
+ @brief return whether type is structured\r
+\r
+ This function returns true iff the JSON type is structured (array or\r
+ object).\r
+\r
+ @return `true` if type is structured (array or object), `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_structured()` for all JSON\r
+ types.,is_structured}\r
+\r
+ @sa @ref is_primitive() -- returns whether value is primitive\r
+ @sa @ref is_array() -- returns whether value is an array\r
+ @sa @ref is_object() -- returns whether value is an object\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_structured() const noexcept\r
+ {\r
+ return is_array() or is_object();\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is null\r
+\r
+ This function returns true iff the JSON value is null.\r
+\r
+ @return `true` if type is null, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_null()` for all JSON\r
+ types.,is_null}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_null() const noexcept\r
+ {\r
+ return m_type == value_t::null;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is a boolean\r
+\r
+ This function returns true iff the JSON value is a boolean.\r
+\r
+ @return `true` if type is boolean, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_boolean()` for all JSON\r
+ types.,is_boolean}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_boolean() const noexcept\r
+ {\r
+ return m_type == value_t::boolean;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is a number\r
+\r
+ This function returns true iff the JSON value is a number. This includes\r
+ both integer and floating-point values.\r
+\r
+ @return `true` if type is number (regardless whether integer, unsigned\r
+ integer or floating-type), `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_number()` for all JSON\r
+ types.,is_number}\r
+\r
+ @sa @ref is_number_integer() -- check if value is an integer or unsigned\r
+ integer number\r
+ @sa @ref is_number_unsigned() -- check if value is an unsigned integer\r
+ number\r
+ @sa @ref is_number_float() -- check if value is a floating-point number\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_number() const noexcept\r
+ {\r
+ return is_number_integer() or is_number_float();\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is an integer number\r
+\r
+ This function returns true iff the JSON value is an integer or unsigned\r
+ integer number. This excludes floating-point values.\r
+\r
+ @return `true` if type is an integer or unsigned integer number, `false`\r
+ otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_number_integer()` for all\r
+ JSON types.,is_number_integer}\r
+\r
+ @sa @ref is_number() -- check if value is a number\r
+ @sa @ref is_number_unsigned() -- check if value is an unsigned integer\r
+ number\r
+ @sa @ref is_number_float() -- check if value is a floating-point number\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_number_integer() const noexcept\r
+ {\r
+ return m_type == value_t::number_integer or m_type == value_t::number_unsigned;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is an unsigned integer number\r
+\r
+ This function returns true iff the JSON value is an unsigned integer\r
+ number. This excludes floating-point and (signed) integer values.\r
+\r
+ @return `true` if type is an unsigned integer number, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_number_unsigned()` for all\r
+ JSON types.,is_number_unsigned}\r
+\r
+ @sa @ref is_number() -- check if value is a number\r
+ @sa @ref is_number_integer() -- check if value is an integer or unsigned\r
+ integer number\r
+ @sa @ref is_number_float() -- check if value is a floating-point number\r
+\r
+ @since version 2.0.0\r
+ */\r
+ constexpr bool is_number_unsigned() const noexcept\r
+ {\r
+ return m_type == value_t::number_unsigned;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is a floating-point number\r
+\r
+ This function returns true iff the JSON value is a floating-point number.\r
+ This excludes integer and unsigned integer values.\r
+\r
+ @return `true` if type is a floating-point number, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_number_float()` for all\r
+ JSON types.,is_number_float}\r
+\r
+ @sa @ref is_number() -- check if value is number\r
+ @sa @ref is_number_integer() -- check if value is an integer number\r
+ @sa @ref is_number_unsigned() -- check if value is an unsigned integer\r
+ number\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_number_float() const noexcept\r
+ {\r
+ return m_type == value_t::number_float;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is an object\r
+\r
+ This function returns true iff the JSON value is an object.\r
+\r
+ @return `true` if type is object, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_object()` for all JSON\r
+ types.,is_object}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_object() const noexcept\r
+ {\r
+ return m_type == value_t::object;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is an array\r
+\r
+ This function returns true iff the JSON value is an array.\r
+\r
+ @return `true` if type is array, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_array()` for all JSON\r
+ types.,is_array}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_array() const noexcept\r
+ {\r
+ return m_type == value_t::array;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is a string\r
+\r
+ This function returns true iff the JSON value is a string.\r
+\r
+ @return `true` if type is string, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_string()` for all JSON\r
+ types.,is_string}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_string() const noexcept\r
+ {\r
+ return m_type == value_t::string;\r
+ }\r
+\r
+ /*!\r
+ @brief return whether value is discarded\r
+\r
+ This function returns true iff the JSON value was discarded during parsing\r
+ with a callback function (see @ref parser_callback_t).\r
+\r
+ @note This function will always be `false` for JSON values after parsing.\r
+ That is, discarded values can only occur during parsing, but will be\r
+ removed when inside a structured value or replaced by null in other cases.\r
+\r
+ @return `true` if type is discarded, `false` otherwise.\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies `is_discarded()` for all JSON\r
+ types.,is_discarded}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr bool is_discarded() const noexcept\r
+ {\r
+ return m_type == value_t::discarded;\r
+ }\r
+\r
+ /*!\r
+ @brief return the type of the JSON value (implicit)\r
+\r
+ Implicitly return the type of the JSON value as a value from the @ref\r
+ value_t enumeration.\r
+\r
+ @return the type of the JSON value\r
+\r
+ @complexity Constant.\r
+\r
+ @exceptionsafety No-throw guarantee: this member function never throws\r
+ exceptions.\r
+\r
+ @liveexample{The following code exemplifies the @ref value_t operator for\r
+ all JSON types.,operator__value_t}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ constexpr operator value_t() const noexcept\r
+ {\r
+ return m_type;\r
+ }\r
+\r
+ /// @}\r
+\r
+ private:\r
+ //////////////////\r
+ // value access //\r
+ //////////////////\r
+\r
+ /// get a boolean (explicit)\r
+ boolean_t get_impl(boolean_t* /*unused*/) const\r
+ {\r
+ if (is_boolean())\r
+ {\r
+ return m_value.boolean;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("type must be boolean, but is " + type_name()));\r
+ }\r
+\r
+ /// get a pointer to the value (object)\r
+ object_t* get_impl_ptr(object_t* /*unused*/) noexcept\r
+ {\r
+ return is_object() ? m_value.object : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (object)\r
+ constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept\r
+ {\r
+ return is_object() ? m_value.object : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (array)\r
+ array_t* get_impl_ptr(array_t* /*unused*/) noexcept\r
+ {\r
+ return is_array() ? m_value.array : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (array)\r
+ constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept\r
+ {\r
+ return is_array() ? m_value.array : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (string)\r
+ string_t* get_impl_ptr(string_t* /*unused*/) noexcept\r
+ {\r
+ return is_string() ? m_value.string : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (string)\r
+ constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept\r
+ {\r
+ return is_string() ? m_value.string : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (boolean)\r
+ boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept\r
+ {\r
+ return is_boolean() ? &m_value.boolean : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (boolean)\r
+ constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept\r
+ {\r
+ return is_boolean() ? &m_value.boolean : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (integer number)\r
+ number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept\r
+ {\r
+ return is_number_integer() ? &m_value.number_integer : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (integer number)\r
+ constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept\r
+ {\r
+ return is_number_integer() ? &m_value.number_integer : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (unsigned number)\r
+ number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept\r
+ {\r
+ return is_number_unsigned() ? &m_value.number_unsigned : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (unsigned number)\r
+ constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept\r
+ {\r
+ return is_number_unsigned() ? &m_value.number_unsigned : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (floating-point number)\r
+ number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept\r
+ {\r
+ return is_number_float() ? &m_value.number_float : nullptr;\r
+ }\r
+\r
+ /// get a pointer to the value (floating-point number)\r
+ constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept\r
+ {\r
+ return is_number_float() ? &m_value.number_float : nullptr;\r
+ }\r
+\r
+ /*!\r
+ @brief helper function to implement get_ref()\r
+\r
+ This funcion helps to implement get_ref() without code duplication for\r
+ const and non-const overloads\r
+\r
+ @tparam ThisType will be deduced as `basic_json` or `const basic_json`\r
+\r
+ @throw std::domain_error if ReferenceType does not match underlying value\r
+ type of the current JSON\r
+ */\r
+ template<typename ReferenceType, typename ThisType>\r
+ static ReferenceType get_ref_impl(ThisType& obj)\r
+ {\r
+ // helper type\r
+ using PointerType = typename std::add_pointer<ReferenceType>::type;\r
+\r
+ // delegate the call to get_ptr<>()\r
+ auto ptr = obj.template get_ptr<PointerType>();\r
+\r
+ if (ptr != nullptr)\r
+ {\r
+ return *ptr;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("incompatible ReferenceType for get_ref, actual type is " +\r
+ obj.type_name()));\r
+ }\r
+\r
+ public:\r
+ /// @name value access\r
+ /// Direct access to the stored value of a JSON value.\r
+ /// @{\r
+\r
+ /*!\r
+ @brief get special-case overload\r
+\r
+ This overloads avoids a lot of template boilerplate, it can be seen as the\r
+ identity method\r
+\r
+ @tparam BasicJsonType == @ref basic_json\r
+\r
+ @return a copy of *this\r
+\r
+ @complexity Constant.\r
+\r
+ @since version 2.1.0\r
+ */\r
+ template <\r
+ typename BasicJsonType,\r
+ detail::enable_if_t<std::is_same<typename std::remove_const<BasicJsonType>::type,\r
+ basic_json_t>::value,\r
+ int> = 0 >\r
+ basic_json get() const\r
+ {\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief get a value (explicit)\r
+\r
+ Explicit type conversion between the JSON value and a compatible value\r
+ which is [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)\r
+ and [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).\r
+ The value is converted by calling the @ref json_serializer<ValueType>\r
+ `from_json()` method.\r
+\r
+ The function is equivalent to executing\r
+ @code {.cpp}\r
+ ValueType ret;\r
+ JSONSerializer<ValueType>::from_json(*this, ret);\r
+ return ret;\r
+ @endcode\r
+\r
+ This overloads is chosen if:\r
+ - @a ValueType is not @ref basic_json,\r
+ - @ref json_serializer<ValueType> has a `from_json()` method of the form\r
+ `void from_json(const @ref basic_json&, ValueType&)`, and\r
+ - @ref json_serializer<ValueType> does not have a `from_json()` method of\r
+ the form `ValueType from_json(const @ref basic_json&)`\r
+\r
+ @tparam ValueTypeCV the provided value type\r
+ @tparam ValueType the returned value type\r
+\r
+ @return copy of the JSON value, converted to @a ValueType\r
+\r
+ @throw what @ref json_serializer<ValueType> `from_json()` method throws\r
+\r
+ @liveexample{The example below shows several conversions from JSON values\r
+ to other types. There a few things to note: (1) Floating-point numbers can\r
+ be converted to integers\, (2) A JSON array can be converted to a standard\r
+ `std::vector<short>`\, (3) A JSON object can be converted to C++\r
+ associative containers such as `std::unordered_map<std::string\,\r
+ json>`.,get__ValueType_const}\r
+\r
+ @since version 2.1.0\r
+ */\r
+ template <\r
+ typename ValueTypeCV,\r
+ typename ValueType = detail::uncvref_t<ValueTypeCV>,\r
+ detail::enable_if_t <\r
+ not std::is_same<basic_json_t, ValueType>::value and\r
+ detail::has_from_json<basic_json_t, ValueType>::value and\r
+ not detail::has_non_default_from_json<basic_json_t, ValueType>::value,\r
+ int > = 0 >\r
+ ValueType get() const noexcept(noexcept(\r
+ JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))\r
+ {\r
+ // we cannot static_assert on ValueTypeCV being non-const, because\r
+ // there is support for get<const basic_json_t>(), which is why we\r
+ // still need the uncvref\r
+ static_assert(not std::is_reference<ValueTypeCV>::value,\r
+ "get() cannot be used with reference types, you might want to use get_ref()");\r
+ static_assert(std::is_default_constructible<ValueType>::value,\r
+ "types must be DefaultConstructible when used with get()");\r
+\r
+ ValueType ret;\r
+ JSONSerializer<ValueType>::from_json(*this, ret);\r
+ return ret;\r
+ }\r
+\r
+ /*!\r
+ @brief get a value (explicit); special case\r
+\r
+ Explicit type conversion between the JSON value and a compatible value\r
+ which is **not** [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)\r
+ and **not** [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).\r
+ The value is converted by calling the @ref json_serializer<ValueType>\r
+ `from_json()` method.\r
+\r
+ The function is equivalent to executing\r
+ @code {.cpp}\r
+ return JSONSerializer<ValueTypeCV>::from_json(*this);\r
+ @endcode\r
+\r
+ This overloads is chosen if:\r
+ - @a ValueType is not @ref basic_json and\r
+ - @ref json_serializer<ValueType> has a `from_json()` method of the form\r
+ `ValueType from_json(const @ref basic_json&)`\r
+\r
+ @note If @ref json_serializer<ValueType> has both overloads of\r
+ `from_json()`, this one is chosen.\r
+\r
+ @tparam ValueTypeCV the provided value type\r
+ @tparam ValueType the returned value type\r
+\r
+ @return copy of the JSON value, converted to @a ValueType\r
+\r
+ @throw what @ref json_serializer<ValueType> `from_json()` method throws\r
+\r
+ @since version 2.1.0\r
+ */\r
+ template <\r
+ typename ValueTypeCV,\r
+ typename ValueType = detail::uncvref_t<ValueTypeCV>,\r
+ detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and\r
+ detail::has_non_default_from_json<basic_json_t,\r
+ ValueType>::value, int> = 0 >\r
+ ValueType get() const noexcept(noexcept(\r
+ JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))\r
+ {\r
+ static_assert(not std::is_reference<ValueTypeCV>::value,\r
+ "get() cannot be used with reference types, you might want to use get_ref()");\r
+ return JSONSerializer<ValueTypeCV>::from_json(*this);\r
+ }\r
+\r
+ /*!\r
+ @brief get a pointer value (explicit)\r
+\r
+ Explicit pointer access to the internally stored JSON value. No copies are\r
+ made.\r
+\r
+ @warning The pointer becomes invalid if the underlying JSON object\r
+ changes.\r
+\r
+ @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref\r
+ object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,\r
+ @ref number_unsigned_t, or @ref number_float_t.\r
+\r
+ @return pointer to the internally stored JSON value if the requested\r
+ pointer type @a PointerType fits to the JSON value; `nullptr` otherwise\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how pointers to internal values of a\r
+ JSON value can be requested. Note that no type conversions are made and a\r
+ `nullptr` is returned if the value and the requested pointer type does not\r
+ match.,get__PointerType}\r
+\r
+ @sa @ref get_ptr() for explicit pointer-member access\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<typename PointerType, typename std::enable_if<\r
+ std::is_pointer<PointerType>::value, int>::type = 0>\r
+ PointerType get() noexcept\r
+ {\r
+ // delegate the call to get_ptr\r
+ return get_ptr<PointerType>();\r
+ }\r
+\r
+ /*!\r
+ @brief get a pointer value (explicit)\r
+ @copydoc get()\r
+ */\r
+ template<typename PointerType, typename std::enable_if<\r
+ std::is_pointer<PointerType>::value, int>::type = 0>\r
+ constexpr const PointerType get() const noexcept\r
+ {\r
+ // delegate the call to get_ptr\r
+ return get_ptr<PointerType>();\r
+ }\r
+\r
+ /*!\r
+ @brief get a pointer value (implicit)\r
+\r
+ Implicit pointer access to the internally stored JSON value. No copies are\r
+ made.\r
+\r
+ @warning Writing data to the pointee of the result yields an undefined\r
+ state.\r
+\r
+ @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref\r
+ object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,\r
+ @ref number_unsigned_t, or @ref number_float_t. Enforced by a static\r
+ assertion.\r
+\r
+ @return pointer to the internally stored JSON value if the requested\r
+ pointer type @a PointerType fits to the JSON value; `nullptr` otherwise\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how pointers to internal values of a\r
+ JSON value can be requested. Note that no type conversions are made and a\r
+ `nullptr` is returned if the value and the requested pointer type does not\r
+ match.,get_ptr}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<typename PointerType, typename std::enable_if<\r
+ std::is_pointer<PointerType>::value, int>::type = 0>\r
+ PointerType get_ptr() noexcept\r
+ {\r
+ // get the type of the PointerType (remove pointer and const)\r
+ using pointee_t = typename std::remove_const<typename\r
+ std::remove_pointer<typename\r
+ std::remove_const<PointerType>::type>::type>::type;\r
+ // make sure the type matches the allowed types\r
+ static_assert(\r
+ std::is_same<object_t, pointee_t>::value\r
+ or std::is_same<array_t, pointee_t>::value\r
+ or std::is_same<string_t, pointee_t>::value\r
+ or std::is_same<boolean_t, pointee_t>::value\r
+ or std::is_same<number_integer_t, pointee_t>::value\r
+ or std::is_same<number_unsigned_t, pointee_t>::value\r
+ or std::is_same<number_float_t, pointee_t>::value\r
+ , "incompatible pointer type");\r
+\r
+ // delegate the call to get_impl_ptr<>()\r
+ return get_impl_ptr(static_cast<PointerType>(nullptr));\r
+ }\r
+\r
+ /*!\r
+ @brief get a pointer value (implicit)\r
+ @copydoc get_ptr()\r
+ */\r
+ template<typename PointerType, typename std::enable_if<\r
+ std::is_pointer<PointerType>::value and\r
+ std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>\r
+ constexpr const PointerType get_ptr() const noexcept\r
+ {\r
+ // get the type of the PointerType (remove pointer and const)\r
+ using pointee_t = typename std::remove_const<typename\r
+ std::remove_pointer<typename\r
+ std::remove_const<PointerType>::type>::type>::type;\r
+ // make sure the type matches the allowed types\r
+ static_assert(\r
+ std::is_same<object_t, pointee_t>::value\r
+ or std::is_same<array_t, pointee_t>::value\r
+ or std::is_same<string_t, pointee_t>::value\r
+ or std::is_same<boolean_t, pointee_t>::value\r
+ or std::is_same<number_integer_t, pointee_t>::value\r
+ or std::is_same<number_unsigned_t, pointee_t>::value\r
+ or std::is_same<number_float_t, pointee_t>::value\r
+ , "incompatible pointer type");\r
+\r
+ // delegate the call to get_impl_ptr<>() const\r
+ return get_impl_ptr(static_cast<const PointerType>(nullptr));\r
+ }\r
+\r
+ /*!\r
+ @brief get a reference value (implicit)\r
+\r
+ Implicit reference access to the internally stored JSON value. No copies\r
+ are made.\r
+\r
+ @warning Writing data to the referee of the result yields an undefined\r
+ state.\r
+\r
+ @tparam ReferenceType reference type; must be a reference to @ref array_t,\r
+ @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or\r
+ @ref number_float_t. Enforced by static assertion.\r
+\r
+ @return reference to the internally stored JSON value if the requested\r
+ reference type @a ReferenceType fits to the JSON value; throws\r
+ std::domain_error otherwise\r
+\r
+ @throw std::domain_error in case passed type @a ReferenceType is\r
+ incompatible with the stored JSON value\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example shows several calls to `get_ref()`.,get_ref}\r
+\r
+ @since version 1.1.0\r
+ */\r
+ template<typename ReferenceType, typename std::enable_if<\r
+ std::is_reference<ReferenceType>::value, int>::type = 0>\r
+ ReferenceType get_ref()\r
+ {\r
+ // delegate call to get_ref_impl\r
+ return get_ref_impl<ReferenceType>(*this);\r
+ }\r
+\r
+ /*!\r
+ @brief get a reference value (implicit)\r
+ @copydoc get_ref()\r
+ */\r
+ template<typename ReferenceType, typename std::enable_if<\r
+ std::is_reference<ReferenceType>::value and\r
+ std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>\r
+ ReferenceType get_ref() const\r
+ {\r
+ // delegate call to get_ref_impl\r
+ return get_ref_impl<ReferenceType>(*this);\r
+ }\r
+\r
+ /*!\r
+ @brief get a value (implicit)\r
+\r
+ Implicit type conversion between the JSON value and a compatible value.\r
+ The call is realized by calling @ref get() const.\r
+\r
+ @tparam ValueType non-pointer type compatible to the JSON value, for\r
+ instance `int` for JSON integer numbers, `bool` for JSON booleans, or\r
+ `std::vector` types for JSON arrays. The character type of @ref string_t\r
+ as well as an initializer list of this type is excluded to avoid\r
+ ambiguities as these types implicitly convert to `std::string`.\r
+\r
+ @return copy of the JSON value, converted to type @a ValueType\r
+\r
+ @throw std::domain_error in case passed type @a ValueType is incompatible\r
+ to JSON, thrown by @ref get() const\r
+\r
+ @complexity Linear in the size of the JSON value.\r
+\r
+ @liveexample{The example below shows several conversions from JSON values\r
+ to other types. There a few things to note: (1) Floating-point numbers can\r
+ be converted to integers\, (2) A JSON array can be converted to a standard\r
+ `std::vector<short>`\, (3) A JSON object can be converted to C++\r
+ associative containers such as `std::unordered_map<std::string\,\r
+ json>`.,operator__ValueType}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template < typename ValueType, typename std::enable_if <\r
+ not std::is_pointer<ValueType>::value and\r
+ not std::is_same<ValueType, typename string_t::value_type>::value\r
+#ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015\r
+ and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value\r
+#endif\r
+ , int >::type = 0 >\r
+ operator ValueType() const\r
+ {\r
+ // delegate the call to get<>() const\r
+ return get<ValueType>();\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ ////////////////////\r
+ // element access //\r
+ ////////////////////\r
+\r
+ /// @name element access\r
+ /// Access to the JSON value.\r
+ /// @{\r
+\r
+ /*!\r
+ @brief access specified array element with bounds checking\r
+\r
+ Returns a reference to the element at specified location @a idx, with\r
+ bounds checking.\r
+\r
+ @param[in] idx index of the element to access\r
+\r
+ @return reference to the element at index @a idx\r
+\r
+ @throw std::domain_error if the JSON value is not an array; example:\r
+ `"cannot use at() with string"`\r
+ @throw std::out_of_range if the index @a idx is out of range of the array;\r
+ that is, `idx >= size()`; example: `"array index 7 is out of range"`\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how array elements can be read and\r
+ written using `at()`.,at__size_type}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference at(size_type idx)\r
+ {\r
+ // at only works for arrays\r
+ if (is_array())\r
+ {\r
+ JSON_TRY\r
+ {\r
+ return m_value.array->at(idx);\r
+ }\r
+ JSON_CATCH (std::out_of_range&)\r
+ {\r
+ // create better exception explanation\r
+ JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));\r
+ }\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use at() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief access specified array element with bounds checking\r
+\r
+ Returns a const reference to the element at specified location @a idx,\r
+ with bounds checking.\r
+\r
+ @param[in] idx index of the element to access\r
+\r
+ @return const reference to the element at index @a idx\r
+\r
+ @throw std::domain_error if the JSON value is not an array; example:\r
+ `"cannot use at() with string"`\r
+ @throw std::out_of_range if the index @a idx is out of range of the array;\r
+ that is, `idx >= size()`; example: `"array index 7 is out of range"`\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how array elements can be read using\r
+ `at()`.,at__size_type_const}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_reference at(size_type idx) const\r
+ {\r
+ // at only works for arrays\r
+ if (is_array())\r
+ {\r
+ JSON_TRY\r
+ {\r
+ return m_value.array->at(idx);\r
+ }\r
+ JSON_CATCH (std::out_of_range&)\r
+ {\r
+ // create better exception explanation\r
+ JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));\r
+ }\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use at() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element with bounds checking\r
+\r
+ Returns a reference to the element at with specified key @a key, with\r
+ bounds checking.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return reference to the element at key @a key\r
+\r
+ @throw std::domain_error if the JSON value is not an object; example:\r
+ `"cannot use at() with boolean"`\r
+ @throw std::out_of_range if the key @a key is is not stored in the object;\r
+ that is, `find(key) == end()`; example: `"key "the fast" not found"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read and\r
+ written using `at()`.,at__object_t_key_type}\r
+\r
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked\r
+ access by reference\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference at(const typename object_t::key_type& key)\r
+ {\r
+ // at only works for objects\r
+ if (is_object())\r
+ {\r
+ JSON_TRY\r
+ {\r
+ return m_value.object->at(key);\r
+ }\r
+ JSON_CATCH (std::out_of_range&)\r
+ {\r
+ // create better exception explanation\r
+ JSON_THROW(std::out_of_range("key '" + key + "' not found"));\r
+ }\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use at() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element with bounds checking\r
+\r
+ Returns a const reference to the element at with specified key @a key,\r
+ with bounds checking.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return const reference to the element at key @a key\r
+\r
+ @throw std::domain_error if the JSON value is not an object; example:\r
+ `"cannot use at() with boolean"`\r
+ @throw std::out_of_range if the key @a key is is not stored in the object;\r
+ that is, `find(key) == end()`; example: `"key "the fast" not found"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read using\r
+ `at()`.,at__object_t_key_type_const}\r
+\r
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked\r
+ access by reference\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_reference at(const typename object_t::key_type& key) const\r
+ {\r
+ // at only works for objects\r
+ if (is_object())\r
+ {\r
+ JSON_TRY\r
+ {\r
+ return m_value.object->at(key);\r
+ }\r
+ JSON_CATCH (std::out_of_range&)\r
+ {\r
+ // create better exception explanation\r
+ JSON_THROW(std::out_of_range("key '" + key + "' not found"));\r
+ }\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use at() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief access specified array element\r
+\r
+ Returns a reference to the element at specified location @a idx.\r
+\r
+ @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),\r
+ then the array is silently filled up with `null` values to make `idx` a\r
+ valid reference to the last stored element.\r
+\r
+ @param[in] idx index of the element to access\r
+\r
+ @return reference to the element at index @a idx\r
+\r
+ @throw std::domain_error if JSON is not an array or null; example:\r
+ `"cannot use operator[] with string"`\r
+\r
+ @complexity Constant if @a idx is in the range of the array. Otherwise\r
+ linear in `idx - size()`.\r
+\r
+ @liveexample{The example below shows how array elements can be read and\r
+ written using `[]` operator. Note the addition of `null`\r
+ values.,operatorarray__size_type}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference operator[](size_type idx)\r
+ {\r
+ // implicitly convert null value to an empty array\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::array;\r
+ m_value.array = create<array_t>();\r
+ assert_invariant();\r
+ }\r
+\r
+ // operator[] only works for arrays\r
+ if (is_array())\r
+ {\r
+ // fill up array with null values if given idx is outside range\r
+ if (idx >= m_value.array->size())\r
+ {\r
+ m_value.array->insert(m_value.array->end(),\r
+ idx - m_value.array->size() + 1,\r
+ basic_json());\r
+ }\r
+\r
+ return m_value.array->operator[](idx);\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief access specified array element\r
+\r
+ Returns a const reference to the element at specified location @a idx.\r
+\r
+ @param[in] idx index of the element to access\r
+\r
+ @return const reference to the element at index @a idx\r
+\r
+ @throw std::domain_error if JSON is not an array; example: `"cannot use\r
+ operator[] with null"`\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how array elements can be read using\r
+ the `[]` operator.,operatorarray__size_type_const}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_reference operator[](size_type idx) const\r
+ {\r
+ // const operator[] only works for arrays\r
+ if (is_array())\r
+ {\r
+ return m_value.array->operator[](idx);\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element\r
+\r
+ Returns a reference to the element at with specified key @a key.\r
+\r
+ @note If @a key is not found in the object, then it is silently added to\r
+ the object and filled with a `null` value to make `key` a valid reference.\r
+ In case the value was `null` before, it is converted to an object.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return reference to the element at key @a key\r
+\r
+ @throw std::domain_error if JSON is not an object or null; example:\r
+ `"cannot use operator[] with string"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read and\r
+ written using the `[]` operator.,operatorarray__key_type}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference operator[](const typename object_t::key_type& key)\r
+ {\r
+ // implicitly convert null value to an empty object\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::object;\r
+ m_value.object = create<object_t>();\r
+ assert_invariant();\r
+ }\r
+\r
+ // operator[] only works for objects\r
+ if (is_object())\r
+ {\r
+ return m_value.object->operator[](key);\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief read-only access specified object element\r
+\r
+ Returns a const reference to the element at with specified key @a key. No\r
+ bounds checking is performed.\r
+\r
+ @warning If the element with key @a key does not exist, the behavior is\r
+ undefined.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return const reference to the element at key @a key\r
+\r
+ @pre The element with key @a key must exist. **This precondition is\r
+ enforced with an assertion.**\r
+\r
+ @throw std::domain_error if JSON is not an object; example: `"cannot use\r
+ operator[] with null"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read using\r
+ the `[]` operator.,operatorarray__key_type_const}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_reference operator[](const typename object_t::key_type& key) const\r
+ {\r
+ // const operator[] only works for objects\r
+ if (is_object())\r
+ {\r
+ assert(m_value.object->find(key) != m_value.object->end());\r
+ return m_value.object->find(key)->second;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element\r
+\r
+ Returns a reference to the element at with specified key @a key.\r
+\r
+ @note If @a key is not found in the object, then it is silently added to\r
+ the object and filled with a `null` value to make `key` a valid reference.\r
+ In case the value was `null` before, it is converted to an object.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return reference to the element at key @a key\r
+\r
+ @throw std::domain_error if JSON is not an object or null; example:\r
+ `"cannot use operator[] with string"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read and\r
+ written using the `[]` operator.,operatorarray__key_type}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<typename T, std::size_t n>\r
+ reference operator[](T * (&key)[n])\r
+ {\r
+ return operator[](static_cast<const T>(key));\r
+ }\r
+\r
+ /*!\r
+ @brief read-only access specified object element\r
+\r
+ Returns a const reference to the element at with specified key @a key. No\r
+ bounds checking is performed.\r
+\r
+ @warning If the element with key @a key does not exist, the behavior is\r
+ undefined.\r
+\r
+ @note This function is required for compatibility reasons with Clang.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return const reference to the element at key @a key\r
+\r
+ @throw std::domain_error if JSON is not an object; example: `"cannot use\r
+ operator[] with null"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read using\r
+ the `[]` operator.,operatorarray__key_type_const}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<typename T, std::size_t n>\r
+ const_reference operator[](T * (&key)[n]) const\r
+ {\r
+ return operator[](static_cast<const T>(key));\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element\r
+\r
+ Returns a reference to the element at with specified key @a key.\r
+\r
+ @note If @a key is not found in the object, then it is silently added to\r
+ the object and filled with a `null` value to make `key` a valid reference.\r
+ In case the value was `null` before, it is converted to an object.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return reference to the element at key @a key\r
+\r
+ @throw std::domain_error if JSON is not an object or null; example:\r
+ `"cannot use operator[] with string"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read and\r
+ written using the `[]` operator.,operatorarray__key_type}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.1.0\r
+ */\r
+ template<typename T>\r
+ reference operator[](T* key)\r
+ {\r
+ // implicitly convert null to object\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::object;\r
+ m_value = value_t::object;\r
+ assert_invariant();\r
+ }\r
+\r
+ // at only works for objects\r
+ if (is_object())\r
+ {\r
+ return m_value.object->operator[](key);\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief read-only access specified object element\r
+\r
+ Returns a const reference to the element at with specified key @a key. No\r
+ bounds checking is performed.\r
+\r
+ @warning If the element with key @a key does not exist, the behavior is\r
+ undefined.\r
+\r
+ @param[in] key key of the element to access\r
+\r
+ @return const reference to the element at key @a key\r
+\r
+ @pre The element with key @a key must exist. **This precondition is\r
+ enforced with an assertion.**\r
+\r
+ @throw std::domain_error if JSON is not an object; example: `"cannot use\r
+ operator[] with null"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be read using\r
+ the `[]` operator.,operatorarray__key_type_const}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref value() for access by value with a default value\r
+\r
+ @since version 1.1.0\r
+ */\r
+ template<typename T>\r
+ const_reference operator[](T* key) const\r
+ {\r
+ // at only works for objects\r
+ if (is_object())\r
+ {\r
+ assert(m_value.object->find(key) != m_value.object->end());\r
+ return m_value.object->find(key)->second;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use operator[] with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element with default value\r
+\r
+ Returns either a copy of an object's element at the specified key @a key\r
+ or a given default value if no element with key @a key exists.\r
+\r
+ The function is basically equivalent to executing\r
+ @code {.cpp}\r
+ try {\r
+ return at(key);\r
+ } catch(std::out_of_range) {\r
+ return default_value;\r
+ }\r
+ @endcode\r
+\r
+ @note Unlike @ref at(const typename object_t::key_type&), this function\r
+ does not throw if the given key @a key was not found.\r
+\r
+ @note Unlike @ref operator[](const typename object_t::key_type& key), this\r
+ function does not implicitly add an element to the position defined by @a\r
+ key. This function is furthermore also applicable to const objects.\r
+\r
+ @param[in] key key of the element to access\r
+ @param[in] default_value the value to return if @a key is not found\r
+\r
+ @tparam ValueType type compatible to JSON values, for instance `int` for\r
+ JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for\r
+ JSON arrays. Note the type of the expected value at @a key and the default\r
+ value @a default_value must be compatible.\r
+\r
+ @return copy of the element at key @a key or @a default_value if @a key\r
+ is not found\r
+\r
+ @throw std::domain_error if JSON is not an object; example: `"cannot use\r
+ value() with null"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be queried\r
+ with a default value.,basic_json__value}\r
+\r
+ @sa @ref at(const typename object_t::key_type&) for access by reference\r
+ with range checking\r
+ @sa @ref operator[](const typename object_t::key_type&) for unchecked\r
+ access by reference\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<class ValueType, typename std::enable_if<\r
+ std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>\r
+ ValueType value(const typename object_t::key_type& key, ValueType default_value) const\r
+ {\r
+ // at only works for objects\r
+ if (is_object())\r
+ {\r
+ // if key is found, return value and given default value otherwise\r
+ const auto it = find(key);\r
+ if (it != end())\r
+ {\r
+ return *it;\r
+ }\r
+\r
+ return default_value;\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use value() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief overload for a default value of type const char*\r
+ @copydoc basic_json::value(const typename object_t::key_type&, ValueType) const\r
+ */\r
+ string_t value(const typename object_t::key_type& key, const char* default_value) const\r
+ {\r
+ return value(key, string_t(default_value));\r
+ }\r
+\r
+ /*!\r
+ @brief access specified object element via JSON Pointer with default value\r
+\r
+ Returns either a copy of an object's element at the specified key @a key\r
+ or a given default value if no element with key @a key exists.\r
+\r
+ The function is basically equivalent to executing\r
+ @code {.cpp}\r
+ try {\r
+ return at(ptr);\r
+ } catch(std::out_of_range) {\r
+ return default_value;\r
+ }\r
+ @endcode\r
+\r
+ @note Unlike @ref at(const json_pointer&), this function does not throw\r
+ if the given key @a key was not found.\r
+\r
+ @param[in] ptr a JSON pointer to the element to access\r
+ @param[in] default_value the value to return if @a ptr found no value\r
+\r
+ @tparam ValueType type compatible to JSON values, for instance `int` for\r
+ JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for\r
+ JSON arrays. Note the type of the expected value at @a key and the default\r
+ value @a default_value must be compatible.\r
+\r
+ @return copy of the element at key @a key or @a default_value if @a key\r
+ is not found\r
+\r
+ @throw std::domain_error if JSON is not an object; example: `"cannot use\r
+ value() with null"`\r
+\r
+ @complexity Logarithmic in the size of the container.\r
+\r
+ @liveexample{The example below shows how object elements can be queried\r
+ with a default value.,basic_json__value_ptr}\r
+\r
+ @sa @ref operator[](const json_pointer&) for unchecked access by reference\r
+\r
+ @since version 2.0.2\r
+ */\r
+ template<class ValueType, typename std::enable_if<\r
+ std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>\r
+ ValueType value(const json_pointer& ptr, ValueType default_value) const\r
+ {\r
+ // at only works for objects\r
+ if (is_object())\r
+ {\r
+ // if pointer resolves a value, return it or use default value\r
+ JSON_TRY\r
+ {\r
+ return ptr.get_checked(this);\r
+ }\r
+ JSON_CATCH (std::out_of_range&)\r
+ {\r
+ return default_value;\r
+ }\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use value() with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief overload for a default value of type const char*\r
+ @copydoc basic_json::value(const json_pointer&, ValueType) const\r
+ */\r
+ string_t value(const json_pointer& ptr, const char* default_value) const\r
+ {\r
+ return value(ptr, string_t(default_value));\r
+ }\r
+\r
+ /*!\r
+ @brief access the first element\r
+\r
+ Returns a reference to the first element in the container. For a JSON\r
+ container `c`, the expression `c.front()` is equivalent to `*c.begin()`.\r
+\r
+ @return In case of a structured type (array or object), a reference to the\r
+ first element is returned. In case of number, string, or boolean values, a\r
+ reference to the value is returned.\r
+\r
+ @complexity Constant.\r
+\r
+ @pre The JSON value must not be `null` (would throw `std::out_of_range`)\r
+ or an empty array or object (undefined behavior, **guarded by\r
+ assertions**).\r
+ @post The JSON value remains unchanged.\r
+\r
+ @throw std::out_of_range when called on `null` value\r
+\r
+ @liveexample{The following code shows an example for `front()`.,front}\r
+\r
+ @sa @ref back() -- access the last element\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference front()\r
+ {\r
+ return *begin();\r
+ }\r
+\r
+ /*!\r
+ @copydoc basic_json::front()\r
+ */\r
+ const_reference front() const\r
+ {\r
+ return *cbegin();\r
+ }\r
+\r
+ /*!\r
+ @brief access the last element\r
+\r
+ Returns a reference to the last element in the container. For a JSON\r
+ container `c`, the expression `c.back()` is equivalent to\r
+ @code {.cpp}\r
+ auto tmp = c.end();\r
+ --tmp;\r
+ return *tmp;\r
+ @endcode\r
+\r
+ @return In case of a structured type (array or object), a reference to the\r
+ last element is returned. In case of number, string, or boolean values, a\r
+ reference to the value is returned.\r
+\r
+ @complexity Constant.\r
+\r
+ @pre The JSON value must not be `null` (would throw `std::out_of_range`)\r
+ or an empty array or object (undefined behavior, **guarded by\r
+ assertions**).\r
+ @post The JSON value remains unchanged.\r
+\r
+ @throw std::out_of_range when called on `null` value.\r
+\r
+ @liveexample{The following code shows an example for `back()`.,back}\r
+\r
+ @sa @ref front() -- access the first element\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reference back()\r
+ {\r
+ auto tmp = end();\r
+ --tmp;\r
+ return *tmp;\r
+ }\r
+\r
+ /*!\r
+ @copydoc basic_json::back()\r
+ */\r
+ const_reference back() const\r
+ {\r
+ auto tmp = cend();\r
+ --tmp;\r
+ return *tmp;\r
+ }\r
+\r
+ /*!\r
+ @brief remove element given an iterator\r
+\r
+ Removes the element specified by iterator @a pos. The iterator @a pos must\r
+ be valid and dereferenceable. Thus the `end()` iterator (which is valid,\r
+ but is not dereferenceable) cannot be used as a value for @a pos.\r
+\r
+ If called on a primitive type other than `null`, the resulting JSON value\r
+ will be `null`.\r
+\r
+ @param[in] pos iterator to the element to remove\r
+ @return Iterator following the last removed element. If the iterator @a\r
+ pos refers to the last element, the `end()` iterator is returned.\r
+\r
+ @tparam IteratorType an @ref iterator or @ref const_iterator\r
+\r
+ @post Invalidates iterators and references at or after the point of the\r
+ erase, including the `end()` iterator.\r
+\r
+ @throw std::domain_error if called on a `null` value; example: `"cannot\r
+ use erase() with null"`\r
+ @throw std::domain_error if called on an iterator which does not belong to\r
+ the current JSON value; example: `"iterator does not fit current value"`\r
+ @throw std::out_of_range if called on a primitive type with invalid\r
+ iterator (i.e., any iterator which is not `begin()`); example: `"iterator\r
+ out of range"`\r
+\r
+ @complexity The complexity depends on the type:\r
+ - objects: amortized constant\r
+ - arrays: linear in distance between @a pos and the end of the container\r
+ - strings: linear in the length of the string\r
+ - other types: constant\r
+\r
+ @liveexample{The example shows the result of `erase()` for different JSON\r
+ types.,erase__IteratorType}\r
+\r
+ @sa @ref erase(IteratorType, IteratorType) -- removes the elements in\r
+ the given range\r
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element\r
+ from an object at the given key\r
+ @sa @ref erase(const size_type) -- removes the element from an array at\r
+ the given index\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<class IteratorType, typename std::enable_if<\r
+ std::is_same<IteratorType, typename basic_json_t::iterator>::value or\r
+ std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type\r
+ = 0>\r
+ IteratorType erase(IteratorType pos)\r
+ {\r
+ // make sure iterator fits the current value\r
+ if (this != pos.m_object)\r
+ {\r
+ JSON_THROW(std::domain_error("iterator does not fit current value"));\r
+ }\r
+\r
+ IteratorType result = end();\r
+\r
+ switch (m_type)\r
+ {\r
+ case value_t::boolean:\r
+ case value_t::number_float:\r
+ case value_t::number_integer:\r
+ case value_t::number_unsigned:\r
+ case value_t::string:\r
+ {\r
+ if (not pos.m_it.primitive_iterator.is_begin())\r
+ {\r
+ JSON_THROW(std::out_of_range("iterator out of range"));\r
+ }\r
+\r
+ if (is_string())\r
+ {\r
+ AllocatorType<string_t> alloc;\r
+ alloc.destroy(m_value.string);\r
+ alloc.deallocate(m_value.string, 1);\r
+ m_value.string = nullptr;\r
+ }\r
+\r
+ m_type = value_t::null;\r
+ assert_invariant();\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief remove elements given an iterator range\r
+\r
+ Removes the element specified by the range `[first; last)`. The iterator\r
+ @a first does not need to be dereferenceable if `first == last`: erasing\r
+ an empty range is a no-op.\r
+\r
+ If called on a primitive type other than `null`, the resulting JSON value\r
+ will be `null`.\r
+\r
+ @param[in] first iterator to the beginning of the range to remove\r
+ @param[in] last iterator past the end of the range to remove\r
+ @return Iterator following the last removed element. If the iterator @a\r
+ second refers to the last element, the `end()` iterator is returned.\r
+\r
+ @tparam IteratorType an @ref iterator or @ref const_iterator\r
+\r
+ @post Invalidates iterators and references at or after the point of the\r
+ erase, including the `end()` iterator.\r
+\r
+ @throw std::domain_error if called on a `null` value; example: `"cannot\r
+ use erase() with null"`\r
+ @throw std::domain_error if called on iterators which does not belong to\r
+ the current JSON value; example: `"iterators do not fit current value"`\r
+ @throw std::out_of_range if called on a primitive type with invalid\r
+ iterators (i.e., if `first != begin()` and `last != end()`); example:\r
+ `"iterators out of range"`\r
+\r
+ @complexity The complexity depends on the type:\r
+ - objects: `log(size()) + std::distance(first, last)`\r
+ - arrays: linear in the distance between @a first and @a last, plus linear\r
+ in the distance between @a last and end of the container\r
+ - strings: linear in the length of the string\r
+ - other types: constant\r
+\r
+ @liveexample{The example shows the result of `erase()` for different JSON\r
+ types.,erase__IteratorType_IteratorType}\r
+\r
+ @sa @ref erase(IteratorType) -- removes the element at a given position\r
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element\r
+ from an object at the given key\r
+ @sa @ref erase(const size_type) -- removes the element from an array at\r
+ the given index\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<class IteratorType, typename std::enable_if<\r
+ std::is_same<IteratorType, typename basic_json_t::iterator>::value or\r
+ std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type\r
+ = 0>\r
+ IteratorType erase(IteratorType first, IteratorType last)\r
+ {\r
+ // make sure iterator fits the current value\r
+ if (this != first.m_object or this != last.m_object)\r
+ {\r
+ JSON_THROW(std::domain_error("iterators do not fit current value"));\r
+ }\r
+\r
+ IteratorType result = end();\r
+\r
+ switch (m_type)\r
+ {\r
+ case value_t::boolean:\r
+ case value_t::number_float:\r
+ case value_t::number_integer:\r
+ case value_t::number_unsigned:\r
+ case value_t::string:\r
+ {\r
+ if (not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())\r
+ {\r
+ JSON_THROW(std::out_of_range("iterators out of range"));\r
+ }\r
+\r
+ if (is_string())\r
+ {\r
+ AllocatorType<string_t> alloc;\r
+ alloc.destroy(m_value.string);\r
+ alloc.deallocate(m_value.string, 1);\r
+ m_value.string = nullptr;\r
+ }\r
+\r
+ m_type = value_t::null;\r
+ assert_invariant();\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,\r
+ last.m_it.object_iterator);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,\r
+ last.m_it.array_iterator);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief remove element from a JSON object given a key\r
+\r
+ Removes elements from a JSON object with the key value @a key.\r
+\r
+ @param[in] key value of the elements to remove\r
+\r
+ @return Number of elements removed. If @a ObjectType is the default\r
+ `std::map` type, the return value will always be `0` (@a key was not\r
+ found) or `1` (@a key was found).\r
+\r
+ @post References and iterators to the erased elements are invalidated.\r
+ Other references and iterators are not affected.\r
+\r
+ @throw std::domain_error when called on a type other than JSON object;\r
+ example: `"cannot use erase() with null"`\r
+\r
+ @complexity `log(size()) + count(key)`\r
+\r
+ @liveexample{The example shows the effect of `erase()`.,erase__key_type}\r
+\r
+ @sa @ref erase(IteratorType) -- removes the element at a given position\r
+ @sa @ref erase(IteratorType, IteratorType) -- removes the elements in\r
+ the given range\r
+ @sa @ref erase(const size_type) -- removes the element from an array at\r
+ the given index\r
+\r
+ @since version 1.0.0\r
+ */\r
+ size_type erase(const typename object_t::key_type& key)\r
+ {\r
+ // this erase only works for objects\r
+ if (is_object())\r
+ {\r
+ return m_value.object->erase(key);\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief remove element from a JSON array given an index\r
+\r
+ Removes element from a JSON array at the index @a idx.\r
+\r
+ @param[in] idx index of the element to remove\r
+\r
+ @throw std::domain_error when called on a type other than JSON array;\r
+ example: `"cannot use erase() with null"`\r
+ @throw std::out_of_range when `idx >= size()`; example: `"array index 17\r
+ is out of range"`\r
+\r
+ @complexity Linear in distance between @a idx and the end of the container.\r
+\r
+ @liveexample{The example shows the effect of `erase()`.,erase__size_type}\r
+\r
+ @sa @ref erase(IteratorType) -- removes the element at a given position\r
+ @sa @ref erase(IteratorType, IteratorType) -- removes the elements in\r
+ the given range\r
+ @sa @ref erase(const typename object_t::key_type&) -- removes the element\r
+ from an object at the given key\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void erase(const size_type idx)\r
+ {\r
+ // this erase only works for arrays\r
+ if (is_array())\r
+ {\r
+ if (idx >= size())\r
+ {\r
+ JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));\r
+ }\r
+\r
+ m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use erase() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ ////////////\r
+ // lookup //\r
+ ////////////\r
+\r
+ /// @name lookup\r
+ /// @{\r
+\r
+ /*!\r
+ @brief find an element in a JSON object\r
+\r
+ Finds an element in a JSON object with key equivalent to @a key. If the\r
+ element is not found or the JSON value is not an object, end() is\r
+ returned.\r
+\r
+ @note This method always returns @ref end() when executed on a JSON type\r
+ that is not an object.\r
+\r
+ @param[in] key key value of the element to search for\r
+\r
+ @return Iterator to an element with key equivalent to @a key. If no such\r
+ element is found or the JSON value is not an object, past-the-end (see\r
+ @ref end()) iterator is returned.\r
+\r
+ @complexity Logarithmic in the size of the JSON object.\r
+\r
+ @liveexample{The example shows how `find()` is used.,find__key_type}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator find(typename object_t::key_type key)\r
+ {\r
+ auto result = end();\r
+\r
+ if (is_object())\r
+ {\r
+ result.m_it.object_iterator = m_value.object->find(key);\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief find an element in a JSON object\r
+ @copydoc find(typename object_t::key_type)\r
+ */\r
+ const_iterator find(typename object_t::key_type key) const\r
+ {\r
+ auto result = cend();\r
+\r
+ if (is_object())\r
+ {\r
+ result.m_it.object_iterator = m_value.object->find(key);\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief returns the number of occurrences of a key in a JSON object\r
+\r
+ Returns the number of elements with key @a key. If ObjectType is the\r
+ default `std::map` type, the return value will always be `0` (@a key was\r
+ not found) or `1` (@a key was found).\r
+\r
+ @note This method always returns `0` when executed on a JSON type that is\r
+ not an object.\r
+\r
+ @param[in] key key value of the element to count\r
+\r
+ @return Number of elements with key @a key. If the JSON value is not an\r
+ object, the return value will be `0`.\r
+\r
+ @complexity Logarithmic in the size of the JSON object.\r
+\r
+ @liveexample{The example shows how `count()` is used.,count}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ size_type count(typename object_t::key_type key) const\r
+ {\r
+ // return 0 for all nonobject types\r
+ return is_object() ? m_value.object->count(key) : 0;\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ ///////////////\r
+ // iterators //\r
+ ///////////////\r
+\r
+ /// @name iterators\r
+ /// @{\r
+\r
+ /*!\r
+ @brief returns an iterator to the first element\r
+\r
+ Returns an iterator to the first element.\r
+\r
+ @image html range-begin-end.svg "Illustration from cppreference.com"\r
+\r
+ @return iterator to the first element\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+\r
+ @liveexample{The following code shows an example for `begin()`.,begin}\r
+\r
+ @sa @ref cbegin() -- returns a const iterator to the beginning\r
+ @sa @ref end() -- returns an iterator to the end\r
+ @sa @ref cend() -- returns a const iterator to the end\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator begin() noexcept\r
+ {\r
+ iterator result(this);\r
+ result.set_begin();\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @copydoc basic_json::cbegin()\r
+ */\r
+ const_iterator begin() const noexcept\r
+ {\r
+ return cbegin();\r
+ }\r
+\r
+ /*!\r
+ @brief returns a const iterator to the first element\r
+\r
+ Returns a const iterator to the first element.\r
+\r
+ @image html range-begin-end.svg "Illustration from cppreference.com"\r
+\r
+ @return const iterator to the first element\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.\r
+\r
+ @liveexample{The following code shows an example for `cbegin()`.,cbegin}\r
+\r
+ @sa @ref begin() -- returns an iterator to the beginning\r
+ @sa @ref end() -- returns an iterator to the end\r
+ @sa @ref cend() -- returns a const iterator to the end\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_iterator cbegin() const noexcept\r
+ {\r
+ const_iterator result(this);\r
+ result.set_begin();\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief returns an iterator to one past the last element\r
+\r
+ Returns an iterator to one past the last element.\r
+\r
+ @image html range-begin-end.svg "Illustration from cppreference.com"\r
+\r
+ @return iterator one past the last element\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+\r
+ @liveexample{The following code shows an example for `end()`.,end}\r
+\r
+ @sa @ref cend() -- returns a const iterator to the end\r
+ @sa @ref begin() -- returns an iterator to the beginning\r
+ @sa @ref cbegin() -- returns a const iterator to the beginning\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator end() noexcept\r
+ {\r
+ iterator result(this);\r
+ result.set_end();\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @copydoc basic_json::cend()\r
+ */\r
+ const_iterator end() const noexcept\r
+ {\r
+ return cend();\r
+ }\r
+\r
+ /*!\r
+ @brief returns a const iterator to one past the last element\r
+\r
+ Returns a const iterator to one past the last element.\r
+\r
+ @image html range-begin-end.svg "Illustration from cppreference.com"\r
+\r
+ @return const iterator one past the last element\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `const_cast<const basic_json&>(*this).end()`.\r
+\r
+ @liveexample{The following code shows an example for `cend()`.,cend}\r
+\r
+ @sa @ref end() -- returns an iterator to the end\r
+ @sa @ref begin() -- returns an iterator to the beginning\r
+ @sa @ref cbegin() -- returns a const iterator to the beginning\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_iterator cend() const noexcept\r
+ {\r
+ const_iterator result(this);\r
+ result.set_end();\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief returns an iterator to the reverse-beginning\r
+\r
+ Returns an iterator to the reverse-beginning; that is, the last element.\r
+\r
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `reverse_iterator(end())`.\r
+\r
+ @liveexample{The following code shows an example for `rbegin()`.,rbegin}\r
+\r
+ @sa @ref crbegin() -- returns a const reverse iterator to the beginning\r
+ @sa @ref rend() -- returns a reverse iterator to the end\r
+ @sa @ref crend() -- returns a const reverse iterator to the end\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reverse_iterator rbegin() noexcept\r
+ {\r
+ return reverse_iterator(end());\r
+ }\r
+\r
+ /*!\r
+ @copydoc basic_json::crbegin()\r
+ */\r
+ const_reverse_iterator rbegin() const noexcept\r
+ {\r
+ return crbegin();\r
+ }\r
+\r
+ /*!\r
+ @brief returns an iterator to the reverse-end\r
+\r
+ Returns an iterator to the reverse-end; that is, one before the first\r
+ element.\r
+\r
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `reverse_iterator(begin())`.\r
+\r
+ @liveexample{The following code shows an example for `rend()`.,rend}\r
+\r
+ @sa @ref crend() -- returns a const reverse iterator to the end\r
+ @sa @ref rbegin() -- returns a reverse iterator to the beginning\r
+ @sa @ref crbegin() -- returns a const reverse iterator to the beginning\r
+\r
+ @since version 1.0.0\r
+ */\r
+ reverse_iterator rend() noexcept\r
+ {\r
+ return reverse_iterator(begin());\r
+ }\r
+\r
+ /*!\r
+ @copydoc basic_json::crend()\r
+ */\r
+ const_reverse_iterator rend() const noexcept\r
+ {\r
+ return crend();\r
+ }\r
+\r
+ /*!\r
+ @brief returns a const reverse iterator to the last element\r
+\r
+ Returns a const iterator to the reverse-beginning; that is, the last\r
+ element.\r
+\r
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.\r
+\r
+ @liveexample{The following code shows an example for `crbegin()`.,crbegin}\r
+\r
+ @sa @ref rbegin() -- returns a reverse iterator to the beginning\r
+ @sa @ref rend() -- returns a reverse iterator to the end\r
+ @sa @ref crend() -- returns a const reverse iterator to the end\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_reverse_iterator crbegin() const noexcept\r
+ {\r
+ return const_reverse_iterator(cend());\r
+ }\r
+\r
+ /*!\r
+ @brief returns a const reverse iterator to one before the first\r
+\r
+ Returns a const reverse iterator to the reverse-end; that is, one before\r
+ the first element.\r
+\r
+ @image html range-rbegin-rend.svg "Illustration from cppreference.com"\r
+\r
+ @complexity Constant.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.\r
+\r
+ @liveexample{The following code shows an example for `crend()`.,crend}\r
+\r
+ @sa @ref rend() -- returns a reverse iterator to the end\r
+ @sa @ref rbegin() -- returns a reverse iterator to the beginning\r
+ @sa @ref crbegin() -- returns a const reverse iterator to the beginning\r
+\r
+ @since version 1.0.0\r
+ */\r
+ const_reverse_iterator crend() const noexcept\r
+ {\r
+ return const_reverse_iterator(cbegin());\r
+ }\r
+\r
+ private:\r
+ // forward declaration\r
+ template<typename IteratorType> class iteration_proxy;\r
+\r
+ public:\r
+ /*!\r
+ @brief wrapper to access iterator member functions in range-based for\r
+\r
+ This function allows to access @ref iterator::key() and @ref\r
+ iterator::value() during range-based for loops. In these loops, a\r
+ reference to the JSON values is returned, so there is no access to the\r
+ underlying iterator.\r
+\r
+ @note The name of this function is not yet final and may change in the\r
+ future.\r
+ */\r
+ static iteration_proxy<iterator> iterator_wrapper(reference cont)\r
+ {\r
+ return iteration_proxy<iterator>(cont);\r
+ }\r
+\r
+ /*!\r
+ @copydoc iterator_wrapper(reference)\r
+ */\r
+ static iteration_proxy<const_iterator> iterator_wrapper(const_reference cont)\r
+ {\r
+ return iteration_proxy<const_iterator>(cont);\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ //////////////\r
+ // capacity //\r
+ //////////////\r
+\r
+ /// @name capacity\r
+ /// @{\r
+\r
+ /*!\r
+ @brief checks whether the container is empty\r
+\r
+ Checks if a JSON value has no elements.\r
+\r
+ @return The return value depends on the different types and is\r
+ defined as follows:\r
+ Value type | return value\r
+ ----------- | -------------\r
+ null | `true`\r
+ boolean | `false`\r
+ string | `false`\r
+ number | `false`\r
+ object | result of function `object_t::empty()`\r
+ array | result of function `array_t::empty()`\r
+\r
+ @note This function does not return whether a string stored as JSON value\r
+ is empty - it returns whether the JSON container itself is empty which is\r
+ false in the case of a string.\r
+\r
+ @complexity Constant, as long as @ref array_t and @ref object_t satisfy\r
+ the Container concept; that is, their `empty()` functions have constant\r
+ complexity.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `begin() == end()`.\r
+\r
+ @liveexample{The following code uses `empty()` to check if a JSON\r
+ object contains any elements.,empty}\r
+\r
+ @sa @ref size() -- returns the number of elements\r
+\r
+ @since version 1.0.0\r
+ */\r
+ bool empty() const noexcept\r
+ {\r
+ switch (m_type)\r
+ {\r
+ case value_t::null:\r
+ {\r
+ // null values are empty\r
+ return true;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ // delegate call to array_t::empty()\r
+ return m_value.array->empty();\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ // delegate call to object_t::empty()\r
+ return m_value.object->empty();\r
+ }\r
+\r
+ default:\r
+ {\r
+ // all other types are nonempty\r
+ return false;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief returns the number of elements\r
+\r
+ Returns the number of elements in a JSON value.\r
+\r
+ @return The return value depends on the different types and is\r
+ defined as follows:\r
+ Value type | return value\r
+ ----------- | -------------\r
+ null | `0`\r
+ boolean | `1`\r
+ string | `1`\r
+ number | `1`\r
+ object | result of function object_t::size()\r
+ array | result of function array_t::size()\r
+\r
+ @note This function does not return the length of a string stored as JSON\r
+ value - it returns the number of elements in the JSON value which is 1 in\r
+ the case of a string.\r
+\r
+ @complexity Constant, as long as @ref array_t and @ref object_t satisfy\r
+ the Container concept; that is, their size() functions have constant\r
+ complexity.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of `std::distance(begin(), end())`.\r
+\r
+ @liveexample{The following code calls `size()` on the different value\r
+ types.,size}\r
+\r
+ @sa @ref empty() -- checks whether the container is empty\r
+ @sa @ref max_size() -- returns the maximal number of elements\r
+\r
+ @since version 1.0.0\r
+ */\r
+ size_type size() const noexcept\r
+ {\r
+ switch (m_type)\r
+ {\r
+ case value_t::null:\r
+ {\r
+ // null values are empty\r
+ return 0;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ // delegate call to array_t::size()\r
+ return m_value.array->size();\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ // delegate call to object_t::size()\r
+ return m_value.object->size();\r
+ }\r
+\r
+ default:\r
+ {\r
+ // all other types have size 1\r
+ return 1;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief returns the maximum possible number of elements\r
+\r
+ Returns the maximum number of elements a JSON value is able to hold due to\r
+ system or library implementation limitations, i.e. `std::distance(begin(),\r
+ end())` for the JSON value.\r
+\r
+ @return The return value depends on the different types and is\r
+ defined as follows:\r
+ Value type | return value\r
+ ----------- | -------------\r
+ null | `0` (same as `size()`)\r
+ boolean | `1` (same as `size()`)\r
+ string | `1` (same as `size()`)\r
+ number | `1` (same as `size()`)\r
+ object | result of function `object_t::max_size()`\r
+ array | result of function `array_t::max_size()`\r
+\r
+ @complexity Constant, as long as @ref array_t and @ref object_t satisfy\r
+ the Container concept; that is, their `max_size()` functions have constant\r
+ complexity.\r
+\r
+ @requirement This function helps `basic_json` satisfying the\r
+ [Container](http://en.cppreference.com/w/cpp/concept/Container)\r
+ requirements:\r
+ - The complexity is constant.\r
+ - Has the semantics of returning `b.size()` where `b` is the largest\r
+ possible JSON value.\r
+\r
+ @liveexample{The following code calls `max_size()` on the different value\r
+ types. Note the output is implementation specific.,max_size}\r
+\r
+ @sa @ref size() -- returns the number of elements\r
+\r
+ @since version 1.0.0\r
+ */\r
+ size_type max_size() const noexcept\r
+ {\r
+ switch (m_type)\r
+ {\r
+ case value_t::array:\r
+ {\r
+ // delegate call to array_t::max_size()\r
+ return m_value.array->max_size();\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ // delegate call to object_t::max_size()\r
+ return m_value.object->max_size();\r
+ }\r
+\r
+ default:\r
+ {\r
+ // all other types have max_size() == size()\r
+ return size();\r
+ }\r
+ }\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ ///////////////\r
+ // modifiers //\r
+ ///////////////\r
+\r
+ /// @name modifiers\r
+ /// @{\r
+\r
+ /*!\r
+ @brief clears the contents\r
+\r
+ Clears the content of a JSON value and resets it to the default value as\r
+ if @ref basic_json(value_t) would have been called:\r
+\r
+ Value type | initial value\r
+ ----------- | -------------\r
+ null | `null`\r
+ boolean | `false`\r
+ string | `""`\r
+ number | `0`\r
+ object | `{}`\r
+ array | `[]`\r
+\r
+ @complexity Linear in the size of the JSON value.\r
+\r
+ @liveexample{The example below shows the effect of `clear()` to different\r
+ JSON types.,clear}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void clear() noexcept\r
+ {\r
+ switch (m_type)\r
+ {\r
+ case value_t::number_integer:\r
+ {\r
+ m_value.number_integer = 0;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ m_value.number_unsigned = 0;\r
+ break;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ m_value.number_float = 0.0;\r
+ break;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ m_value.boolean = false;\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ m_value.string->clear();\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ m_value.array->clear();\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ m_value.object->clear();\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an array\r
+\r
+ Appends the given element @a val to the end of the JSON value. If the\r
+ function is called on a JSON null value, an empty array is created before\r
+ appending @a val.\r
+\r
+ @param[in] val the value to add to the JSON array\r
+\r
+ @throw std::domain_error when called on a type other than JSON array or\r
+ null; example: `"cannot use push_back() with number"`\r
+\r
+ @complexity Amortized constant.\r
+\r
+ @liveexample{The example shows how `push_back()` and `+=` can be used to\r
+ add elements to a JSON array. Note how the `null` value was silently\r
+ converted to a JSON array.,push_back}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void push_back(basic_json&& val)\r
+ {\r
+ // push_back only works for null objects or arrays\r
+ if (not(is_null() or is_array()))\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));\r
+ }\r
+\r
+ // transform null object into an array\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::array;\r
+ m_value = value_t::array;\r
+ assert_invariant();\r
+ }\r
+\r
+ // add element to array (move semantics)\r
+ m_value.array->push_back(std::move(val));\r
+ // invalidate object\r
+ val.m_type = value_t::null;\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an array\r
+ @copydoc push_back(basic_json&&)\r
+ */\r
+ reference operator+=(basic_json&& val)\r
+ {\r
+ push_back(std::move(val));\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an array\r
+ @copydoc push_back(basic_json&&)\r
+ */\r
+ void push_back(const basic_json& val)\r
+ {\r
+ // push_back only works for null objects or arrays\r
+ if (not(is_null() or is_array()))\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));\r
+ }\r
+\r
+ // transform null object into an array\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::array;\r
+ m_value = value_t::array;\r
+ assert_invariant();\r
+ }\r
+\r
+ // add element to array\r
+ m_value.array->push_back(val);\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an array\r
+ @copydoc push_back(basic_json&&)\r
+ */\r
+ reference operator+=(const basic_json& val)\r
+ {\r
+ push_back(val);\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an object\r
+\r
+ Inserts the given element @a val to the JSON object. If the function is\r
+ called on a JSON null value, an empty object is created before inserting\r
+ @a val.\r
+\r
+ @param[in] val the value to add to the JSON object\r
+\r
+ @throw std::domain_error when called on a type other than JSON object or\r
+ null; example: `"cannot use push_back() with number"`\r
+\r
+ @complexity Logarithmic in the size of the container, O(log(`size()`)).\r
+\r
+ @liveexample{The example shows how `push_back()` and `+=` can be used to\r
+ add elements to a JSON object. Note how the `null` value was silently\r
+ converted to a JSON object.,push_back__object_t__value}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void push_back(const typename object_t::value_type& val)\r
+ {\r
+ // push_back only works for null objects or objects\r
+ if (not(is_null() or is_object()))\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use push_back() with " + type_name()));\r
+ }\r
+\r
+ // transform null object into an object\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::object;\r
+ m_value = value_t::object;\r
+ assert_invariant();\r
+ }\r
+\r
+ // add element to array\r
+ m_value.object->insert(val);\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an object\r
+ @copydoc push_back(const typename object_t::value_type&)\r
+ */\r
+ reference operator+=(const typename object_t::value_type& val)\r
+ {\r
+ push_back(val);\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an object\r
+\r
+ This function allows to use `push_back` with an initializer list. In case\r
+\r
+ 1. the current value is an object,\r
+ 2. the initializer list @a init contains only two elements, and\r
+ 3. the first element of @a init is a string,\r
+\r
+ @a init is converted into an object element and added using\r
+ @ref push_back(const typename object_t::value_type&). Otherwise, @a init\r
+ is converted to a JSON value and added using @ref push_back(basic_json&&).\r
+\r
+ @param init an initializer list\r
+\r
+ @complexity Linear in the size of the initializer list @a init.\r
+\r
+ @note This function is required to resolve an ambiguous overload error,\r
+ because pairs like `{"key", "value"}` can be both interpreted as\r
+ `object_t::value_type` or `std::initializer_list<basic_json>`, see\r
+ https://github.com/nlohmann/json/issues/235 for more information.\r
+\r
+ @liveexample{The example shows how initializer lists are treated as\r
+ objects when possible.,push_back__initializer_list}\r
+ */\r
+ void push_back(std::initializer_list<basic_json> init)\r
+ {\r
+ if (is_object() and init.size() == 2 and init.begin()->is_string())\r
+ {\r
+ const string_t key = *init.begin();\r
+ push_back(typename object_t::value_type(key, *(init.begin() + 1)));\r
+ }\r
+ else\r
+ {\r
+ push_back(basic_json(init));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an object\r
+ @copydoc push_back(std::initializer_list<basic_json>)\r
+ */\r
+ reference operator+=(std::initializer_list<basic_json> init)\r
+ {\r
+ push_back(init);\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an array\r
+\r
+ Creates a JSON value from the passed parameters @a args to the end of the\r
+ JSON value. If the function is called on a JSON null value, an empty array\r
+ is created before appending the value created from @a args.\r
+\r
+ @param[in] args arguments to forward to a constructor of @ref basic_json\r
+ @tparam Args compatible types to create a @ref basic_json object\r
+\r
+ @throw std::domain_error when called on a type other than JSON array or\r
+ null; example: `"cannot use emplace_back() with number"`\r
+\r
+ @complexity Amortized constant.\r
+\r
+ @liveexample{The example shows how `push_back()` can be used to add\r
+ elements to a JSON array. Note how the `null` value was silently converted\r
+ to a JSON array.,emplace_back}\r
+\r
+ @since version 2.0.8\r
+ */\r
+ template<class... Args>\r
+ void emplace_back(Args&& ... args)\r
+ {\r
+ // emplace_back only works for null objects or arrays\r
+ if (not(is_null() or is_array()))\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use emplace_back() with " + type_name()));\r
+ }\r
+\r
+ // transform null object into an array\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::array;\r
+ m_value = value_t::array;\r
+ assert_invariant();\r
+ }\r
+\r
+ // add element to array (perfect forwarding)\r
+ m_value.array->emplace_back(std::forward<Args>(args)...);\r
+ }\r
+\r
+ /*!\r
+ @brief add an object to an object if key does not exist\r
+\r
+ Inserts a new element into a JSON object constructed in-place with the\r
+ given @a args if there is no element with the key in the container. If the\r
+ function is called on a JSON null value, an empty object is created before\r
+ appending the value created from @a args.\r
+\r
+ @param[in] args arguments to forward to a constructor of @ref basic_json\r
+ @tparam Args compatible types to create a @ref basic_json object\r
+\r
+ @return a pair consisting of an iterator to the inserted element, or the\r
+ already-existing element if no insertion happened, and a bool\r
+ denoting whether the insertion took place.\r
+\r
+ @throw std::domain_error when called on a type other than JSON object or\r
+ null; example: `"cannot use emplace() with number"`\r
+\r
+ @complexity Logarithmic in the size of the container, O(log(`size()`)).\r
+\r
+ @liveexample{The example shows how `emplace()` can be used to add elements\r
+ to a JSON object. Note how the `null` value was silently converted to a\r
+ JSON object. Further note how no value is added if there was already one\r
+ value stored with the same key.,emplace}\r
+\r
+ @since version 2.0.8\r
+ */\r
+ template<class... Args>\r
+ std::pair<iterator, bool> emplace(Args&& ... args)\r
+ {\r
+ // emplace only works for null objects or arrays\r
+ if (not(is_null() or is_object()))\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use emplace() with " + type_name()));\r
+ }\r
+\r
+ // transform null object into an object\r
+ if (is_null())\r
+ {\r
+ m_type = value_t::object;\r
+ m_value = value_t::object;\r
+ assert_invariant();\r
+ }\r
+\r
+ // add element to array (perfect forwarding)\r
+ auto res = m_value.object->emplace(std::forward<Args>(args)...);\r
+ // create result iterator and set iterator to the result of emplace\r
+ auto it = begin();\r
+ it.m_it.object_iterator = res.first;\r
+\r
+ // return pair of iterator and boolean\r
+ return {it, res.second};\r
+ }\r
+\r
+ /*!\r
+ @brief inserts element\r
+\r
+ Inserts element @a val before iterator @a pos.\r
+\r
+ @param[in] pos iterator before which the content will be inserted; may be\r
+ the end() iterator\r
+ @param[in] val element to insert\r
+ @return iterator pointing to the inserted @a val.\r
+\r
+ @throw std::domain_error if called on JSON values other than arrays;\r
+ example: `"cannot use insert() with string"`\r
+ @throw std::domain_error if @a pos is not an iterator of *this; example:\r
+ `"iterator does not fit current value"`\r
+\r
+ @complexity Constant plus linear in the distance between @a pos and end of\r
+ the container.\r
+\r
+ @liveexample{The example shows how `insert()` is used.,insert}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator insert(const_iterator pos, const basic_json& val)\r
+ {\r
+ // insert only works for arrays\r
+ if (is_array())\r
+ {\r
+ // check if iterator pos fits to this JSON value\r
+ if (pos.m_object != this)\r
+ {\r
+ JSON_THROW(std::domain_error("iterator does not fit current value"));\r
+ }\r
+\r
+ // insert to array and return iterator\r
+ iterator result(this);\r
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);\r
+ return result;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief inserts element\r
+ @copydoc insert(const_iterator, const basic_json&)\r
+ */\r
+ iterator insert(const_iterator pos, basic_json&& val)\r
+ {\r
+ return insert(pos, val);\r
+ }\r
+\r
+ /*!\r
+ @brief inserts elements\r
+\r
+ Inserts @a cnt copies of @a val before iterator @a pos.\r
+\r
+ @param[in] pos iterator before which the content will be inserted; may be\r
+ the end() iterator\r
+ @param[in] cnt number of copies of @a val to insert\r
+ @param[in] val element to insert\r
+ @return iterator pointing to the first element inserted, or @a pos if\r
+ `cnt==0`\r
+\r
+ @throw std::domain_error if called on JSON values other than arrays;\r
+ example: `"cannot use insert() with string"`\r
+ @throw std::domain_error if @a pos is not an iterator of *this; example:\r
+ `"iterator does not fit current value"`\r
+\r
+ @complexity Linear in @a cnt plus linear in the distance between @a pos\r
+ and end of the container.\r
+\r
+ @liveexample{The example shows how `insert()` is used.,insert__count}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator insert(const_iterator pos, size_type cnt, const basic_json& val)\r
+ {\r
+ // insert only works for arrays\r
+ if (is_array())\r
+ {\r
+ // check if iterator pos fits to this JSON value\r
+ if (pos.m_object != this)\r
+ {\r
+ JSON_THROW(std::domain_error("iterator does not fit current value"));\r
+ }\r
+\r
+ // insert to array and return iterator\r
+ iterator result(this);\r
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);\r
+ return result;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));\r
+ }\r
+\r
+ /*!\r
+ @brief inserts elements\r
+\r
+ Inserts elements from range `[first, last)` before iterator @a pos.\r
+\r
+ @param[in] pos iterator before which the content will be inserted; may be\r
+ the end() iterator\r
+ @param[in] first begin of the range of elements to insert\r
+ @param[in] last end of the range of elements to insert\r
+\r
+ @throw std::domain_error if called on JSON values other than arrays;\r
+ example: `"cannot use insert() with string"`\r
+ @throw std::domain_error if @a pos is not an iterator of *this; example:\r
+ `"iterator does not fit current value"`\r
+ @throw std::domain_error if @a first and @a last do not belong to the same\r
+ JSON value; example: `"iterators do not fit"`\r
+ @throw std::domain_error if @a first or @a last are iterators into\r
+ container for which insert is called; example: `"passed iterators may not\r
+ belong to container"`\r
+\r
+ @return iterator pointing to the first element inserted, or @a pos if\r
+ `first==last`\r
+\r
+ @complexity Linear in `std::distance(first, last)` plus linear in the\r
+ distance between @a pos and end of the container.\r
+\r
+ @liveexample{The example shows how `insert()` is used.,insert__range}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator insert(const_iterator pos, const_iterator first, const_iterator last)\r
+ {\r
+ // insert only works for arrays\r
+ if (not is_array())\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));\r
+ }\r
+\r
+ // check if iterator pos fits to this JSON value\r
+ if (pos.m_object != this)\r
+ {\r
+ JSON_THROW(std::domain_error("iterator does not fit current value"));\r
+ }\r
+\r
+ // check if range iterators belong to the same JSON object\r
+ if (first.m_object != last.m_object)\r
+ {\r
+ JSON_THROW(std::domain_error("iterators do not fit"));\r
+ }\r
+\r
+ if (first.m_object == this or last.m_object == this)\r
+ {\r
+ JSON_THROW(std::domain_error("passed iterators may not belong to container"));\r
+ }\r
+\r
+ // insert to array and return iterator\r
+ iterator result(this);\r
+ result.m_it.array_iterator = m_value.array->insert(\r
+ pos.m_it.array_iterator,\r
+ first.m_it.array_iterator,\r
+ last.m_it.array_iterator);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief inserts elements\r
+\r
+ Inserts elements from initializer list @a ilist before iterator @a pos.\r
+\r
+ @param[in] pos iterator before which the content will be inserted; may be\r
+ the end() iterator\r
+ @param[in] ilist initializer list to insert the values from\r
+\r
+ @throw std::domain_error if called on JSON values other than arrays;\r
+ example: `"cannot use insert() with string"`\r
+ @throw std::domain_error if @a pos is not an iterator of *this; example:\r
+ `"iterator does not fit current value"`\r
+\r
+ @return iterator pointing to the first element inserted, or @a pos if\r
+ `ilist` is empty\r
+\r
+ @complexity Linear in `ilist.size()` plus linear in the distance between\r
+ @a pos and end of the container.\r
+\r
+ @liveexample{The example shows how `insert()` is used.,insert__ilist}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ iterator insert(const_iterator pos, std::initializer_list<basic_json> ilist)\r
+ {\r
+ // insert only works for arrays\r
+ if (not is_array())\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use insert() with " + type_name()));\r
+ }\r
+\r
+ // check if iterator pos fits to this JSON value\r
+ if (pos.m_object != this)\r
+ {\r
+ JSON_THROW(std::domain_error("iterator does not fit current value"));\r
+ }\r
+\r
+ // insert to array and return iterator\r
+ iterator result(this);\r
+ result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief exchanges the values\r
+\r
+ Exchanges the contents of the JSON value with those of @a other. Does not\r
+ invoke any move, copy, or swap operations on individual elements. All\r
+ iterators and references remain valid. The past-the-end iterator is\r
+ invalidated.\r
+\r
+ @param[in,out] other JSON value to exchange the contents with\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how JSON values can be swapped with\r
+ `swap()`.,swap__reference}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void swap(reference other) noexcept (\r
+ std::is_nothrow_move_constructible<value_t>::value and\r
+ std::is_nothrow_move_assignable<value_t>::value and\r
+ std::is_nothrow_move_constructible<json_value>::value and\r
+ std::is_nothrow_move_assignable<json_value>::value\r
+ )\r
+ {\r
+ std::swap(m_type, other.m_type);\r
+ std::swap(m_value, other.m_value);\r
+ assert_invariant();\r
+ }\r
+\r
+ /*!\r
+ @brief exchanges the values\r
+\r
+ Exchanges the contents of a JSON array with those of @a other. Does not\r
+ invoke any move, copy, or swap operations on individual elements. All\r
+ iterators and references remain valid. The past-the-end iterator is\r
+ invalidated.\r
+\r
+ @param[in,out] other array to exchange the contents with\r
+\r
+ @throw std::domain_error when JSON value is not an array; example:\r
+ `"cannot use swap() with string"`\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how arrays can be swapped with\r
+ `swap()`.,swap__array_t}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void swap(array_t& other)\r
+ {\r
+ // swap only works for arrays\r
+ if (is_array())\r
+ {\r
+ std::swap(*(m_value.array), other);\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use swap() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief exchanges the values\r
+\r
+ Exchanges the contents of a JSON object with those of @a other. Does not\r
+ invoke any move, copy, or swap operations on individual elements. All\r
+ iterators and references remain valid. The past-the-end iterator is\r
+ invalidated.\r
+\r
+ @param[in,out] other object to exchange the contents with\r
+\r
+ @throw std::domain_error when JSON value is not an object; example:\r
+ `"cannot use swap() with string"`\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how objects can be swapped with\r
+ `swap()`.,swap__object_t}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void swap(object_t& other)\r
+ {\r
+ // swap only works for objects\r
+ if (is_object())\r
+ {\r
+ std::swap(*(m_value.object), other);\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use swap() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief exchanges the values\r
+\r
+ Exchanges the contents of a JSON string with those of @a other. Does not\r
+ invoke any move, copy, or swap operations on individual elements. All\r
+ iterators and references remain valid. The past-the-end iterator is\r
+ invalidated.\r
+\r
+ @param[in,out] other string to exchange the contents with\r
+\r
+ @throw std::domain_error when JSON value is not a string; example: `"cannot\r
+ use swap() with boolean"`\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The example below shows how strings can be swapped with\r
+ `swap()`.,swap__string_t}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ void swap(string_t& other)\r
+ {\r
+ // swap only works for strings\r
+ if (is_string())\r
+ {\r
+ std::swap(*(m_value.string), other);\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use swap() with " + type_name()));\r
+ }\r
+ }\r
+\r
+ /// @}\r
+\r
+ public:\r
+ //////////////////////////////////////////\r
+ // lexicographical comparison operators //\r
+ //////////////////////////////////////////\r
+\r
+ /// @name lexicographical comparison operators\r
+ /// @{\r
+\r
+ /*!\r
+ @brief comparison: equal\r
+\r
+ Compares two JSON values for equality according to the following rules:\r
+ - Two JSON values are equal if (1) they are from the same type and (2)\r
+ their stored values are the same.\r
+ - Integer and floating-point numbers are automatically converted before\r
+ comparison. Floating-point numbers are compared indirectly: two\r
+ floating-point numbers `f1` and `f2` are considered equal if neither\r
+ `f1 > f2` nor `f2 > f1` holds.\r
+ - Two JSON null values are equal.\r
+\r
+ @param[in] lhs first JSON value to consider\r
+ @param[in] rhs second JSON value to consider\r
+ @return whether the values @a lhs and @a rhs are equal\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example demonstrates comparing several JSON\r
+ types.,operator__equal}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend bool operator==(const_reference lhs, const_reference rhs) noexcept\r
+ {\r
+ const auto lhs_type = lhs.type();\r
+ const auto rhs_type = rhs.type();\r
+\r
+ if (lhs_type == rhs_type)\r
+ {\r
+ switch (lhs_type)\r
+ {\r
+ case value_t::array:\r
+ {\r
+ return *lhs.m_value.array == *rhs.m_value.array;\r
+ }\r
+ case value_t::object:\r
+ {\r
+ return *lhs.m_value.object == *rhs.m_value.object;\r
+ }\r
+ case value_t::null:\r
+ {\r
+ return true;\r
+ }\r
+ case value_t::string:\r
+ {\r
+ return *lhs.m_value.string == *rhs.m_value.string;\r
+ }\r
+ case value_t::boolean:\r
+ {\r
+ return lhs.m_value.boolean == rhs.m_value.boolean;\r
+ }\r
+ case value_t::number_integer:\r
+ {\r
+ return lhs.m_value.number_integer == rhs.m_value.number_integer;\r
+ }\r
+ case value_t::number_unsigned:\r
+ {\r
+ return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;\r
+ }\r
+ case value_t::number_float:\r
+ {\r
+ return lhs.m_value.number_float == rhs.m_value.number_float;\r
+ }\r
+ default:\r
+ {\r
+ return false;\r
+ }\r
+ }\r
+ }\r
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)\r
+ {\r
+ return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;\r
+ }\r
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)\r
+ {\r
+ return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);\r
+ }\r
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)\r
+ {\r
+ return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;\r
+ }\r
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)\r
+ {\r
+ return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);\r
+ }\r
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)\r
+ {\r
+ return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;\r
+ }\r
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)\r
+ {\r
+ return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);\r
+ }\r
+\r
+ return false;\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: equal\r
+ @copydoc operator==(const_reference, const_reference)\r
+ */\r
+ template<typename ScalarType, typename std::enable_if<\r
+ std::is_scalar<ScalarType>::value, int>::type = 0>\r
+ friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept\r
+ {\r
+ return (lhs == basic_json(rhs));\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: equal\r
+ @copydoc operator==(const_reference, const_reference)\r
+ */\r
+ template<typename ScalarType, typename std::enable_if<\r
+ std::is_scalar<ScalarType>::value, int>::type = 0>\r
+ friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept\r
+ {\r
+ return (basic_json(lhs) == rhs);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: not equal\r
+\r
+ Compares two JSON values for inequality by calculating `not (lhs == rhs)`.\r
+\r
+ @param[in] lhs first JSON value to consider\r
+ @param[in] rhs second JSON value to consider\r
+ @return whether the values @a lhs and @a rhs are not equal\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example demonstrates comparing several JSON\r
+ types.,operator__notequal}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend bool operator!=(const_reference lhs, const_reference rhs) noexcept\r
+ {\r
+ return not (lhs == rhs);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: not equal\r
+ @copydoc operator!=(const_reference, const_reference)\r
+ */\r
+ template<typename ScalarType, typename std::enable_if<\r
+ std::is_scalar<ScalarType>::value, int>::type = 0>\r
+ friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept\r
+ {\r
+ return (lhs != basic_json(rhs));\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: not equal\r
+ @copydoc operator!=(const_reference, const_reference)\r
+ */\r
+ template<typename ScalarType, typename std::enable_if<\r
+ std::is_scalar<ScalarType>::value, int>::type = 0>\r
+ friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept\r
+ {\r
+ return (basic_json(lhs) != rhs);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: less than\r
+\r
+ Compares whether one JSON value @a lhs is less than another JSON value @a\r
+ rhs according to the following rules:\r
+ - If @a lhs and @a rhs have the same type, the values are compared using\r
+ the default `<` operator.\r
+ - Integer and floating-point numbers are automatically converted before\r
+ comparison\r
+ - In case @a lhs and @a rhs have different types, the values are ignored\r
+ and the order of the types is considered, see\r
+ @ref operator<(const value_t, const value_t).\r
+\r
+ @param[in] lhs first JSON value to consider\r
+ @param[in] rhs second JSON value to consider\r
+ @return whether @a lhs is less than @a rhs\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example demonstrates comparing several JSON\r
+ types.,operator__less}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend bool operator<(const_reference lhs, const_reference rhs) noexcept\r
+ {\r
+ const auto lhs_type = lhs.type();\r
+ const auto rhs_type = rhs.type();\r
+\r
+ if (lhs_type == rhs_type)\r
+ {\r
+ switch (lhs_type)\r
+ {\r
+ case value_t::array:\r
+ {\r
+ return *lhs.m_value.array < *rhs.m_value.array;\r
+ }\r
+ case value_t::object:\r
+ {\r
+ return *lhs.m_value.object < *rhs.m_value.object;\r
+ }\r
+ case value_t::null:\r
+ {\r
+ return false;\r
+ }\r
+ case value_t::string:\r
+ {\r
+ return *lhs.m_value.string < *rhs.m_value.string;\r
+ }\r
+ case value_t::boolean:\r
+ {\r
+ return lhs.m_value.boolean < rhs.m_value.boolean;\r
+ }\r
+ case value_t::number_integer:\r
+ {\r
+ return lhs.m_value.number_integer < rhs.m_value.number_integer;\r
+ }\r
+ case value_t::number_unsigned:\r
+ {\r
+ return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;\r
+ }\r
+ case value_t::number_float:\r
+ {\r
+ return lhs.m_value.number_float < rhs.m_value.number_float;\r
+ }\r
+ default:\r
+ {\r
+ return false;\r
+ }\r
+ }\r
+ }\r
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)\r
+ {\r
+ return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;\r
+ }\r
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)\r
+ {\r
+ return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);\r
+ }\r
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)\r
+ {\r
+ return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;\r
+ }\r
+ else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)\r
+ {\r
+ return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);\r
+ }\r
+ else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)\r
+ {\r
+ return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);\r
+ }\r
+ else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)\r
+ {\r
+ return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;\r
+ }\r
+\r
+ // We only reach this line if we cannot compare values. In that case,\r
+ // we compare types. Note we have to call the operator explicitly,\r
+ // because MSVC has problems otherwise.\r
+ return operator<(lhs_type, rhs_type);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: less than or equal\r
+\r
+ Compares whether one JSON value @a lhs is less than or equal to another\r
+ JSON value by calculating `not (rhs < lhs)`.\r
+\r
+ @param[in] lhs first JSON value to consider\r
+ @param[in] rhs second JSON value to consider\r
+ @return whether @a lhs is less than or equal to @a rhs\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example demonstrates comparing several JSON\r
+ types.,operator__greater}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend bool operator<=(const_reference lhs, const_reference rhs) noexcept\r
+ {\r
+ return not (rhs < lhs);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: greater than\r
+\r
+ Compares whether one JSON value @a lhs is greater than another\r
+ JSON value by calculating `not (lhs <= rhs)`.\r
+\r
+ @param[in] lhs first JSON value to consider\r
+ @param[in] rhs second JSON value to consider\r
+ @return whether @a lhs is greater than to @a rhs\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example demonstrates comparing several JSON\r
+ types.,operator__lessequal}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend bool operator>(const_reference lhs, const_reference rhs) noexcept\r
+ {\r
+ return not (lhs <= rhs);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: greater than or equal\r
+\r
+ Compares whether one JSON value @a lhs is greater than or equal to another\r
+ JSON value by calculating `not (lhs < rhs)`.\r
+\r
+ @param[in] lhs first JSON value to consider\r
+ @param[in] rhs second JSON value to consider\r
+ @return whether @a lhs is greater than or equal to @a rhs\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example demonstrates comparing several JSON\r
+ types.,operator__greaterequal}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend bool operator>=(const_reference lhs, const_reference rhs) noexcept\r
+ {\r
+ return not (lhs < rhs);\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ ///////////////////\r
+ // serialization //\r
+ ///////////////////\r
+\r
+ /// @name serialization\r
+ /// @{\r
+\r
+ /*!\r
+ @brief serialize to stream\r
+\r
+ Serialize the given JSON value @a j to the output stream @a o. The JSON\r
+ value will be serialized using the @ref dump member function. The\r
+ indentation of the output can be controlled with the member variable\r
+ `width` of the output stream @a o. For instance, using the manipulator\r
+ `std::setw(4)` on @a o sets the indentation level to `4` and the\r
+ serialization result is the same as calling `dump(4)`.\r
+\r
+ @param[in,out] o stream to serialize to\r
+ @param[in] j JSON value to serialize\r
+\r
+ @return the stream @a o\r
+\r
+ @complexity Linear.\r
+\r
+ @liveexample{The example below shows the serialization with different\r
+ parameters to `width` to adjust the indentation level.,operator_serialize}\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend std::ostream& operator<<(std::ostream& o, const basic_json& j)\r
+ {\r
+ // read width member and use it as indentation parameter if nonzero\r
+ const bool pretty_print = (o.width() > 0);\r
+ const auto indentation = (pretty_print ? o.width() : 0);\r
+\r
+ // reset width to 0 for subsequent calls to this stream\r
+ o.width(0);\r
+\r
+ // do the actual serialization\r
+ j.dump(o, pretty_print, static_cast<unsigned int>(indentation));\r
+\r
+ return o;\r
+ }\r
+\r
+ /*!\r
+ @brief serialize to stream\r
+ @copydoc operator<<(std::ostream&, const basic_json&)\r
+ */\r
+ friend std::ostream& operator>>(const basic_json& j, std::ostream& o)\r
+ {\r
+ return o << j;\r
+ }\r
+\r
+ /// @}\r
+\r
+\r
+ /////////////////////\r
+ // deserialization //\r
+ /////////////////////\r
+\r
+ /// @name deserialization\r
+ /// @{\r
+\r
+ /*!\r
+ @brief deserialize from an array\r
+\r
+ This function reads from an array of 1-byte values.\r
+\r
+ @pre Each element of the container has a size of 1 byte. Violating this\r
+ precondition yields undefined behavior. **This precondition is enforced\r
+ with a static assertion.**\r
+\r
+ @param[in] array array to read from\r
+ @param[in] cb a parser callback function of type @ref parser_callback_t\r
+ which is used to control the deserialization by filtering unwanted values\r
+ (optional)\r
+\r
+ @return result of the deserialization\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser. The complexity can be higher if the parser callback function\r
+ @a cb has a super-linear complexity.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+\r
+ @liveexample{The example below demonstrates the `parse()` function reading\r
+ from an array.,parse__array__parser_callback_t}\r
+\r
+ @since version 2.0.3\r
+ */\r
+ template<class T, std::size_t N>\r
+ static basic_json parse(T (&array)[N],\r
+ const parser_callback_t cb = nullptr)\r
+ {\r
+ // delegate the call to the iterator-range parse overload\r
+ return parse(std::begin(array), std::end(array), cb);\r
+ }\r
+\r
+ /*!\r
+ @brief deserialize from string literal\r
+\r
+ @tparam CharT character/literal type with size of 1 byte\r
+ @param[in] s string literal to read a serialized JSON value from\r
+ @param[in] cb a parser callback function of type @ref parser_callback_t\r
+ which is used to control the deserialization by filtering unwanted values\r
+ (optional)\r
+\r
+ @return result of the deserialization\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser. The complexity can be higher if the parser callback function\r
+ @a cb has a super-linear complexity.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+ @note String containers like `std::string` or @ref string_t can be parsed\r
+ with @ref parse(const ContiguousContainer&, const parser_callback_t)\r
+\r
+ @liveexample{The example below demonstrates the `parse()` function with\r
+ and without callback function.,parse__string__parser_callback_t}\r
+\r
+ @sa @ref parse(std::istream&, const parser_callback_t) for a version that\r
+ reads from an input stream\r
+\r
+ @since version 1.0.0 (originally for @ref string_t)\r
+ */\r
+ template<typename CharT, typename std::enable_if<\r
+ std::is_pointer<CharT>::value and\r
+ std::is_integral<typename std::remove_pointer<CharT>::type>::value and\r
+ sizeof(typename std::remove_pointer<CharT>::type) == 1, int>::type = 0>\r
+ static basic_json parse(const CharT s,\r
+ const parser_callback_t cb = nullptr)\r
+ {\r
+ return parser(reinterpret_cast<const char*>(s), cb).parse();\r
+ }\r
+\r
+ /*!\r
+ @brief deserialize from stream\r
+\r
+ @param[in,out] i stream to read a serialized JSON value from\r
+ @param[in] cb a parser callback function of type @ref parser_callback_t\r
+ which is used to control the deserialization by filtering unwanted values\r
+ (optional)\r
+\r
+ @return result of the deserialization\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser. The complexity can be higher if the parser callback function\r
+ @a cb has a super-linear complexity.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+\r
+ @liveexample{The example below demonstrates the `parse()` function with\r
+ and without callback function.,parse__istream__parser_callback_t}\r
+\r
+ @sa @ref parse(const CharT, const parser_callback_t) for a version\r
+ that reads from a string\r
+\r
+ @since version 1.0.0\r
+ */\r
+ static basic_json parse(std::istream& i,\r
+ const parser_callback_t cb = nullptr)\r
+ {\r
+ return parser(i, cb).parse();\r
+ }\r
+\r
+ /*!\r
+ @copydoc parse(std::istream&, const parser_callback_t)\r
+ */\r
+ static basic_json parse(std::istream&& i,\r
+ const parser_callback_t cb = nullptr)\r
+ {\r
+ return parser(i, cb).parse();\r
+ }\r
+\r
+ /*!\r
+ @brief deserialize from an iterator range with contiguous storage\r
+\r
+ This function reads from an iterator range of a container with contiguous\r
+ storage of 1-byte values. Compatible container types include\r
+ `std::vector`, `std::string`, `std::array`, `std::valarray`, and\r
+ `std::initializer_list`. Furthermore, C-style arrays can be used with\r
+ `std::begin()`/`std::end()`. User-defined containers can be used as long\r
+ as they implement random-access iterators and a contiguous storage.\r
+\r
+ @pre The iterator range is contiguous. Violating this precondition yields\r
+ undefined behavior. **This precondition is enforced with an assertion.**\r
+ @pre Each element in the range has a size of 1 byte. Violating this\r
+ precondition yields undefined behavior. **This precondition is enforced\r
+ with a static assertion.**\r
+\r
+ @warning There is no way to enforce all preconditions at compile-time. If\r
+ the function is called with noncompliant iterators and with\r
+ assertions switched off, the behavior is undefined and will most\r
+ likely yield segmentation violation.\r
+\r
+ @tparam IteratorType iterator of container with contiguous storage\r
+ @param[in] first begin of the range to parse (included)\r
+ @param[in] last end of the range to parse (excluded)\r
+ @param[in] cb a parser callback function of type @ref parser_callback_t\r
+ which is used to control the deserialization by filtering unwanted values\r
+ (optional)\r
+\r
+ @return result of the deserialization\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser. The complexity can be higher if the parser callback function\r
+ @a cb has a super-linear complexity.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+\r
+ @liveexample{The example below demonstrates the `parse()` function reading\r
+ from an iterator range.,parse__iteratortype__parser_callback_t}\r
+\r
+ @since version 2.0.3\r
+ */\r
+ template<class IteratorType, typename std::enable_if<\r
+ std::is_base_of<\r
+ std::random_access_iterator_tag,\r
+ typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>\r
+ static basic_json parse(IteratorType first, IteratorType last,\r
+ const parser_callback_t cb = nullptr)\r
+ {\r
+ // assertion to check that the iterator range is indeed contiguous,\r
+ // see http://stackoverflow.com/a/35008842/266378 for more discussion\r
+ assert(std::accumulate(first, last, std::pair<bool, int>(true, 0),\r
+ [&first](std::pair<bool, int> res, decltype(*first) val)\r
+ {\r
+ res.first &= (val == *(std::next(std::addressof(*first), res.second++)));\r
+ return res;\r
+ }).first);\r
+\r
+ // assertion to check that each element is 1 byte long\r
+ static_assert(sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,\r
+ "each element in the iterator range must have the size of 1 byte");\r
+\r
+ // if iterator range is empty, create a parser with an empty string\r
+ // to generate "unexpected EOF" error message\r
+ if (std::distance(first, last) <= 0)\r
+ {\r
+ return parser("").parse();\r
+ }\r
+\r
+ return parser(first, last, cb).parse();\r
+ }\r
+\r
+ /*!\r
+ @brief deserialize from a container with contiguous storage\r
+\r
+ This function reads from a container with contiguous storage of 1-byte\r
+ values. Compatible container types include `std::vector`, `std::string`,\r
+ `std::array`, and `std::initializer_list`. User-defined containers can be\r
+ used as long as they implement random-access iterators and a contiguous\r
+ storage.\r
+\r
+ @pre The container storage is contiguous. Violating this precondition\r
+ yields undefined behavior. **This precondition is enforced with an\r
+ assertion.**\r
+ @pre Each element of the container has a size of 1 byte. Violating this\r
+ precondition yields undefined behavior. **This precondition is enforced\r
+ with a static assertion.**\r
+\r
+ @warning There is no way to enforce all preconditions at compile-time. If\r
+ the function is called with a noncompliant container and with\r
+ assertions switched off, the behavior is undefined and will most\r
+ likely yield segmentation violation.\r
+\r
+ @tparam ContiguousContainer container type with contiguous storage\r
+ @param[in] c container to read from\r
+ @param[in] cb a parser callback function of type @ref parser_callback_t\r
+ which is used to control the deserialization by filtering unwanted values\r
+ (optional)\r
+\r
+ @return result of the deserialization\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser. The complexity can be higher if the parser callback function\r
+ @a cb has a super-linear complexity.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+\r
+ @liveexample{The example below demonstrates the `parse()` function reading\r
+ from a contiguous container.,parse__contiguouscontainer__parser_callback_t}\r
+\r
+ @since version 2.0.3\r
+ */\r
+ template<class ContiguousContainer, typename std::enable_if<\r
+ not std::is_pointer<ContiguousContainer>::value and\r
+ std::is_base_of<\r
+ std::random_access_iterator_tag,\r
+ typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value\r
+ , int>::type = 0>\r
+ static basic_json parse(const ContiguousContainer& c,\r
+ const parser_callback_t cb = nullptr)\r
+ {\r
+ // delegate the call to the iterator-range parse overload\r
+ return parse(std::begin(c), std::end(c), cb);\r
+ }\r
+\r
+ /*!\r
+ @brief deserialize from stream\r
+\r
+ Deserializes an input stream to a JSON value.\r
+\r
+ @param[in,out] i input stream to read a serialized JSON value from\r
+ @param[in,out] j JSON value to write the deserialized input to\r
+\r
+ @throw std::invalid_argument in case of parse errors\r
+\r
+ @complexity Linear in the length of the input. The parser is a predictive\r
+ LL(1) parser.\r
+\r
+ @note A UTF-8 byte order mark is silently ignored.\r
+\r
+ @liveexample{The example below shows how a JSON value is constructed by\r
+ reading a serialization from a stream.,operator_deserialize}\r
+\r
+ @sa parse(std::istream&, const parser_callback_t) for a variant with a\r
+ parser callback function to filter values while parsing\r
+\r
+ @since version 1.0.0\r
+ */\r
+ friend std::istream& operator<<(basic_json& j, std::istream& i)\r
+ {\r
+ j = parser(i).parse();\r
+ return i;\r
+ }\r
+\r
+ /*!\r
+ @brief deserialize from stream\r
+ @copydoc operator<<(basic_json&, std::istream&)\r
+ */\r
+ friend std::istream& operator>>(std::istream& i, basic_json& j)\r
+ {\r
+ j = parser(i).parse();\r
+ return i;\r
+ }\r
+\r
+ /// @}\r
+\r
+ //////////////////////////////////////////\r
+ // binary serialization/deserialization //\r
+ //////////////////////////////////////////\r
+\r
+ /// @name binary serialization/deserialization support\r
+ /// @{\r
+\r
+ private:\r
+ /*!\r
+ @note Some code in the switch cases has been copied, because otherwise\r
+ copilers would complain about implicit fallthrough and there is no\r
+ portable attribute to mute such warnings.\r
+ */\r
+ template<typename T>\r
+ static void add_to_vector(std::vector<uint8_t>& vec, size_t bytes, const T number)\r
+ {\r
+ assert(bytes == 1 or bytes == 2 or bytes == 4 or bytes == 8);\r
+\r
+ switch (bytes)\r
+ {\r
+ case 8:\r
+ {\r
+ vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 070) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 060) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 050) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((static_cast<uint64_t>(number) >> 040) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((number >> 030) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((number >> 020) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>(number & 0xff));\r
+ break;\r
+ }\r
+\r
+ case 4:\r
+ {\r
+ vec.push_back(static_cast<uint8_t>((number >> 030) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((number >> 020) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>(number & 0xff));\r
+ break;\r
+ }\r
+\r
+ case 2:\r
+ {\r
+ vec.push_back(static_cast<uint8_t>((number >> 010) & 0xff));\r
+ vec.push_back(static_cast<uint8_t>(number & 0xff));\r
+ break;\r
+ }\r
+\r
+ case 1:\r
+ {\r
+ vec.push_back(static_cast<uint8_t>(number & 0xff));\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief take sufficient bytes from a vector to fill an integer variable\r
+\r
+ In the context of binary serialization formats, we need to read several\r
+ bytes from a byte vector and combine them to multi-byte integral data\r
+ types.\r
+\r
+ @param[in] vec byte vector to read from\r
+ @param[in] current_index the position in the vector after which to read\r
+\r
+ @return the next sizeof(T) bytes from @a vec, in reverse order as T\r
+\r
+ @tparam T the integral return type\r
+\r
+ @throw std::out_of_range if there are less than sizeof(T)+1 bytes in the\r
+ vector @a vec to read\r
+\r
+ In the for loop, the bytes from the vector are copied in reverse order into\r
+ the return value. In the figures below, let sizeof(T)=4 and `i` be the loop\r
+ variable.\r
+\r
+ Precondition:\r
+\r
+ vec: | | | a | b | c | d | T: | | | | |\r
+ ^ ^ ^ ^\r
+ current_index i ptr sizeof(T)\r
+\r
+ Postcondition:\r
+\r
+ vec: | | | a | b | c | d | T: | d | c | b | a |\r
+ ^ ^ ^\r
+ | i ptr\r
+ current_index\r
+\r
+ @sa Code adapted from <http://stackoverflow.com/a/41031865/266378>.\r
+ */\r
+ template<typename T>\r
+ static T get_from_vector(const std::vector<uint8_t>& vec, const size_t current_index)\r
+ {\r
+ if (current_index + sizeof(T) + 1 > vec.size())\r
+ {\r
+ JSON_THROW(std::out_of_range("cannot read " + std::to_string(sizeof(T)) + " bytes from vector"));\r
+ }\r
+\r
+ T result;\r
+ auto* ptr = reinterpret_cast<uint8_t*>(&result);\r
+ for (size_t i = 0; i < sizeof(T); ++i)\r
+ {\r
+ *ptr++ = vec[current_index + sizeof(T) - i];\r
+ }\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief create a MessagePack serialization of a given JSON value\r
+\r
+ This is a straightforward implementation of the MessagePack specification.\r
+\r
+ @param[in] j JSON value to serialize\r
+ @param[in,out] v byte vector to write the serialization to\r
+\r
+ @sa https://github.com/msgpack/msgpack/blob/master/spec.md\r
+ */\r
+ static void to_msgpack_internal(const basic_json& j, std::vector<uint8_t>& v)\r
+ {\r
+ switch (j.type())\r
+ {\r
+ case value_t::null:\r
+ {\r
+ // nil\r
+ v.push_back(0xc0);\r
+ break;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ // true and false\r
+ v.push_back(j.m_value.boolean ? 0xc3 : 0xc2);\r
+ break;\r
+ }\r
+\r
+ case value_t::number_integer:\r
+ {\r
+ if (j.m_value.number_integer >= 0)\r
+ {\r
+ // MessagePack does not differentiate between positive\r
+ // signed integers and unsigned integers. Therefore, we\r
+ // used the code from the value_t::number_unsigned case\r
+ // here.\r
+ if (j.m_value.number_unsigned < 128)\r
+ {\r
+ // positive fixnum\r
+ add_to_vector(v, 1, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint8_t>::max())\r
+ {\r
+ // uint 8\r
+ v.push_back(0xcc);\r
+ add_to_vector(v, 1, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint16_t>::max())\r
+ {\r
+ // uint 16\r
+ v.push_back(0xcd);\r
+ add_to_vector(v, 2, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint32_t>::max())\r
+ {\r
+ // uint 32\r
+ v.push_back(0xce);\r
+ add_to_vector(v, 4, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint64_t>::max())\r
+ {\r
+ // uint 64\r
+ v.push_back(0xcf);\r
+ add_to_vector(v, 8, j.m_value.number_unsigned);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (j.m_value.number_integer >= -32)\r
+ {\r
+ // negative fixnum\r
+ add_to_vector(v, 1, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer >= std::numeric_limits<int8_t>::min() and j.m_value.number_integer <= std::numeric_limits<int8_t>::max())\r
+ {\r
+ // int 8\r
+ v.push_back(0xd0);\r
+ add_to_vector(v, 1, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer >= std::numeric_limits<int16_t>::min() and j.m_value.number_integer <= std::numeric_limits<int16_t>::max())\r
+ {\r
+ // int 16\r
+ v.push_back(0xd1);\r
+ add_to_vector(v, 2, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer >= std::numeric_limits<int32_t>::min() and j.m_value.number_integer <= std::numeric_limits<int32_t>::max())\r
+ {\r
+ // int 32\r
+ v.push_back(0xd2);\r
+ add_to_vector(v, 4, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer >= std::numeric_limits<int64_t>::min() and j.m_value.number_integer <= std::numeric_limits<int64_t>::max())\r
+ {\r
+ // int 64\r
+ v.push_back(0xd3);\r
+ add_to_vector(v, 8, j.m_value.number_integer);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ if (j.m_value.number_unsigned < 128)\r
+ {\r
+ // positive fixnum\r
+ add_to_vector(v, 1, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint8_t>::max())\r
+ {\r
+ // uint 8\r
+ v.push_back(0xcc);\r
+ add_to_vector(v, 1, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint16_t>::max())\r
+ {\r
+ // uint 16\r
+ v.push_back(0xcd);\r
+ add_to_vector(v, 2, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint32_t>::max())\r
+ {\r
+ // uint 32\r
+ v.push_back(0xce);\r
+ add_to_vector(v, 4, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= std::numeric_limits<uint64_t>::max())\r
+ {\r
+ // uint 64\r
+ v.push_back(0xcf);\r
+ add_to_vector(v, 8, j.m_value.number_unsigned);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ // float 64\r
+ v.push_back(0xcb);\r
+ const auto* helper = reinterpret_cast<const uint8_t*>(&(j.m_value.number_float));\r
+ for (size_t i = 0; i < 8; ++i)\r
+ {\r
+ v.push_back(helper[7 - i]);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ const auto N = j.m_value.string->size();\r
+ if (N <= 31)\r
+ {\r
+ // fixstr\r
+ v.push_back(static_cast<uint8_t>(0xa0 | N));\r
+ }\r
+ else if (N <= 255)\r
+ {\r
+ // str 8\r
+ v.push_back(0xd9);\r
+ add_to_vector(v, 1, N);\r
+ }\r
+ else if (N <= 65535)\r
+ {\r
+ // str 16\r
+ v.push_back(0xda);\r
+ add_to_vector(v, 2, N);\r
+ }\r
+ else if (N <= 4294967295)\r
+ {\r
+ // str 32\r
+ v.push_back(0xdb);\r
+ add_to_vector(v, 4, N);\r
+ }\r
+\r
+ // append string\r
+ std::copy(j.m_value.string->begin(), j.m_value.string->end(),\r
+ std::back_inserter(v));\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ const auto N = j.m_value.array->size();\r
+ if (N <= 15)\r
+ {\r
+ // fixarray\r
+ v.push_back(static_cast<uint8_t>(0x90 | N));\r
+ }\r
+ else if (N <= 0xffff)\r
+ {\r
+ // array 16\r
+ v.push_back(0xdc);\r
+ add_to_vector(v, 2, N);\r
+ }\r
+ else if (N <= 0xffffffff)\r
+ {\r
+ // array 32\r
+ v.push_back(0xdd);\r
+ add_to_vector(v, 4, N);\r
+ }\r
+\r
+ // append each element\r
+ for (const auto& el : *j.m_value.array)\r
+ {\r
+ to_msgpack_internal(el, v);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ const auto N = j.m_value.object->size();\r
+ if (N <= 15)\r
+ {\r
+ // fixmap\r
+ v.push_back(static_cast<uint8_t>(0x80 | (N & 0xf)));\r
+ }\r
+ else if (N <= 65535)\r
+ {\r
+ // map 16\r
+ v.push_back(0xde);\r
+ add_to_vector(v, 2, N);\r
+ }\r
+ else if (N <= 4294967295)\r
+ {\r
+ // map 32\r
+ v.push_back(0xdf);\r
+ add_to_vector(v, 4, N);\r
+ }\r
+\r
+ // append each element\r
+ for (const auto& el : *j.m_value.object)\r
+ {\r
+ to_msgpack_internal(el.first, v);\r
+ to_msgpack_internal(el.second, v);\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief create a CBOR serialization of a given JSON value\r
+\r
+ This is a straightforward implementation of the CBOR specification.\r
+\r
+ @param[in] j JSON value to serialize\r
+ @param[in,out] v byte vector to write the serialization to\r
+\r
+ @sa https://tools.ietf.org/html/rfc7049\r
+ */\r
+ static void to_cbor_internal(const basic_json& j, std::vector<uint8_t>& v)\r
+ {\r
+ switch (j.type())\r
+ {\r
+ case value_t::null:\r
+ {\r
+ v.push_back(0xf6);\r
+ break;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ v.push_back(j.m_value.boolean ? 0xf5 : 0xf4);\r
+ break;\r
+ }\r
+\r
+ case value_t::number_integer:\r
+ {\r
+ if (j.m_value.number_integer >= 0)\r
+ {\r
+ // CBOR does not differentiate between positive signed\r
+ // integers and unsigned integers. Therefore, we used the\r
+ // code from the value_t::number_unsigned case here.\r
+ if (j.m_value.number_integer <= 0x17)\r
+ {\r
+ add_to_vector(v, 1, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer <= std::numeric_limits<uint8_t>::max())\r
+ {\r
+ v.push_back(0x18);\r
+ // one-byte uint8_t\r
+ add_to_vector(v, 1, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer <= std::numeric_limits<uint16_t>::max())\r
+ {\r
+ v.push_back(0x19);\r
+ // two-byte uint16_t\r
+ add_to_vector(v, 2, j.m_value.number_integer);\r
+ }\r
+ else if (j.m_value.number_integer <= std::numeric_limits<uint32_t>::max())\r
+ {\r
+ v.push_back(0x1a);\r
+ // four-byte uint32_t\r
+ add_to_vector(v, 4, j.m_value.number_integer);\r
+ }\r
+ else\r
+ {\r
+ v.push_back(0x1b);\r
+ // eight-byte uint64_t\r
+ add_to_vector(v, 8, j.m_value.number_integer);\r
+ }\r
+ }\r
+ else\r
+ {\r
+ // The conversions below encode the sign in the first\r
+ // byte, and the value is converted to a positive number.\r
+ const auto positive_number = -1 - j.m_value.number_integer;\r
+ if (j.m_value.number_integer >= -24)\r
+ {\r
+ v.push_back(static_cast<uint8_t>(0x20 + positive_number));\r
+ }\r
+ else if (positive_number <= std::numeric_limits<uint8_t>::max())\r
+ {\r
+ // int 8\r
+ v.push_back(0x38);\r
+ add_to_vector(v, 1, positive_number);\r
+ }\r
+ else if (positive_number <= std::numeric_limits<uint16_t>::max())\r
+ {\r
+ // int 16\r
+ v.push_back(0x39);\r
+ add_to_vector(v, 2, positive_number);\r
+ }\r
+ else if (positive_number <= std::numeric_limits<uint32_t>::max())\r
+ {\r
+ // int 32\r
+ v.push_back(0x3a);\r
+ add_to_vector(v, 4, positive_number);\r
+ }\r
+ else\r
+ {\r
+ // int 64\r
+ v.push_back(0x3b);\r
+ add_to_vector(v, 8, positive_number);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ if (j.m_value.number_unsigned <= 0x17)\r
+ {\r
+ v.push_back(static_cast<uint8_t>(j.m_value.number_unsigned));\r
+ }\r
+ else if (j.m_value.number_unsigned <= 0xff)\r
+ {\r
+ v.push_back(0x18);\r
+ // one-byte uint8_t\r
+ add_to_vector(v, 1, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= 0xffff)\r
+ {\r
+ v.push_back(0x19);\r
+ // two-byte uint16_t\r
+ add_to_vector(v, 2, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= 0xffffffff)\r
+ {\r
+ v.push_back(0x1a);\r
+ // four-byte uint32_t\r
+ add_to_vector(v, 4, j.m_value.number_unsigned);\r
+ }\r
+ else if (j.m_value.number_unsigned <= 0xffffffffffffffff)\r
+ {\r
+ v.push_back(0x1b);\r
+ // eight-byte uint64_t\r
+ add_to_vector(v, 8, j.m_value.number_unsigned);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ // Double-Precision Float\r
+ v.push_back(0xfb);\r
+ const auto* helper = reinterpret_cast<const uint8_t*>(&(j.m_value.number_float));\r
+ for (size_t i = 0; i < 8; ++i)\r
+ {\r
+ v.push_back(helper[7 - i]);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ const auto N = j.m_value.string->size();\r
+ if (N <= 0x17)\r
+ {\r
+ v.push_back(0x60 + static_cast<uint8_t>(N)); // 1 byte for string + size\r
+ }\r
+ else if (N <= 0xff)\r
+ {\r
+ v.push_back(0x78); // one-byte uint8_t for N\r
+ add_to_vector(v, 1, N);\r
+ }\r
+ else if (N <= 0xffff)\r
+ {\r
+ v.push_back(0x79); // two-byte uint16_t for N\r
+ add_to_vector(v, 2, N);\r
+ }\r
+ else if (N <= 0xffffffff)\r
+ {\r
+ v.push_back(0x7a); // four-byte uint32_t for N\r
+ add_to_vector(v, 4, N);\r
+ }\r
+ // LCOV_EXCL_START\r
+ else if (N <= 0xffffffffffffffff)\r
+ {\r
+ v.push_back(0x7b); // eight-byte uint64_t for N\r
+ add_to_vector(v, 8, N);\r
+ }\r
+ // LCOV_EXCL_STOP\r
+\r
+ // append string\r
+ std::copy(j.m_value.string->begin(), j.m_value.string->end(),\r
+ std::back_inserter(v));\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ const auto N = j.m_value.array->size();\r
+ if (N <= 0x17)\r
+ {\r
+ v.push_back(0x80 + static_cast<uint8_t>(N)); // 1 byte for array + size\r
+ }\r
+ else if (N <= 0xff)\r
+ {\r
+ v.push_back(0x98); // one-byte uint8_t for N\r
+ add_to_vector(v, 1, N);\r
+ }\r
+ else if (N <= 0xffff)\r
+ {\r
+ v.push_back(0x99); // two-byte uint16_t for N\r
+ add_to_vector(v, 2, N);\r
+ }\r
+ else if (N <= 0xffffffff)\r
+ {\r
+ v.push_back(0x9a); // four-byte uint32_t for N\r
+ add_to_vector(v, 4, N);\r
+ }\r
+ // LCOV_EXCL_START\r
+ else if (N <= 0xffffffffffffffff)\r
+ {\r
+ v.push_back(0x9b); // eight-byte uint64_t for N\r
+ add_to_vector(v, 8, N);\r
+ }\r
+ // LCOV_EXCL_STOP\r
+\r
+ // append each element\r
+ for (const auto& el : *j.m_value.array)\r
+ {\r
+ to_cbor_internal(el, v);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ const auto N = j.m_value.object->size();\r
+ if (N <= 0x17)\r
+ {\r
+ v.push_back(0xa0 + static_cast<uint8_t>(N)); // 1 byte for object + size\r
+ }\r
+ else if (N <= 0xff)\r
+ {\r
+ v.push_back(0xb8);\r
+ add_to_vector(v, 1, N); // one-byte uint8_t for N\r
+ }\r
+ else if (N <= 0xffff)\r
+ {\r
+ v.push_back(0xb9);\r
+ add_to_vector(v, 2, N); // two-byte uint16_t for N\r
+ }\r
+ else if (N <= 0xffffffff)\r
+ {\r
+ v.push_back(0xba);\r
+ add_to_vector(v, 4, N); // four-byte uint32_t for N\r
+ }\r
+ // LCOV_EXCL_START\r
+ else if (N <= 0xffffffffffffffff)\r
+ {\r
+ v.push_back(0xbb);\r
+ add_to_vector(v, 8, N); // eight-byte uint64_t for N\r
+ }\r
+ // LCOV_EXCL_STOP\r
+\r
+ // append each element\r
+ for (const auto& el : *j.m_value.object)\r
+ {\r
+ to_cbor_internal(el.first, v);\r
+ to_cbor_internal(el.second, v);\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ /*\r
+ @brief checks if given lengths do not exceed the size of a given vector\r
+\r
+ To secure the access to the byte vector during CBOR/MessagePack\r
+ deserialization, bytes are copied from the vector into buffers. This\r
+ function checks if the number of bytes to copy (@a len) does not exceed\r
+ the size @s size of the vector. Additionally, an @a offset is given from\r
+ where to start reading the bytes.\r
+\r
+ This function checks whether reading the bytes is safe; that is, offset is\r
+ a valid index in the vector, offset+len\r
+\r
+ @param[in] size size of the byte vector\r
+ @param[in] len number of bytes to read\r
+ @param[in] offset offset where to start reading\r
+\r
+ vec: x x x x x X X X X X\r
+ ^ ^ ^\r
+ 0 offset len\r
+\r
+ @throws out_of_range if `len > v.size()`\r
+ */\r
+ static void check_length(const size_t size, const size_t len, const size_t offset)\r
+ {\r
+ // simple case: requested length is greater than the vector's length\r
+ if (len > size or offset > size)\r
+ {\r
+ JSON_THROW(std::out_of_range("len out of range"));\r
+ }\r
+\r
+ // second case: adding offset would result in overflow\r
+ if ((size > (std::numeric_limits<size_t>::max() - offset)))\r
+ {\r
+ JSON_THROW(std::out_of_range("len+offset out of range"));\r
+ }\r
+\r
+ // last case: reading past the end of the vector\r
+ if (len + offset > size)\r
+ {\r
+ JSON_THROW(std::out_of_range("len+offset out of range"));\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief create a JSON value from a given MessagePack vector\r
+\r
+ @param[in] v MessagePack serialization\r
+ @param[in] idx byte index to start reading from @a v\r
+\r
+ @return deserialized JSON value\r
+\r
+ @throw std::invalid_argument if unsupported features from MessagePack were\r
+ used in the given vector @a v or if the input is not valid MessagePack\r
+ @throw std::out_of_range if the given vector ends prematurely\r
+\r
+ @sa https://github.com/msgpack/msgpack/blob/master/spec.md\r
+ */\r
+ static basic_json from_msgpack_internal(const std::vector<uint8_t>& v, size_t& idx)\r
+ {\r
+ // make sure reading 1 byte is safe\r
+ check_length(v.size(), 1, idx);\r
+\r
+ // store and increment index\r
+ const size_t current_idx = idx++;\r
+\r
+ if (v[current_idx] <= 0xbf)\r
+ {\r
+ if (v[current_idx] <= 0x7f) // positive fixint\r
+ {\r
+ return v[current_idx];\r
+ }\r
+ if (v[current_idx] <= 0x8f) // fixmap\r
+ {\r
+ basic_json result = value_t::object;\r
+ const size_t len = v[current_idx] & 0x0f;\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_msgpack_internal(v, idx);\r
+ result[key] = from_msgpack_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+ else if (v[current_idx] <= 0x9f) // fixarray\r
+ {\r
+ basic_json result = value_t::array;\r
+ const size_t len = v[current_idx] & 0x0f;\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_msgpack_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+ else // fixstr\r
+ {\r
+ const size_t len = v[current_idx] & 0x1f;\r
+ const size_t offset = current_idx + 1;\r
+ idx += len; // skip content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+ }\r
+ else if (v[current_idx] >= 0xe0) // negative fixint\r
+ {\r
+ return static_cast<int8_t>(v[current_idx]);\r
+ }\r
+ else\r
+ {\r
+ switch (v[current_idx])\r
+ {\r
+ case 0xc0: // nil\r
+ {\r
+ return value_t::null;\r
+ }\r
+\r
+ case 0xc2: // false\r
+ {\r
+ return false;\r
+ }\r
+\r
+ case 0xc3: // true\r
+ {\r
+ return true;\r
+ }\r
+\r
+ case 0xca: // float 32\r
+ {\r
+ // copy bytes in reverse order into the double variable\r
+ float res;\r
+ for (size_t byte = 0; byte < sizeof(float); ++byte)\r
+ {\r
+ reinterpret_cast<uint8_t*>(&res)[sizeof(float) - byte - 1] = v.at(current_idx + 1 + byte);\r
+ }\r
+ idx += sizeof(float); // skip content bytes\r
+ return res;\r
+ }\r
+\r
+ case 0xcb: // float 64\r
+ {\r
+ // copy bytes in reverse order into the double variable\r
+ double res;\r
+ for (size_t byte = 0; byte < sizeof(double); ++byte)\r
+ {\r
+ reinterpret_cast<uint8_t*>(&res)[sizeof(double) - byte - 1] = v.at(current_idx + 1 + byte);\r
+ }\r
+ idx += sizeof(double); // skip content bytes\r
+ return res;\r
+ }\r
+\r
+ case 0xcc: // uint 8\r
+ {\r
+ idx += 1; // skip content byte\r
+ return get_from_vector<uint8_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xcd: // uint 16\r
+ {\r
+ idx += 2; // skip 2 content bytes\r
+ return get_from_vector<uint16_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xce: // uint 32\r
+ {\r
+ idx += 4; // skip 4 content bytes\r
+ return get_from_vector<uint32_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xcf: // uint 64\r
+ {\r
+ idx += 8; // skip 8 content bytes\r
+ return get_from_vector<uint64_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xd0: // int 8\r
+ {\r
+ idx += 1; // skip content byte\r
+ return get_from_vector<int8_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xd1: // int 16\r
+ {\r
+ idx += 2; // skip 2 content bytes\r
+ return get_from_vector<int16_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xd2: // int 32\r
+ {\r
+ idx += 4; // skip 4 content bytes\r
+ return get_from_vector<int32_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xd3: // int 64\r
+ {\r
+ idx += 8; // skip 8 content bytes\r
+ return get_from_vector<int64_t>(v, current_idx);\r
+ }\r
+\r
+ case 0xd9: // str 8\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));\r
+ const size_t offset = current_idx + 2;\r
+ idx += len + 1; // skip size byte + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0xda: // str 16\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));\r
+ const size_t offset = current_idx + 3;\r
+ idx += len + 2; // skip 2 size bytes + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0xdb: // str 32\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));\r
+ const size_t offset = current_idx + 5;\r
+ idx += len + 4; // skip 4 size bytes + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0xdc: // array 16\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));\r
+ idx += 2; // skip 2 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_msgpack_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xdd: // array 32\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));\r
+ idx += 4; // skip 4 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_msgpack_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xde: // map 16\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));\r
+ idx += 2; // skip 2 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_msgpack_internal(v, idx);\r
+ result[key] = from_msgpack_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xdf: // map 32\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));\r
+ idx += 4; // skip 4 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_msgpack_internal(v, idx);\r
+ result[key] = from_msgpack_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::invalid_argument("error parsing a msgpack @ " + std::to_string(current_idx) + ": " + std::to_string(static_cast<int>(v[current_idx]))));\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief create a JSON value from a given CBOR vector\r
+\r
+ @param[in] v CBOR serialization\r
+ @param[in] idx byte index to start reading from @a v\r
+\r
+ @return deserialized JSON value\r
+\r
+ @throw std::invalid_argument if unsupported features from CBOR were used in\r
+ the given vector @a v or if the input is not valid CBOR\r
+ @throw std::out_of_range if the given vector ends prematurely\r
+\r
+ @sa https://tools.ietf.org/html/rfc7049\r
+ */\r
+ static basic_json from_cbor_internal(const std::vector<uint8_t>& v, size_t& idx)\r
+ {\r
+ // store and increment index\r
+ const size_t current_idx = idx++;\r
+\r
+ switch (v.at(current_idx))\r
+ {\r
+ // Integer 0x00..0x17 (0..23)\r
+ case 0x00:\r
+ case 0x01:\r
+ case 0x02:\r
+ case 0x03:\r
+ case 0x04:\r
+ case 0x05:\r
+ case 0x06:\r
+ case 0x07:\r
+ case 0x08:\r
+ case 0x09:\r
+ case 0x0a:\r
+ case 0x0b:\r
+ case 0x0c:\r
+ case 0x0d:\r
+ case 0x0e:\r
+ case 0x0f:\r
+ case 0x10:\r
+ case 0x11:\r
+ case 0x12:\r
+ case 0x13:\r
+ case 0x14:\r
+ case 0x15:\r
+ case 0x16:\r
+ case 0x17:\r
+ {\r
+ return v[current_idx];\r
+ }\r
+\r
+ case 0x18: // Unsigned integer (one-byte uint8_t follows)\r
+ {\r
+ idx += 1; // skip content byte\r
+ return get_from_vector<uint8_t>(v, current_idx);\r
+ }\r
+\r
+ case 0x19: // Unsigned integer (two-byte uint16_t follows)\r
+ {\r
+ idx += 2; // skip 2 content bytes\r
+ return get_from_vector<uint16_t>(v, current_idx);\r
+ }\r
+\r
+ case 0x1a: // Unsigned integer (four-byte uint32_t follows)\r
+ {\r
+ idx += 4; // skip 4 content bytes\r
+ return get_from_vector<uint32_t>(v, current_idx);\r
+ }\r
+\r
+ case 0x1b: // Unsigned integer (eight-byte uint64_t follows)\r
+ {\r
+ idx += 8; // skip 8 content bytes\r
+ return get_from_vector<uint64_t>(v, current_idx);\r
+ }\r
+\r
+ // Negative integer -1-0x00..-1-0x17 (-1..-24)\r
+ case 0x20:\r
+ case 0x21:\r
+ case 0x22:\r
+ case 0x23:\r
+ case 0x24:\r
+ case 0x25:\r
+ case 0x26:\r
+ case 0x27:\r
+ case 0x28:\r
+ case 0x29:\r
+ case 0x2a:\r
+ case 0x2b:\r
+ case 0x2c:\r
+ case 0x2d:\r
+ case 0x2e:\r
+ case 0x2f:\r
+ case 0x30:\r
+ case 0x31:\r
+ case 0x32:\r
+ case 0x33:\r
+ case 0x34:\r
+ case 0x35:\r
+ case 0x36:\r
+ case 0x37:\r
+ {\r
+ return static_cast<int8_t>(0x20 - 1 - v[current_idx]);\r
+ }\r
+\r
+ case 0x38: // Negative integer (one-byte uint8_t follows)\r
+ {\r
+ idx += 1; // skip content byte\r
+ // must be uint8_t !\r
+ return static_cast<number_integer_t>(-1) - get_from_vector<uint8_t>(v, current_idx);\r
+ }\r
+\r
+ case 0x39: // Negative integer -1-n (two-byte uint16_t follows)\r
+ {\r
+ idx += 2; // skip 2 content bytes\r
+ return static_cast<number_integer_t>(-1) - get_from_vector<uint16_t>(v, current_idx);\r
+ }\r
+\r
+ case 0x3a: // Negative integer -1-n (four-byte uint32_t follows)\r
+ {\r
+ idx += 4; // skip 4 content bytes\r
+ return static_cast<number_integer_t>(-1) - get_from_vector<uint32_t>(v, current_idx);\r
+ }\r
+\r
+ case 0x3b: // Negative integer -1-n (eight-byte uint64_t follows)\r
+ {\r
+ idx += 8; // skip 8 content bytes\r
+ return static_cast<number_integer_t>(-1) - static_cast<number_integer_t>(get_from_vector<uint64_t>(v, current_idx));\r
+ }\r
+\r
+ // UTF-8 string (0x00..0x17 bytes follow)\r
+ case 0x60:\r
+ case 0x61:\r
+ case 0x62:\r
+ case 0x63:\r
+ case 0x64:\r
+ case 0x65:\r
+ case 0x66:\r
+ case 0x67:\r
+ case 0x68:\r
+ case 0x69:\r
+ case 0x6a:\r
+ case 0x6b:\r
+ case 0x6c:\r
+ case 0x6d:\r
+ case 0x6e:\r
+ case 0x6f:\r
+ case 0x70:\r
+ case 0x71:\r
+ case 0x72:\r
+ case 0x73:\r
+ case 0x74:\r
+ case 0x75:\r
+ case 0x76:\r
+ case 0x77:\r
+ {\r
+ const auto len = static_cast<size_t>(v[current_idx] - 0x60);\r
+ const size_t offset = current_idx + 1;\r
+ idx += len; // skip content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0x78: // UTF-8 string (one-byte uint8_t for n follows)\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));\r
+ const size_t offset = current_idx + 2;\r
+ idx += len + 1; // skip size byte + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0x79: // UTF-8 string (two-byte uint16_t for n follow)\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));\r
+ const size_t offset = current_idx + 3;\r
+ idx += len + 2; // skip 2 size bytes + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0x7a: // UTF-8 string (four-byte uint32_t for n follow)\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));\r
+ const size_t offset = current_idx + 5;\r
+ idx += len + 4; // skip 4 size bytes + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0x7b: // UTF-8 string (eight-byte uint64_t for n follow)\r
+ {\r
+ const auto len = static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));\r
+ const size_t offset = current_idx + 9;\r
+ idx += len + 8; // skip 8 size bytes + content bytes\r
+ check_length(v.size(), len, offset);\r
+ return std::string(reinterpret_cast<const char*>(v.data()) + offset, len);\r
+ }\r
+\r
+ case 0x7f: // UTF-8 string (indefinite length)\r
+ {\r
+ std::string result;\r
+ while (v.at(idx) != 0xff)\r
+ {\r
+ string_t s = from_cbor_internal(v, idx);\r
+ result += s;\r
+ }\r
+ // skip break byte (0xFF)\r
+ idx += 1;\r
+ return result;\r
+ }\r
+\r
+ // array (0x00..0x17 data items follow)\r
+ case 0x80:\r
+ case 0x81:\r
+ case 0x82:\r
+ case 0x83:\r
+ case 0x84:\r
+ case 0x85:\r
+ case 0x86:\r
+ case 0x87:\r
+ case 0x88:\r
+ case 0x89:\r
+ case 0x8a:\r
+ case 0x8b:\r
+ case 0x8c:\r
+ case 0x8d:\r
+ case 0x8e:\r
+ case 0x8f:\r
+ case 0x90:\r
+ case 0x91:\r
+ case 0x92:\r
+ case 0x93:\r
+ case 0x94:\r
+ case 0x95:\r
+ case 0x96:\r
+ case 0x97:\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(v[current_idx] - 0x80);\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_cbor_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0x98: // array (one-byte uint8_t for n follows)\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));\r
+ idx += 1; // skip 1 size byte\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_cbor_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0x99: // array (two-byte uint16_t for n follow)\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));\r
+ idx += 2; // skip 4 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_cbor_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0x9a: // array (four-byte uint32_t for n follow)\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));\r
+ idx += 4; // skip 4 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_cbor_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0x9b: // array (eight-byte uint64_t for n follow)\r
+ {\r
+ basic_json result = value_t::array;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));\r
+ idx += 8; // skip 8 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ result.push_back(from_cbor_internal(v, idx));\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0x9f: // array (indefinite length)\r
+ {\r
+ basic_json result = value_t::array;\r
+ while (v.at(idx) != 0xff)\r
+ {\r
+ result.push_back(from_cbor_internal(v, idx));\r
+ }\r
+ // skip break byte (0xFF)\r
+ idx += 1;\r
+ return result;\r
+ }\r
+\r
+ // map (0x00..0x17 pairs of data items follow)\r
+ case 0xa0:\r
+ case 0xa1:\r
+ case 0xa2:\r
+ case 0xa3:\r
+ case 0xa4:\r
+ case 0xa5:\r
+ case 0xa6:\r
+ case 0xa7:\r
+ case 0xa8:\r
+ case 0xa9:\r
+ case 0xaa:\r
+ case 0xab:\r
+ case 0xac:\r
+ case 0xad:\r
+ case 0xae:\r
+ case 0xaf:\r
+ case 0xb0:\r
+ case 0xb1:\r
+ case 0xb2:\r
+ case 0xb3:\r
+ case 0xb4:\r
+ case 0xb5:\r
+ case 0xb6:\r
+ case 0xb7:\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(v[current_idx] - 0xa0);\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_cbor_internal(v, idx);\r
+ result[key] = from_cbor_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xb8: // map (one-byte uint8_t for n follows)\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint8_t>(v, current_idx));\r
+ idx += 1; // skip 1 size byte\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_cbor_internal(v, idx);\r
+ result[key] = from_cbor_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xb9: // map (two-byte uint16_t for n follow)\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint16_t>(v, current_idx));\r
+ idx += 2; // skip 2 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_cbor_internal(v, idx);\r
+ result[key] = from_cbor_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xba: // map (four-byte uint32_t for n follow)\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint32_t>(v, current_idx));\r
+ idx += 4; // skip 4 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_cbor_internal(v, idx);\r
+ result[key] = from_cbor_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xbb: // map (eight-byte uint64_t for n follow)\r
+ {\r
+ basic_json result = value_t::object;\r
+ const auto len = static_cast<size_t>(get_from_vector<uint64_t>(v, current_idx));\r
+ idx += 8; // skip 8 size bytes\r
+ for (size_t i = 0; i < len; ++i)\r
+ {\r
+ std::string key = from_cbor_internal(v, idx);\r
+ result[key] = from_cbor_internal(v, idx);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ case 0xbf: // map (indefinite length)\r
+ {\r
+ basic_json result = value_t::object;\r
+ while (v.at(idx) != 0xff)\r
+ {\r
+ std::string key = from_cbor_internal(v, idx);\r
+ result[key] = from_cbor_internal(v, idx);\r
+ }\r
+ // skip break byte (0xFF)\r
+ idx += 1;\r
+ return result;\r
+ }\r
+\r
+ case 0xf4: // false\r
+ {\r
+ return false;\r
+ }\r
+\r
+ case 0xf5: // true\r
+ {\r
+ return true;\r
+ }\r
+\r
+ case 0xf6: // null\r
+ {\r
+ return value_t::null;\r
+ }\r
+\r
+ case 0xf9: // Half-Precision Float (two-byte IEEE 754)\r
+ {\r
+ idx += 2; // skip two content bytes\r
+\r
+ // code from RFC 7049, Appendix D, Figure 3:\r
+ // As half-precision floating-point numbers were only added to\r
+ // IEEE 754 in 2008, today's programming platforms often still\r
+ // only have limited support for them. It is very easy to\r
+ // include at least decoding support for them even without such\r
+ // support. An example of a small decoder for half-precision\r
+ // floating-point numbers in the C language is shown in Fig. 3.\r
+ const int half = (v.at(current_idx + 1) << 8) + v.at(current_idx + 2);\r
+ const int exp = (half >> 10) & 0x1f;\r
+ const int mant = half & 0x3ff;\r
+ double val;\r
+ if (exp == 0)\r
+ {\r
+ val = std::ldexp(mant, -24);\r
+ }\r
+ else if (exp != 31)\r
+ {\r
+ val = std::ldexp(mant + 1024, exp - 25);\r
+ }\r
+ else\r
+ {\r
+ val = mant == 0\r
+ ? std::numeric_limits<double>::infinity()\r
+ : std::numeric_limits<double>::quiet_NaN();\r
+ }\r
+ return (half & 0x8000) != 0 ? -val : val;\r
+ }\r
+\r
+ case 0xfa: // Single-Precision Float (four-byte IEEE 754)\r
+ {\r
+ // copy bytes in reverse order into the float variable\r
+ float res;\r
+ for (size_t byte = 0; byte < sizeof(float); ++byte)\r
+ {\r
+ reinterpret_cast<uint8_t*>(&res)[sizeof(float) - byte - 1] = v.at(current_idx + 1 + byte);\r
+ }\r
+ idx += sizeof(float); // skip content bytes\r
+ return res;\r
+ }\r
+\r
+ case 0xfb: // Double-Precision Float (eight-byte IEEE 754)\r
+ {\r
+ // copy bytes in reverse order into the double variable\r
+ double res;\r
+ for (size_t byte = 0; byte < sizeof(double); ++byte)\r
+ {\r
+ reinterpret_cast<uint8_t*>(&res)[sizeof(double) - byte - 1] = v.at(current_idx + 1 + byte);\r
+ }\r
+ idx += sizeof(double); // skip content bytes\r
+ return res;\r
+ }\r
+\r
+ default: // anything else (0xFF is handled inside the other types)\r
+ {\r
+ JSON_THROW(std::invalid_argument("error parsing a CBOR @ " + std::to_string(current_idx) + ": " + std::to_string(static_cast<int>(v[current_idx]))));\r
+ }\r
+ }\r
+ }\r
+\r
+ public:\r
+ /*!\r
+ @brief create a MessagePack serialization of a given JSON value\r
+\r
+ Serializes a given JSON value @a j to a byte vector using the MessagePack\r
+ serialization format. MessagePack is a binary serialization format which\r
+ aims to be more compact than JSON itself, yet more efficient to parse.\r
+\r
+ @param[in] j JSON value to serialize\r
+ @return MessagePack serialization as byte vector\r
+\r
+ @complexity Linear in the size of the JSON value @a j.\r
+\r
+ @liveexample{The example shows the serialization of a JSON value to a byte\r
+ vector in MessagePack format.,to_msgpack}\r
+\r
+ @sa http://msgpack.org\r
+ @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the\r
+ analogous deserialization\r
+ @sa @ref to_cbor(const basic_json& for the related CBOR format\r
+\r
+ @since version 2.0.9\r
+ */\r
+ static std::vector<uint8_t> to_msgpack(const basic_json& j)\r
+ {\r
+ std::vector<uint8_t> result;\r
+ to_msgpack_internal(j, result);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief create a JSON value from a byte vector in MessagePack format\r
+\r
+ Deserializes a given byte vector @a v to a JSON value using the MessagePack\r
+ serialization format.\r
+\r
+ @param[in] v a byte vector in MessagePack format\r
+ @param[in] start_index the index to start reading from @a v (0 by default)\r
+ @return deserialized JSON value\r
+\r
+ @throw std::invalid_argument if unsupported features from MessagePack were\r
+ used in the given vector @a v or if the input is not valid MessagePack\r
+ @throw std::out_of_range if the given vector ends prematurely\r
+\r
+ @complexity Linear in the size of the byte vector @a v.\r
+\r
+ @liveexample{The example shows the deserialization of a byte vector in\r
+ MessagePack format to a JSON value.,from_msgpack}\r
+\r
+ @sa http://msgpack.org\r
+ @sa @ref to_msgpack(const basic_json&) for the analogous serialization\r
+ @sa @ref from_cbor(const std::vector<uint8_t>&, const size_t) for the\r
+ related CBOR format\r
+\r
+ @since version 2.0.9, parameter @a start_index since 2.1.1\r
+ */\r
+ static basic_json from_msgpack(const std::vector<uint8_t>& v,\r
+ const size_t start_index = 0)\r
+ {\r
+ size_t i = start_index;\r
+ return from_msgpack_internal(v, i);\r
+ }\r
+\r
+ /*!\r
+ @brief create a MessagePack serialization of a given JSON value\r
+\r
+ Serializes a given JSON value @a j to a byte vector using the CBOR (Concise\r
+ Binary Object Representation) serialization format. CBOR is a binary\r
+ serialization format which aims to be more compact than JSON itself, yet\r
+ more efficient to parse.\r
+\r
+ @param[in] j JSON value to serialize\r
+ @return MessagePack serialization as byte vector\r
+\r
+ @complexity Linear in the size of the JSON value @a j.\r
+\r
+ @liveexample{The example shows the serialization of a JSON value to a byte\r
+ vector in CBOR format.,to_cbor}\r
+\r
+ @sa http://cbor.io\r
+ @sa @ref from_cbor(const std::vector<uint8_t>&, const size_t) for the\r
+ analogous deserialization\r
+ @sa @ref to_msgpack(const basic_json& for the related MessagePack format\r
+\r
+ @since version 2.0.9\r
+ */\r
+ static std::vector<uint8_t> to_cbor(const basic_json& j)\r
+ {\r
+ std::vector<uint8_t> result;\r
+ to_cbor_internal(j, result);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief create a JSON value from a byte vector in CBOR format\r
+\r
+ Deserializes a given byte vector @a v to a JSON value using the CBOR\r
+ (Concise Binary Object Representation) serialization format.\r
+\r
+ @param[in] v a byte vector in CBOR format\r
+ @param[in] start_index the index to start reading from @a v (0 by default)\r
+ @return deserialized JSON value\r
+\r
+ @throw std::invalid_argument if unsupported features from CBOR were used in\r
+ the given vector @a v or if the input is not valid MessagePack\r
+ @throw std::out_of_range if the given vector ends prematurely\r
+\r
+ @complexity Linear in the size of the byte vector @a v.\r
+\r
+ @liveexample{The example shows the deserialization of a byte vector in CBOR\r
+ format to a JSON value.,from_cbor}\r
+\r
+ @sa http://cbor.io\r
+ @sa @ref to_cbor(const basic_json&) for the analogous serialization\r
+ @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the\r
+ related MessagePack format\r
+\r
+ @since version 2.0.9, parameter @a start_index since 2.1.1\r
+ */\r
+ static basic_json from_cbor(const std::vector<uint8_t>& v,\r
+ const size_t start_index = 0)\r
+ {\r
+ size_t i = start_index;\r
+ return from_cbor_internal(v, i);\r
+ }\r
+\r
+ /// @}\r
+\r
+ ///////////////////////////\r
+ // convenience functions //\r
+ ///////////////////////////\r
+\r
+ /*!\r
+ @brief return the type as string\r
+\r
+ Returns the type name as string to be used in error messages - usually to\r
+ indicate that a function was called on a wrong JSON type.\r
+\r
+ @return basically a string representation of a the @a m_type member\r
+\r
+ @complexity Constant.\r
+\r
+ @liveexample{The following code exemplifies `type_name()` for all JSON\r
+ types.,type_name}\r
+\r
+ @since version 1.0.0, public since 2.1.0\r
+ */\r
+ std::string type_name() const\r
+ {\r
+ {\r
+ switch (m_type)\r
+ {\r
+ case value_t::null:\r
+ return "null";\r
+ case value_t::object:\r
+ return "object";\r
+ case value_t::array:\r
+ return "array";\r
+ case value_t::string:\r
+ return "string";\r
+ case value_t::boolean:\r
+ return "boolean";\r
+ case value_t::discarded:\r
+ return "discarded";\r
+ default:\r
+ return "number";\r
+ }\r
+ }\r
+ }\r
+\r
+ private:\r
+ /*!\r
+ @brief calculates the extra space to escape a JSON string\r
+\r
+ @param[in] s the string to escape\r
+ @return the number of characters required to escape string @a s\r
+\r
+ @complexity Linear in the length of string @a s.\r
+ */\r
+ static std::size_t extra_space(const string_t& s) noexcept\r
+ {\r
+ return std::accumulate(s.begin(), s.end(), size_t{},\r
+ [](size_t res, typename string_t::value_type c)\r
+ {\r
+ switch (c)\r
+ {\r
+ case '"':\r
+ case '\\':\r
+ case '\b':\r
+ case '\f':\r
+ case '\n':\r
+ case '\r':\r
+ case '\t':\r
+ {\r
+ // from c (1 byte) to \x (2 bytes)\r
+ return res + 1;\r
+ }\r
+\r
+ default:\r
+ {\r
+ if (c >= 0x00 and c <= 0x1f)\r
+ {\r
+ // from c (1 byte) to \uxxxx (6 bytes)\r
+ return res + 5;\r
+ }\r
+\r
+ return res;\r
+ }\r
+ }\r
+ });\r
+ }\r
+\r
+ /*!\r
+ @brief escape a string\r
+\r
+ Escape a string by replacing certain special characters by a sequence of\r
+ an escape character (backslash) and another character and other control\r
+ characters by a sequence of "\u" followed by a four-digit hex\r
+ representation.\r
+\r
+ @param[in] s the string to escape\r
+ @return the escaped string\r
+\r
+ @complexity Linear in the length of string @a s.\r
+ */\r
+ static string_t escape_string(const string_t& s)\r
+ {\r
+ const auto space = extra_space(s);\r
+ if (space == 0)\r
+ {\r
+ return s;\r
+ }\r
+\r
+ // create a result string of necessary size\r
+ string_t result(s.size() + space, '\\');\r
+ std::size_t pos = 0;\r
+\r
+ for (const auto& c : s)\r
+ {\r
+ switch (c)\r
+ {\r
+ // quotation mark (0x22)\r
+ case '"':\r
+ {\r
+ result[pos + 1] = '"';\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ // reverse solidus (0x5c)\r
+ case '\\':\r
+ {\r
+ // nothing to change\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ // backspace (0x08)\r
+ case '\b':\r
+ {\r
+ result[pos + 1] = 'b';\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ // formfeed (0x0c)\r
+ case '\f':\r
+ {\r
+ result[pos + 1] = 'f';\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ // newline (0x0a)\r
+ case '\n':\r
+ {\r
+ result[pos + 1] = 'n';\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ // carriage return (0x0d)\r
+ case '\r':\r
+ {\r
+ result[pos + 1] = 'r';\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ // horizontal tab (0x09)\r
+ case '\t':\r
+ {\r
+ result[pos + 1] = 't';\r
+ pos += 2;\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ if (c >= 0x00 and c <= 0x1f)\r
+ {\r
+ // convert a number 0..15 to its hex representation\r
+ // (0..f)\r
+ static const char hexify[16] =\r
+ {\r
+ '0', '1', '2', '3', '4', '5', '6', '7',\r
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'\r
+ };\r
+\r
+ // print character c as \uxxxx\r
+ for (const char m :\r
+ { 'u', '0', '0', hexify[c >> 4], hexify[c & 0x0f]\r
+ })\r
+ {\r
+ result[++pos] = m;\r
+ }\r
+\r
+ ++pos;\r
+ }\r
+ else\r
+ {\r
+ // all other characters are added as-is\r
+ result[pos++] = c;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+\r
+ /*!\r
+ @brief locale-independent serialization for built-in arithmetic types\r
+ */\r
+ struct numtostr\r
+ {\r
+ public:\r
+ template<typename NumberType>\r
+ numtostr(NumberType value)\r
+ {\r
+ x_write(value, std::is_integral<NumberType>());\r
+ }\r
+\r
+ const char* c_str() const\r
+ {\r
+ return m_buf.data();\r
+ }\r
+\r
+ private:\r
+ /// a (hopefully) large enough character buffer\r
+ std::array < char, 64 > m_buf{{}};\r
+\r
+ template<typename NumberType>\r
+ void x_write(NumberType x, /*is_integral=*/std::true_type)\r
+ {\r
+ // special case for "0"\r
+ if (x == 0)\r
+ {\r
+ m_buf[0] = '0';\r
+ return;\r
+ }\r
+\r
+ const bool is_negative = x < 0;\r
+ size_t i = 0;\r
+\r
+ // spare 1 byte for '\0'\r
+ while (x != 0 and i < m_buf.size() - 1)\r
+ {\r
+ const auto digit = std::labs(static_cast<long>(x % 10));\r
+ m_buf[i++] = static_cast<char>('0' + digit);\r
+ x /= 10;\r
+ }\r
+\r
+ // make sure the number has been processed completely\r
+ assert(x == 0);\r
+\r
+ if (is_negative)\r
+ {\r
+ // make sure there is capacity for the '-'\r
+ assert(i < m_buf.size() - 2);\r
+ m_buf[i++] = '-';\r
+ }\r
+\r
+ std::reverse(m_buf.begin(), m_buf.begin() + i);\r
+ }\r
+\r
+ template<typename NumberType>\r
+ void x_write(NumberType x, /*is_integral=*/std::false_type)\r
+ {\r
+ // special case for 0.0 and -0.0\r
+ if (x == 0)\r
+ {\r
+ size_t i = 0;\r
+ if (std::signbit(x))\r
+ {\r
+ m_buf[i++] = '-';\r
+ }\r
+ m_buf[i++] = '0';\r
+ m_buf[i++] = '.';\r
+ m_buf[i] = '0';\r
+ return;\r
+ }\r
+\r
+ // get number of digits for a text -> float -> text round-trip\r
+ static constexpr auto d = std::numeric_limits<NumberType>::digits10;\r
+\r
+ // the actual conversion\r
+ const auto written_bytes = snprintf(m_buf.data(), m_buf.size(), "%.*g", d, (double)x);\r
+\r
+ // negative value indicates an error\r
+ assert(written_bytes > 0);\r
+ // check if buffer was large enough\r
+ assert(static_cast<size_t>(written_bytes) < m_buf.size());\r
+\r
+ // read information from locale\r
+ const auto loc = localeconv();\r
+ assert(loc != nullptr);\r
+ const char thousands_sep = !loc->thousands_sep ? '\0'\r
+ : loc->thousands_sep[0];\r
+\r
+ const char decimal_point = !loc->decimal_point ? '\0'\r
+ : loc->decimal_point[0];\r
+\r
+ // erase thousands separator\r
+ if (thousands_sep != '\0')\r
+ {\r
+ const auto end = std::remove(m_buf.begin(), m_buf.begin() + written_bytes, thousands_sep);\r
+ std::fill(end, m_buf.end(), '\0');\r
+ }\r
+\r
+ // convert decimal point to '.'\r
+ if (decimal_point != '\0' and decimal_point != '.')\r
+ {\r
+ for (auto& c : m_buf)\r
+ {\r
+ if (c == decimal_point)\r
+ {\r
+ c = '.';\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ // determine if need to append ".0"\r
+ size_t i = 0;\r
+ bool value_is_int_like = true;\r
+ for (i = 0; i < m_buf.size(); ++i)\r
+ {\r
+ // break when end of number is reached\r
+ if (m_buf[i] == '\0')\r
+ {\r
+ break;\r
+ }\r
+\r
+ // check if we find non-int character\r
+ value_is_int_like = value_is_int_like and m_buf[i] != '.' and\r
+ m_buf[i] != 'e' and m_buf[i] != 'E';\r
+ }\r
+\r
+ if (value_is_int_like)\r
+ {\r
+ // there must be 2 bytes left for ".0"\r
+ assert((i + 2) < m_buf.size());\r
+ // we write to the end of the number\r
+ assert(m_buf[i] == '\0');\r
+ assert(m_buf[i - 1] != '\0');\r
+\r
+ // add ".0"\r
+ m_buf[i] = '.';\r
+ m_buf[i + 1] = '0';\r
+\r
+ // the resulting string is properly terminated\r
+ assert(m_buf[i + 2] == '\0');\r
+ }\r
+ }\r
+ };\r
+\r
+\r
+ /*!\r
+ @brief internal implementation of the serialization function\r
+\r
+ This function is called by the public member function dump and organizes\r
+ the serialization internally. The indentation level is propagated as\r
+ additional parameter. In case of arrays and objects, the function is\r
+ called recursively. Note that\r
+\r
+ - strings and object keys are escaped using `escape_string()`\r
+ - integer numbers are converted implicitly via `operator<<`\r
+ - floating-point numbers are converted to a string using `"%g"` format\r
+\r
+ @param[out] o stream to write to\r
+ @param[in] pretty_print whether the output shall be pretty-printed\r
+ @param[in] indent_step the indent level\r
+ @param[in] current_indent the current indent level (only used internally)\r
+ */\r
+ void dump(std::ostream& o,\r
+ const bool pretty_print,\r
+ const unsigned int indent_step,\r
+ const unsigned int current_indent = 0) const\r
+ {\r
+ // variable to hold indentation for recursive calls\r
+ unsigned int new_indent = current_indent;\r
+\r
+ switch (m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ if (m_value.object->empty())\r
+ {\r
+ o << "{}";\r
+ return;\r
+ }\r
+\r
+ o << "{";\r
+\r
+ // increase indentation\r
+ if (pretty_print)\r
+ {\r
+ new_indent += indent_step;\r
+ o << "\n";\r
+ }\r
+\r
+ for (auto i = m_value.object->cbegin(); i != m_value.object->cend(); ++i)\r
+ {\r
+ if (i != m_value.object->cbegin())\r
+ {\r
+ o << (pretty_print ? ",\n" : ",");\r
+ }\r
+ o << string_t(new_indent, ' ') << "\""\r
+ << escape_string(i->first) << "\":"\r
+ << (pretty_print ? " " : "");\r
+ i->second.dump(o, pretty_print, indent_step, new_indent);\r
+ }\r
+\r
+ // decrease indentation\r
+ if (pretty_print)\r
+ {\r
+ new_indent -= indent_step;\r
+ o << "\n";\r
+ }\r
+\r
+ o << string_t(new_indent, ' ') + "}";\r
+ return;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ if (m_value.array->empty())\r
+ {\r
+ o << "[]";\r
+ return;\r
+ }\r
+\r
+ o << "[";\r
+\r
+ // increase indentation\r
+ if (pretty_print)\r
+ {\r
+ new_indent += indent_step;\r
+ o << "\n";\r
+ }\r
+\r
+ for (auto i = m_value.array->cbegin(); i != m_value.array->cend(); ++i)\r
+ {\r
+ if (i != m_value.array->cbegin())\r
+ {\r
+ o << (pretty_print ? ",\n" : ",");\r
+ }\r
+ o << string_t(new_indent, ' ');\r
+ i->dump(o, pretty_print, indent_step, new_indent);\r
+ }\r
+\r
+ // decrease indentation\r
+ if (pretty_print)\r
+ {\r
+ new_indent -= indent_step;\r
+ o << "\n";\r
+ }\r
+\r
+ o << string_t(new_indent, ' ') << "]";\r
+ return;\r
+ }\r
+\r
+ case value_t::string:\r
+ {\r
+ o << string_t("\"") << escape_string(*m_value.string) << "\"";\r
+ return;\r
+ }\r
+\r
+ case value_t::boolean:\r
+ {\r
+ o << (m_value.boolean ? "true" : "false");\r
+ return;\r
+ }\r
+\r
+ case value_t::number_integer:\r
+ {\r
+ o << numtostr(m_value.number_integer).c_str();\r
+ return;\r
+ }\r
+\r
+ case value_t::number_unsigned:\r
+ {\r
+ o << numtostr(m_value.number_unsigned).c_str();\r
+ return;\r
+ }\r
+\r
+ case value_t::number_float:\r
+ {\r
+ o << numtostr(m_value.number_float).c_str();\r
+ return;\r
+ }\r
+\r
+ case value_t::discarded:\r
+ {\r
+ o << "<discarded>";\r
+ return;\r
+ }\r
+\r
+ case value_t::null:\r
+ {\r
+ o << "null";\r
+ return;\r
+ }\r
+ }\r
+ }\r
+\r
+ private:\r
+ //////////////////////\r
+ // member variables //\r
+ //////////////////////\r
+\r
+ /// the type of the current element\r
+ value_t m_type = value_t::null;\r
+\r
+ /// the value of the current element\r
+ json_value m_value = {};\r
+\r
+\r
+ private:\r
+ ///////////////\r
+ // iterators //\r
+ ///////////////\r
+\r
+ /*!\r
+ @brief an iterator for primitive JSON types\r
+\r
+ This class models an iterator for primitive JSON types (boolean, number,\r
+ string). It's only purpose is to allow the iterator/const_iterator classes\r
+ to "iterate" over primitive values. Internally, the iterator is modeled by\r
+ a `difference_type` variable. Value begin_value (`0`) models the begin,\r
+ end_value (`1`) models past the end.\r
+ */\r
+ class primitive_iterator_t\r
+ {\r
+ public:\r
+\r
+ difference_type get_value() const noexcept\r
+ {\r
+ return m_it;\r
+ }\r
+ /// set iterator to a defined beginning\r
+ void set_begin() noexcept\r
+ {\r
+ m_it = begin_value;\r
+ }\r
+\r
+ /// set iterator to a defined past the end\r
+ void set_end() noexcept\r
+ {\r
+ m_it = end_value;\r
+ }\r
+\r
+ /// return whether the iterator can be dereferenced\r
+ constexpr bool is_begin() const noexcept\r
+ {\r
+ return (m_it == begin_value);\r
+ }\r
+\r
+ /// return whether the iterator is at end\r
+ constexpr bool is_end() const noexcept\r
+ {\r
+ return (m_it == end_value);\r
+ }\r
+\r
+ friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return lhs.m_it == rhs.m_it;\r
+ }\r
+\r
+ friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return !(lhs == rhs);\r
+ }\r
+\r
+ friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return lhs.m_it < rhs.m_it;\r
+ }\r
+\r
+ friend constexpr bool operator<=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return lhs.m_it <= rhs.m_it;\r
+ }\r
+\r
+ friend constexpr bool operator>(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return lhs.m_it > rhs.m_it;\r
+ }\r
+\r
+ friend constexpr bool operator>=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return lhs.m_it >= rhs.m_it;\r
+ }\r
+\r
+ primitive_iterator_t operator+(difference_type i)\r
+ {\r
+ auto result = *this;\r
+ result += i;\r
+ return result;\r
+ }\r
+\r
+ friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept\r
+ {\r
+ return lhs.m_it - rhs.m_it;\r
+ }\r
+\r
+ friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)\r
+ {\r
+ return os << it.m_it;\r
+ }\r
+\r
+ primitive_iterator_t& operator++()\r
+ {\r
+ ++m_it;\r
+ return *this;\r
+ }\r
+\r
+ primitive_iterator_t operator++(int)\r
+ {\r
+ auto result = *this;\r
+ m_it++;\r
+ return result;\r
+ }\r
+\r
+ primitive_iterator_t& operator--()\r
+ {\r
+ --m_it;\r
+ return *this;\r
+ }\r
+\r
+ primitive_iterator_t operator--(int)\r
+ {\r
+ auto result = *this;\r
+ m_it--;\r
+ return result;\r
+ }\r
+\r
+ primitive_iterator_t& operator+=(difference_type n)\r
+ {\r
+ m_it += n;\r
+ return *this;\r
+ }\r
+\r
+ primitive_iterator_t& operator-=(difference_type n)\r
+ {\r
+ m_it -= n;\r
+ return *this;\r
+ }\r
+\r
+ private:\r
+ static constexpr difference_type begin_value = 0;\r
+ static constexpr difference_type end_value = begin_value + 1;\r
+\r
+ /// iterator as signed integer type\r
+ difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();\r
+ };\r
+\r
+ /*!\r
+ @brief an iterator value\r
+\r
+ @note This structure could easily be a union, but MSVC currently does not\r
+ allow unions members with complex constructors, see\r
+ https://github.com/nlohmann/json/pull/105.\r
+ */\r
+ struct internal_iterator\r
+ {\r
+ /// iterator for JSON objects\r
+ typename object_t::iterator object_iterator;\r
+ /// iterator for JSON arrays\r
+ typename array_t::iterator array_iterator;\r
+ /// generic iterator for all other types\r
+ primitive_iterator_t primitive_iterator;\r
+\r
+ /// create an uninitialized internal_iterator\r
+ internal_iterator() noexcept\r
+ : object_iterator(), array_iterator(), primitive_iterator()\r
+ {}\r
+ };\r
+\r
+ /// proxy class for the iterator_wrapper functions\r
+ template<typename IteratorType>\r
+ class iteration_proxy\r
+ {\r
+ private:\r
+ /// helper class for iteration\r
+ class iteration_proxy_internal\r
+ {\r
+ private:\r
+ /// the iterator\r
+ IteratorType anchor;\r
+ /// an index for arrays (used to create key names)\r
+ size_t array_index = 0;\r
+\r
+ public:\r
+ explicit iteration_proxy_internal(IteratorType it) noexcept\r
+ : anchor(it)\r
+ {}\r
+\r
+ /// dereference operator (needed for range-based for)\r
+ iteration_proxy_internal& operator*()\r
+ {\r
+ return *this;\r
+ }\r
+\r
+ /// increment operator (needed for range-based for)\r
+ iteration_proxy_internal& operator++()\r
+ {\r
+ ++anchor;\r
+ ++array_index;\r
+\r
+ return *this;\r
+ }\r
+\r
+ /// inequality operator (needed for range-based for)\r
+ bool operator!= (const iteration_proxy_internal& o) const\r
+ {\r
+ return anchor != o.anchor;\r
+ }\r
+\r
+ /// return key of the iterator\r
+ typename basic_json::string_t key() const\r
+ {\r
+ assert(anchor.m_object != nullptr);\r
+\r
+ switch (anchor.m_object->type())\r
+ {\r
+ // use integer array index as key\r
+ case value_t::array:\r
+ {\r
+ return std::to_string(array_index);\r
+ }\r
+\r
+ // use key from the object\r
+ case value_t::object:\r
+ {\r
+ return anchor.key();\r
+ }\r
+\r
+ // use an empty key for all primitive types\r
+ default:\r
+ {\r
+ return "";\r
+ }\r
+ }\r
+ }\r
+\r
+ /// return value of the iterator\r
+ typename IteratorType::reference value() const\r
+ {\r
+ return anchor.value();\r
+ }\r
+ };\r
+\r
+ /// the container to iterate\r
+ typename IteratorType::reference container;\r
+\r
+ public:\r
+ /// construct iteration proxy from a container\r
+ explicit iteration_proxy(typename IteratorType::reference cont)\r
+ : container(cont)\r
+ {}\r
+\r
+ /// return iterator begin (needed for range-based for)\r
+ iteration_proxy_internal begin() noexcept\r
+ {\r
+ return iteration_proxy_internal(container.begin());\r
+ }\r
+\r
+ /// return iterator end (needed for range-based for)\r
+ iteration_proxy_internal end() noexcept\r
+ {\r
+ return iteration_proxy_internal(container.end());\r
+ }\r
+ };\r
+\r
+ public:\r
+ /*!\r
+ @brief a template for a random access iterator for the @ref basic_json class\r
+\r
+ This class implements a both iterators (iterator and const_iterator) for the\r
+ @ref basic_json class.\r
+\r
+ @note An iterator is called *initialized* when a pointer to a JSON value\r
+ has been set (e.g., by a constructor or a copy assignment). If the\r
+ iterator is default-constructed, it is *uninitialized* and most\r
+ methods are undefined. **The library uses assertions to detect calls\r
+ on uninitialized iterators.**\r
+\r
+ @requirement The class satisfies the following concept requirements:\r
+ - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):\r
+ The iterator that can be moved to point (forward and backward) to any\r
+ element in constant time.\r
+\r
+ @since version 1.0.0, simplified in version 2.0.9\r
+ */\r
+ template<typename U>\r
+ class iter_impl : public std::iterator<std::random_access_iterator_tag, U>\r
+ {\r
+ /// allow basic_json to access private members\r
+ friend class basic_json;\r
+\r
+ // make sure U is basic_json or const basic_json\r
+ static_assert(std::is_same<U, basic_json>::value\r
+ or std::is_same<U, const basic_json>::value,\r
+ "iter_impl only accepts (const) basic_json");\r
+\r
+ public:\r
+ /// the type of the values when the iterator is dereferenced\r
+ using value_type = typename basic_json::value_type;\r
+ /// a type to represent differences between iterators\r
+ using difference_type = typename basic_json::difference_type;\r
+ /// defines a pointer to the type iterated over (value_type)\r
+ using pointer = typename std::conditional<std::is_const<U>::value,\r
+ typename basic_json::const_pointer,\r
+ typename basic_json::pointer>::type;\r
+ /// defines a reference to the type iterated over (value_type)\r
+ using reference = typename std::conditional<std::is_const<U>::value,\r
+ typename basic_json::const_reference,\r
+ typename basic_json::reference>::type;\r
+ /// the category of the iterator\r
+ using iterator_category = std::bidirectional_iterator_tag;\r
+\r
+ /// default constructor\r
+ iter_impl() = default;\r
+\r
+ /*!\r
+ @brief constructor for a given JSON instance\r
+ @param[in] object pointer to a JSON object for this iterator\r
+ @pre object != nullptr\r
+ @post The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ explicit iter_impl(pointer object) noexcept\r
+ : m_object(object)\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ m_it.object_iterator = typename object_t::iterator();\r
+ break;\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ m_it.array_iterator = typename array_t::iterator();\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ m_it.primitive_iterator = primitive_iterator_t();\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*\r
+ Use operator `const_iterator` instead of `const_iterator(const iterator&\r
+ other) noexcept` to avoid two class definitions for @ref iterator and\r
+ @ref const_iterator.\r
+\r
+ This function is only called if this class is an @ref iterator. If this\r
+ class is a @ref const_iterator this function is not called.\r
+ */\r
+ operator const_iterator() const\r
+ {\r
+ const_iterator ret;\r
+\r
+ if (m_object)\r
+ {\r
+ ret.m_object = m_object;\r
+ ret.m_it = m_it;\r
+ }\r
+\r
+ return ret;\r
+ }\r
+\r
+ /*!\r
+ @brief copy constructor\r
+ @param[in] other iterator to copy from\r
+ @note It is not checked whether @a other is initialized.\r
+ */\r
+ iter_impl(const iter_impl& other) noexcept\r
+ : m_object(other.m_object), m_it(other.m_it)\r
+ {}\r
+\r
+ /*!\r
+ @brief copy assignment\r
+ @param[in,out] other iterator to copy from\r
+ @note It is not checked whether @a other is initialized.\r
+ */\r
+ iter_impl& operator=(iter_impl other) noexcept(\r
+ std::is_nothrow_move_constructible<pointer>::value and\r
+ std::is_nothrow_move_assignable<pointer>::value and\r
+ std::is_nothrow_move_constructible<internal_iterator>::value and\r
+ std::is_nothrow_move_assignable<internal_iterator>::value\r
+ )\r
+ {\r
+ std::swap(m_object, other.m_object);\r
+ std::swap(m_it, other.m_it);\r
+ return *this;\r
+ }\r
+\r
+ private:\r
+ /*!\r
+ @brief set the iterator to the first value\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ void set_begin() noexcept\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ m_it.object_iterator = m_object->m_value.object->begin();\r
+ break;\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ m_it.array_iterator = m_object->m_value.array->begin();\r
+ break;\r
+ }\r
+\r
+ case basic_json::value_t::null:\r
+ {\r
+ // set to end so begin()==end() is true: null is empty\r
+ m_it.primitive_iterator.set_end();\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ m_it.primitive_iterator.set_begin();\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief set the iterator past the last value\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ void set_end() noexcept\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ m_it.object_iterator = m_object->m_value.object->end();\r
+ break;\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ m_it.array_iterator = m_object->m_value.array->end();\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ m_it.primitive_iterator.set_end();\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ public:\r
+ /*!\r
+ @brief return a reference to the value pointed to by the iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ reference operator*() const\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ assert(m_it.object_iterator != m_object->m_value.object->end());\r
+ return m_it.object_iterator->second;\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ assert(m_it.array_iterator != m_object->m_value.array->end());\r
+ return *m_it.array_iterator;\r
+ }\r
+\r
+ case basic_json::value_t::null:\r
+ {\r
+ JSON_THROW(std::out_of_range("cannot get value"));\r
+ }\r
+\r
+ default:\r
+ {\r
+ if (m_it.primitive_iterator.is_begin())\r
+ {\r
+ return *m_object;\r
+ }\r
+\r
+ JSON_THROW(std::out_of_range("cannot get value"));\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief dereference the iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ pointer operator->() const\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ assert(m_it.object_iterator != m_object->m_value.object->end());\r
+ return &(m_it.object_iterator->second);\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ assert(m_it.array_iterator != m_object->m_value.array->end());\r
+ return &*m_it.array_iterator;\r
+ }\r
+\r
+ default:\r
+ {\r
+ if (m_it.primitive_iterator.is_begin())\r
+ {\r
+ return m_object;\r
+ }\r
+\r
+ JSON_THROW(std::out_of_range("cannot get value"));\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief post-increment (it++)\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl operator++(int)\r
+ {\r
+ auto result = *this;\r
+ ++(*this);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief pre-increment (++it)\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl& operator++()\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ std::advance(m_it.object_iterator, 1);\r
+ break;\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ std::advance(m_it.array_iterator, 1);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ ++m_it.primitive_iterator;\r
+ break;\r
+ }\r
+ }\r
+\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief post-decrement (it--)\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl operator--(int)\r
+ {\r
+ auto result = *this;\r
+ --(*this);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief pre-decrement (--it)\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl& operator--()\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ std::advance(m_it.object_iterator, -1);\r
+ break;\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ std::advance(m_it.array_iterator, -1);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ --m_it.primitive_iterator;\r
+ break;\r
+ }\r
+ }\r
+\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: equal\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ bool operator==(const iter_impl& other) const\r
+ {\r
+ // if objects are not the same, the comparison is undefined\r
+ if (m_object != other.m_object)\r
+ {\r
+ JSON_THROW(std::domain_error("cannot compare iterators of different containers"));\r
+ }\r
+\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ return (m_it.object_iterator == other.m_it.object_iterator);\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ return (m_it.array_iterator == other.m_it.array_iterator);\r
+ }\r
+\r
+ default:\r
+ {\r
+ return (m_it.primitive_iterator == other.m_it.primitive_iterator);\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: not equal\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ bool operator!=(const iter_impl& other) const\r
+ {\r
+ return not operator==(other);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: smaller\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ bool operator<(const iter_impl& other) const\r
+ {\r
+ // if objects are not the same, the comparison is undefined\r
+ if (m_object != other.m_object)\r
+ {\r
+ JSON_THROW(std::domain_error("cannot compare iterators of different containers"));\r
+ }\r
+\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot compare order of object iterators"));\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ return (m_it.array_iterator < other.m_it.array_iterator);\r
+ }\r
+\r
+ default:\r
+ {\r
+ return (m_it.primitive_iterator < other.m_it.primitive_iterator);\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: less than or equal\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ bool operator<=(const iter_impl& other) const\r
+ {\r
+ return not other.operator < (*this);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: greater than\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ bool operator>(const iter_impl& other) const\r
+ {\r
+ return not operator<=(other);\r
+ }\r
+\r
+ /*!\r
+ @brief comparison: greater than or equal\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ bool operator>=(const iter_impl& other) const\r
+ {\r
+ return not operator<(other);\r
+ }\r
+\r
+ /*!\r
+ @brief add to iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl& operator+=(difference_type i)\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use offsets with object iterators"));\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ std::advance(m_it.array_iterator, i);\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ m_it.primitive_iterator += i;\r
+ break;\r
+ }\r
+ }\r
+\r
+ return *this;\r
+ }\r
+\r
+ /*!\r
+ @brief subtract from iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl& operator-=(difference_type i)\r
+ {\r
+ return operator+=(-i);\r
+ }\r
+\r
+ /*!\r
+ @brief add to iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl operator+(difference_type i)\r
+ {\r
+ auto result = *this;\r
+ result += i;\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief subtract from iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ iter_impl operator-(difference_type i)\r
+ {\r
+ auto result = *this;\r
+ result -= i;\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief return difference\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ difference_type operator-(const iter_impl& other) const\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use offsets with object iterators"));\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ return m_it.array_iterator - other.m_it.array_iterator;\r
+ }\r
+\r
+ default:\r
+ {\r
+ return m_it.primitive_iterator - other.m_it.primitive_iterator;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief access to successor\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ reference operator[](difference_type n) const\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ switch (m_object->m_type)\r
+ {\r
+ case basic_json::value_t::object:\r
+ {\r
+ JSON_THROW(std::domain_error("cannot use operator[] for object iterators"));\r
+ }\r
+\r
+ case basic_json::value_t::array:\r
+ {\r
+ return *std::next(m_it.array_iterator, n);\r
+ }\r
+\r
+ case basic_json::value_t::null:\r
+ {\r
+ JSON_THROW(std::out_of_range("cannot get value"));\r
+ }\r
+\r
+ default:\r
+ {\r
+ if (m_it.primitive_iterator.get_value() == -n)\r
+ {\r
+ return *m_object;\r
+ }\r
+\r
+ JSON_THROW(std::out_of_range("cannot get value"));\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @brief return the key of an object iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ typename object_t::key_type key() const\r
+ {\r
+ assert(m_object != nullptr);\r
+\r
+ if (m_object->is_object())\r
+ {\r
+ return m_it.object_iterator->first;\r
+ }\r
+\r
+ JSON_THROW(std::domain_error("cannot use key() for non-object iterators"));\r
+ }\r
+\r
+ /*!\r
+ @brief return the value of an iterator\r
+ @pre The iterator is initialized; i.e. `m_object != nullptr`.\r
+ */\r
+ reference value() const\r
+ {\r
+ return operator*();\r
+ }\r
+\r
+ private:\r
+ /// associated JSON instance\r
+ pointer m_object = nullptr;\r
+ /// the actual iterator of the associated instance\r
+ internal_iterator m_it = internal_iterator();\r
+ };\r
+\r
+ /*!\r
+ @brief a template for a reverse iterator class\r
+\r
+ @tparam Base the base iterator type to reverse. Valid types are @ref\r
+ iterator (to create @ref reverse_iterator) and @ref const_iterator (to\r
+ create @ref const_reverse_iterator).\r
+\r
+ @requirement The class satisfies the following concept requirements:\r
+ - [RandomAccessIterator](http://en.cppreference.com/w/cpp/concept/RandomAccessIterator):\r
+ The iterator that can be moved to point (forward and backward) to any\r
+ element in constant time.\r
+ - [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):\r
+ It is possible to write to the pointed-to element (only if @a Base is\r
+ @ref iterator).\r
+\r
+ @since version 1.0.0\r
+ */\r
+ template<typename Base>\r
+ class json_reverse_iterator : public std::reverse_iterator<Base>\r
+ {\r
+ public:\r
+ /// shortcut to the reverse iterator adaptor\r
+ using base_iterator = std::reverse_iterator<Base>;\r
+ /// the reference type for the pointed-to element\r
+ using reference = typename Base::reference;\r
+\r
+ /// create reverse iterator from iterator\r
+ json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept\r
+ : base_iterator(it)\r
+ {}\r
+\r
+ /// create reverse iterator from base class\r
+ json_reverse_iterator(const base_iterator& it) noexcept\r
+ : base_iterator(it)\r
+ {}\r
+\r
+ /// post-increment (it++)\r
+ json_reverse_iterator operator++(int)\r
+ {\r
+ return base_iterator::operator++(1);\r
+ }\r
+\r
+ /// pre-increment (++it)\r
+ json_reverse_iterator& operator++()\r
+ {\r
+ base_iterator::operator++();\r
+ return *this;\r
+ }\r
+\r
+ /// post-decrement (it--)\r
+ json_reverse_iterator operator--(int)\r
+ {\r
+ return base_iterator::operator--(1);\r
+ }\r
+\r
+ /// pre-decrement (--it)\r
+ json_reverse_iterator& operator--()\r
+ {\r
+ base_iterator::operator--();\r
+ return *this;\r
+ }\r
+\r
+ /// add to iterator\r
+ json_reverse_iterator& operator+=(difference_type i)\r
+ {\r
+ base_iterator::operator+=(i);\r
+ return *this;\r
+ }\r
+\r
+ /// add to iterator\r
+ json_reverse_iterator operator+(difference_type i) const\r
+ {\r
+ auto result = *this;\r
+ result += i;\r
+ return result;\r
+ }\r
+\r
+ /// subtract from iterator\r
+ json_reverse_iterator operator-(difference_type i) const\r
+ {\r
+ auto result = *this;\r
+ result -= i;\r
+ return result;\r
+ }\r
+\r
+ /// return difference\r
+ difference_type operator-(const json_reverse_iterator& other) const\r
+ {\r
+ return this->base() - other.base();\r
+ }\r
+\r
+ /// access to successor\r
+ reference operator[](difference_type n) const\r
+ {\r
+ return *(this->operator+(n));\r
+ }\r
+\r
+ /// return the key of an object iterator\r
+ typename object_t::key_type key() const\r
+ {\r
+ auto it = --this->base();\r
+ return it.key();\r
+ }\r
+\r
+ /// return the value of an iterator\r
+ reference value() const\r
+ {\r
+ auto it = --this->base();\r
+ return it.operator * ();\r
+ }\r
+ };\r
+\r
+\r
+ private:\r
+ //////////////////////\r
+ // lexer and parser //\r
+ //////////////////////\r
+\r
+ /*!\r
+ @brief lexical analysis\r
+\r
+ This class organizes the lexical analysis during JSON deserialization. The\r
+ core of it is a scanner generated by [re2c](http://re2c.org) that\r
+ processes a buffer and recognizes tokens according to RFC 7159.\r
+ */\r
+ class lexer\r
+ {\r
+ public:\r
+ /// token types for the parser\r
+ enum class token_type\r
+ {\r
+ uninitialized, ///< indicating the scanner is uninitialized\r
+ literal_true, ///< the `true` literal\r
+ literal_false, ///< the `false` literal\r
+ literal_null, ///< the `null` literal\r
+ value_string, ///< a string -- use get_string() for actual value\r
+ value_unsigned, ///< an unsigned integer -- use get_number() for actual value\r
+ value_integer, ///< a signed integer -- use get_number() for actual value\r
+ value_float, ///< an floating point number -- use get_number() for actual value\r
+ begin_array, ///< the character for array begin `[`\r
+ begin_object, ///< the character for object begin `{`\r
+ end_array, ///< the character for array end `]`\r
+ end_object, ///< the character for object end `}`\r
+ name_separator, ///< the name separator `:`\r
+ value_separator, ///< the value separator `,`\r
+ parse_error, ///< indicating a parse error\r
+ end_of_input ///< indicating the end of the input buffer\r
+ };\r
+\r
+ /// the char type to use in the lexer\r
+ using lexer_char_t = unsigned char;\r
+\r
+ /// a lexer from a buffer with given length\r
+ lexer(const lexer_char_t* buff, const size_t len) noexcept\r
+ : m_content(buff)\r
+ {\r
+ assert(m_content != nullptr);\r
+ m_start = m_cursor = m_content;\r
+ m_limit = m_content + len;\r
+ }\r
+\r
+ /// a lexer from an input stream\r
+ explicit lexer(std::istream& s)\r
+ : m_stream(&s), m_line_buffer()\r
+ {\r
+ // immediately abort if stream is erroneous\r
+ if (s.fail())\r
+ {\r
+ JSON_THROW(std::invalid_argument("stream error"));\r
+ }\r
+\r
+ // fill buffer\r
+ fill_line_buffer();\r
+\r
+ // skip UTF-8 byte-order mark\r
+ if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")\r
+ {\r
+ m_line_buffer[0] = ' ';\r
+ m_line_buffer[1] = ' ';\r
+ m_line_buffer[2] = ' ';\r
+ }\r
+ }\r
+\r
+ // switch off unwanted functions (due to pointer members)\r
+ lexer() = delete;\r
+ lexer(const lexer&) = delete;\r
+ lexer operator=(const lexer&) = delete;\r
+\r
+ /*!\r
+ @brief create a string from one or two Unicode code points\r
+\r
+ There are two cases: (1) @a codepoint1 is in the Basic Multilingual\r
+ Plane (U+0000 through U+FFFF) and @a codepoint2 is 0, or (2)\r
+ @a codepoint1 and @a codepoint2 are a UTF-16 surrogate pair to\r
+ represent a code point above U+FFFF.\r
+\r
+ @param[in] codepoint1 the code point (can be high surrogate)\r
+ @param[in] codepoint2 the code point (can be low surrogate or 0)\r
+\r
+ @return string representation of the code point; the length of the\r
+ result string is between 1 and 4 characters.\r
+\r
+ @throw std::out_of_range if code point is > 0x10ffff; example: `"code\r
+ points above 0x10FFFF are invalid"`\r
+ @throw std::invalid_argument if the low surrogate is invalid; example:\r
+ `""missing or wrong low surrogate""`\r
+\r
+ @complexity Constant.\r
+\r
+ @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>\r
+ */\r
+ static string_t to_unicode(const std::size_t codepoint1,\r
+ const std::size_t codepoint2 = 0)\r
+ {\r
+ // calculate the code point from the given code points\r
+ std::size_t codepoint = codepoint1;\r
+\r
+ // check if codepoint1 is a high surrogate\r
+ if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)\r
+ {\r
+ // check if codepoint2 is a low surrogate\r
+ if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)\r
+ {\r
+ codepoint =\r
+ // high surrogate occupies the most significant 22 bits\r
+ (codepoint1 << 10)\r
+ // low surrogate occupies the least significant 15 bits\r
+ + codepoint2\r
+ // there is still the 0xD800, 0xDC00 and 0x10000 noise\r
+ // in the result so we have to subtract with:\r
+ // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00\r
+ - 0x35FDC00;\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::invalid_argument("missing or wrong low surrogate"));\r
+ }\r
+ }\r
+\r
+ string_t result;\r
+\r
+ if (codepoint < 0x80)\r
+ {\r
+ // 1-byte characters: 0xxxxxxx (ASCII)\r
+ result.append(1, static_cast<typename string_t::value_type>(codepoint));\r
+ }\r
+ else if (codepoint <= 0x7ff)\r
+ {\r
+ // 2-byte characters: 110xxxxx 10xxxxxx\r
+ result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));\r
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));\r
+ }\r
+ else if (codepoint <= 0xffff)\r
+ {\r
+ // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx\r
+ result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));\r
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));\r
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));\r
+ }\r
+ else if (codepoint <= 0x10ffff)\r
+ {\r
+ // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\r
+ result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));\r
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));\r
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));\r
+ result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::out_of_range("code points above 0x10FFFF are invalid"));\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /// return name of values of type token_type (only used for errors)\r
+ static std::string token_type_name(const token_type t)\r
+ {\r
+ switch (t)\r
+ {\r
+ case token_type::uninitialized:\r
+ return "<uninitialized>";\r
+ case token_type::literal_true:\r
+ return "true literal";\r
+ case token_type::literal_false:\r
+ return "false literal";\r
+ case token_type::literal_null:\r
+ return "null literal";\r
+ case token_type::value_string:\r
+ return "string literal";\r
+ case lexer::token_type::value_unsigned:\r
+ case lexer::token_type::value_integer:\r
+ case lexer::token_type::value_float:\r
+ return "number literal";\r
+ case token_type::begin_array:\r
+ return "'['";\r
+ case token_type::begin_object:\r
+ return "'{'";\r
+ case token_type::end_array:\r
+ return "']'";\r
+ case token_type::end_object:\r
+ return "'}'";\r
+ case token_type::name_separator:\r
+ return "':'";\r
+ case token_type::value_separator:\r
+ return "','";\r
+ case token_type::parse_error:\r
+ return "<parse error>";\r
+ case token_type::end_of_input:\r
+ return "end of input";\r
+ default:\r
+ {\r
+ // catch non-enum values\r
+ return "unknown token"; // LCOV_EXCL_LINE\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ This function implements a scanner for JSON. It is specified using\r
+ regular expressions that try to follow RFC 7159 as close as possible.\r
+ These regular expressions are then translated into a minimized\r
+ deterministic finite automaton (DFA) by the tool\r
+ [re2c](http://re2c.org). As a result, the translated code for this\r
+ function consists of a large block of code with `goto` jumps.\r
+\r
+ @return the class of the next token read from the buffer\r
+\r
+ @complexity Linear in the length of the input.\n\r
+\r
+ Proposition: The loop below will always terminate for finite input.\n\r
+\r
+ Proof (by contradiction): Assume a finite input. To loop forever, the\r
+ loop must never hit code with a `break` statement. The only code\r
+ snippets without a `break` statement are the continue statements for\r
+ whitespace and byte-order-marks. To loop forever, the input must be an\r
+ infinite sequence of whitespace or byte-order-marks. This contradicts\r
+ the assumption of finite input, q.e.d.\r
+ */\r
+ token_type scan()\r
+ {\r
+ while (true)\r
+ {\r
+ // pointer for backtracking information\r
+ m_marker = nullptr;\r
+\r
+ // remember the begin of the token\r
+ m_start = m_cursor;\r
+ assert(m_start != nullptr);\r
+\r
+\r
+ {\r
+ lexer_char_t yych;\r
+ unsigned int yyaccept = 0;\r
+ static const unsigned char yybm[] =\r
+ {\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 32, 32, 0, 0, 32, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 160, 128, 0, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 192, 192, 192, 192, 192, 192, 192, 192,\r
+ 192, 192, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 0, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 128, 128, 128, 128, 128, 128, 128, 128,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ 0, 0, 0, 0, 0, 0, 0, 0,\r
+ };\r
+ if ((m_limit - m_cursor) < 5)\r
+ {\r
+ fill_line_buffer(5); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yybm[0 + yych] & 32)\r
+ {\r
+ goto basic_json_parser_6;\r
+ }\r
+ if (yych <= '[')\r
+ {\r
+ if (yych <= '-')\r
+ {\r
+ if (yych <= '"')\r
+ {\r
+ if (yych <= 0x00)\r
+ {\r
+ goto basic_json_parser_2;\r
+ }\r
+ if (yych <= '!')\r
+ {\r
+ goto basic_json_parser_4;\r
+ }\r
+ goto basic_json_parser_9;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= '+')\r
+ {\r
+ goto basic_json_parser_4;\r
+ }\r
+ if (yych <= ',')\r
+ {\r
+ goto basic_json_parser_10;\r
+ }\r
+ goto basic_json_parser_12;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= '9')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_4;\r
+ }\r
+ if (yych <= '0')\r
+ {\r
+ goto basic_json_parser_13;\r
+ }\r
+ goto basic_json_parser_15;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= ':')\r
+ {\r
+ goto basic_json_parser_17;\r
+ }\r
+ if (yych <= 'Z')\r
+ {\r
+ goto basic_json_parser_4;\r
+ }\r
+ goto basic_json_parser_19;\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'n')\r
+ {\r
+ if (yych <= 'e')\r
+ {\r
+ if (yych == ']')\r
+ {\r
+ goto basic_json_parser_21;\r
+ }\r
+ goto basic_json_parser_4;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'f')\r
+ {\r
+ goto basic_json_parser_23;\r
+ }\r
+ if (yych <= 'm')\r
+ {\r
+ goto basic_json_parser_4;\r
+ }\r
+ goto basic_json_parser_24;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'z')\r
+ {\r
+ if (yych == 't')\r
+ {\r
+ goto basic_json_parser_25;\r
+ }\r
+ goto basic_json_parser_4;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= '{')\r
+ {\r
+ goto basic_json_parser_26;\r
+ }\r
+ if (yych == '}')\r
+ {\r
+ goto basic_json_parser_28;\r
+ }\r
+ goto basic_json_parser_4;\r
+ }\r
+ }\r
+ }\r
+basic_json_parser_2:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::end_of_input;\r
+ break;\r
+ }\r
+basic_json_parser_4:\r
+ ++m_cursor;\r
+basic_json_parser_5:\r
+ {\r
+ last_token_type = token_type::parse_error;\r
+ break;\r
+ }\r
+basic_json_parser_6:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yybm[0 + yych] & 32)\r
+ {\r
+ goto basic_json_parser_6;\r
+ }\r
+ {\r
+ continue;\r
+ }\r
+basic_json_parser_9:\r
+ yyaccept = 0;\r
+ yych = *(m_marker = ++m_cursor);\r
+ if (yych <= 0x1F)\r
+ {\r
+ goto basic_json_parser_5;\r
+ }\r
+ if (yych <= 0x7F)\r
+ {\r
+ goto basic_json_parser_31;\r
+ }\r
+ if (yych <= 0xC1)\r
+ {\r
+ goto basic_json_parser_5;\r
+ }\r
+ if (yych <= 0xF4)\r
+ {\r
+ goto basic_json_parser_31;\r
+ }\r
+ goto basic_json_parser_5;\r
+basic_json_parser_10:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::value_separator;\r
+ break;\r
+ }\r
+basic_json_parser_12:\r
+ yych = *++m_cursor;\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_5;\r
+ }\r
+ if (yych <= '0')\r
+ {\r
+ goto basic_json_parser_43;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_45;\r
+ }\r
+ goto basic_json_parser_5;\r
+basic_json_parser_13:\r
+ yyaccept = 1;\r
+ yych = *(m_marker = ++m_cursor);\r
+ if (yych <= '9')\r
+ {\r
+ if (yych == '.')\r
+ {\r
+ goto basic_json_parser_47;\r
+ }\r
+ if (yych >= '0')\r
+ {\r
+ goto basic_json_parser_48;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'E')\r
+ {\r
+ if (yych >= 'E')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ }\r
+ }\r
+basic_json_parser_14:\r
+ {\r
+ last_token_type = token_type::value_unsigned;\r
+ break;\r
+ }\r
+basic_json_parser_15:\r
+ yyaccept = 1;\r
+ m_marker = ++m_cursor;\r
+ if ((m_limit - m_cursor) < 3)\r
+ {\r
+ fill_line_buffer(3); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yybm[0 + yych] & 64)\r
+ {\r
+ goto basic_json_parser_15;\r
+ }\r
+ if (yych <= 'D')\r
+ {\r
+ if (yych == '.')\r
+ {\r
+ goto basic_json_parser_47;\r
+ }\r
+ goto basic_json_parser_14;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'E')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ goto basic_json_parser_14;\r
+ }\r
+basic_json_parser_17:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::name_separator;\r
+ break;\r
+ }\r
+basic_json_parser_19:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::begin_array;\r
+ break;\r
+ }\r
+basic_json_parser_21:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::end_array;\r
+ break;\r
+ }\r
+basic_json_parser_23:\r
+ yyaccept = 0;\r
+ yych = *(m_marker = ++m_cursor);\r
+ if (yych == 'a')\r
+ {\r
+ goto basic_json_parser_52;\r
+ }\r
+ goto basic_json_parser_5;\r
+basic_json_parser_24:\r
+ yyaccept = 0;\r
+ yych = *(m_marker = ++m_cursor);\r
+ if (yych == 'u')\r
+ {\r
+ goto basic_json_parser_53;\r
+ }\r
+ goto basic_json_parser_5;\r
+basic_json_parser_25:\r
+ yyaccept = 0;\r
+ yych = *(m_marker = ++m_cursor);\r
+ if (yych == 'r')\r
+ {\r
+ goto basic_json_parser_54;\r
+ }\r
+ goto basic_json_parser_5;\r
+basic_json_parser_26:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::begin_object;\r
+ break;\r
+ }\r
+basic_json_parser_28:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::end_object;\r
+ break;\r
+ }\r
+basic_json_parser_30:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+basic_json_parser_31:\r
+ if (yybm[0 + yych] & 128)\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ if (yych <= 0xE0)\r
+ {\r
+ if (yych <= '\\')\r
+ {\r
+ if (yych <= 0x1F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '"')\r
+ {\r
+ goto basic_json_parser_33;\r
+ }\r
+ goto basic_json_parser_35;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 0xC1)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0xDF)\r
+ {\r
+ goto basic_json_parser_36;\r
+ }\r
+ goto basic_json_parser_37;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 0xEF)\r
+ {\r
+ if (yych == 0xED)\r
+ {\r
+ goto basic_json_parser_39;\r
+ }\r
+ goto basic_json_parser_38;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 0xF0)\r
+ {\r
+ goto basic_json_parser_40;\r
+ }\r
+ if (yych <= 0xF3)\r
+ {\r
+ goto basic_json_parser_41;\r
+ }\r
+ if (yych <= 0xF4)\r
+ {\r
+ goto basic_json_parser_42;\r
+ }\r
+ }\r
+ }\r
+basic_json_parser_32:\r
+ m_cursor = m_marker;\r
+ if (yyaccept <= 1)\r
+ {\r
+ if (yyaccept == 0)\r
+ {\r
+ goto basic_json_parser_5;\r
+ }\r
+ else\r
+ {\r
+ goto basic_json_parser_14;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yyaccept == 2)\r
+ {\r
+ goto basic_json_parser_44;\r
+ }\r
+ else\r
+ {\r
+ goto basic_json_parser_58;\r
+ }\r
+ }\r
+basic_json_parser_33:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::value_string;\r
+ break;\r
+ }\r
+basic_json_parser_35:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 'e')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ if (yych == '"')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ if (yych <= '.')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ goto basic_json_parser_30;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= '\\')\r
+ {\r
+ if (yych <= '[')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ goto basic_json_parser_30;\r
+ }\r
+ else\r
+ {\r
+ if (yych == 'b')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'q')\r
+ {\r
+ if (yych <= 'f')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ if (yych == 'n')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 's')\r
+ {\r
+ if (yych <= 'r')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 't')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ if (yych <= 'u')\r
+ {\r
+ goto basic_json_parser_55;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ }\r
+ }\r
+basic_json_parser_36:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x7F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0xBF)\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_37:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x9F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0xBF)\r
+ {\r
+ goto basic_json_parser_36;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_38:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x7F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0xBF)\r
+ {\r
+ goto basic_json_parser_36;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_39:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x7F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0x9F)\r
+ {\r
+ goto basic_json_parser_36;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_40:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x8F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0xBF)\r
+ {\r
+ goto basic_json_parser_38;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_41:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x7F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0xBF)\r
+ {\r
+ goto basic_json_parser_38;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_42:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 0x7F)\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 0x8F)\r
+ {\r
+ goto basic_json_parser_38;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_43:\r
+ yyaccept = 2;\r
+ yych = *(m_marker = ++m_cursor);\r
+ if (yych <= '9')\r
+ {\r
+ if (yych == '.')\r
+ {\r
+ goto basic_json_parser_47;\r
+ }\r
+ if (yych >= '0')\r
+ {\r
+ goto basic_json_parser_48;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'E')\r
+ {\r
+ if (yych >= 'E')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ }\r
+ }\r
+basic_json_parser_44:\r
+ {\r
+ last_token_type = token_type::value_integer;\r
+ break;\r
+ }\r
+basic_json_parser_45:\r
+ yyaccept = 2;\r
+ m_marker = ++m_cursor;\r
+ if ((m_limit - m_cursor) < 3)\r
+ {\r
+ fill_line_buffer(3); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '9')\r
+ {\r
+ if (yych == '.')\r
+ {\r
+ goto basic_json_parser_47;\r
+ }\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_44;\r
+ }\r
+ goto basic_json_parser_45;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'E')\r
+ {\r
+ if (yych <= 'D')\r
+ {\r
+ goto basic_json_parser_44;\r
+ }\r
+ goto basic_json_parser_51;\r
+ }\r
+ else\r
+ {\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ goto basic_json_parser_44;\r
+ }\r
+ }\r
+basic_json_parser_47:\r
+ yych = *++m_cursor;\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_56;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_48:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_50;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_48;\r
+ }\r
+basic_json_parser_50:\r
+ {\r
+ last_token_type = token_type::parse_error;\r
+ break;\r
+ }\r
+basic_json_parser_51:\r
+ yych = *++m_cursor;\r
+ if (yych <= ',')\r
+ {\r
+ if (yych == '+')\r
+ {\r
+ goto basic_json_parser_59;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= '-')\r
+ {\r
+ goto basic_json_parser_59;\r
+ }\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_60;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+basic_json_parser_52:\r
+ yych = *++m_cursor;\r
+ if (yych == 'l')\r
+ {\r
+ goto basic_json_parser_62;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_53:\r
+ yych = *++m_cursor;\r
+ if (yych == 'l')\r
+ {\r
+ goto basic_json_parser_63;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_54:\r
+ yych = *++m_cursor;\r
+ if (yych == 'u')\r
+ {\r
+ goto basic_json_parser_64;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_55:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '@')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_65;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'F')\r
+ {\r
+ goto basic_json_parser_65;\r
+ }\r
+ if (yych <= '`')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 'f')\r
+ {\r
+ goto basic_json_parser_65;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+basic_json_parser_56:\r
+ yyaccept = 3;\r
+ m_marker = ++m_cursor;\r
+ if ((m_limit - m_cursor) < 3)\r
+ {\r
+ fill_line_buffer(3); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= 'D')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_58;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_56;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'E')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_51;\r
+ }\r
+ }\r
+basic_json_parser_58:\r
+ {\r
+ last_token_type = token_type::value_float;\r
+ break;\r
+ }\r
+basic_json_parser_59:\r
+ yych = *++m_cursor;\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych >= ':')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+basic_json_parser_60:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_58;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_60;\r
+ }\r
+ goto basic_json_parser_58;\r
+basic_json_parser_62:\r
+ yych = *++m_cursor;\r
+ if (yych == 's')\r
+ {\r
+ goto basic_json_parser_66;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_63:\r
+ yych = *++m_cursor;\r
+ if (yych == 'l')\r
+ {\r
+ goto basic_json_parser_67;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_64:\r
+ yych = *++m_cursor;\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_69;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_65:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '@')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_71;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'F')\r
+ {\r
+ goto basic_json_parser_71;\r
+ }\r
+ if (yych <= '`')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 'f')\r
+ {\r
+ goto basic_json_parser_71;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+basic_json_parser_66:\r
+ yych = *++m_cursor;\r
+ if (yych == 'e')\r
+ {\r
+ goto basic_json_parser_72;\r
+ }\r
+ goto basic_json_parser_32;\r
+basic_json_parser_67:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::literal_null;\r
+ break;\r
+ }\r
+basic_json_parser_69:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::literal_true;\r
+ break;\r
+ }\r
+basic_json_parser_71:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '@')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_74;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'F')\r
+ {\r
+ goto basic_json_parser_74;\r
+ }\r
+ if (yych <= '`')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 'f')\r
+ {\r
+ goto basic_json_parser_74;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+basic_json_parser_72:\r
+ ++m_cursor;\r
+ {\r
+ last_token_type = token_type::literal_false;\r
+ break;\r
+ }\r
+basic_json_parser_74:\r
+ ++m_cursor;\r
+ if (m_limit <= m_cursor)\r
+ {\r
+ fill_line_buffer(1); // LCOV_EXCL_LINE\r
+ }\r
+ yych = *m_cursor;\r
+ if (yych <= '@')\r
+ {\r
+ if (yych <= '/')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= '9')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ else\r
+ {\r
+ if (yych <= 'F')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ if (yych <= '`')\r
+ {\r
+ goto basic_json_parser_32;\r
+ }\r
+ if (yych <= 'f')\r
+ {\r
+ goto basic_json_parser_30;\r
+ }\r
+ goto basic_json_parser_32;\r
+ }\r
+ }\r
+\r
+ }\r
+\r
+ return last_token_type;\r
+ }\r
+\r
+ /*!\r
+ @brief append data from the stream to the line buffer\r
+\r
+ This function is called by the scan() function when the end of the\r
+ buffer (`m_limit`) is reached and the `m_cursor` pointer cannot be\r
+ incremented without leaving the limits of the line buffer. Note re2c\r
+ decides when to call this function.\r
+\r
+ If the lexer reads from contiguous storage, there is no trailing null\r
+ byte. Therefore, this function must make sure to add these padding\r
+ null bytes.\r
+\r
+ If the lexer reads from an input stream, this function reads the next\r
+ line of the input.\r
+\r
+ @pre\r
+ p p p p p p u u u u u x . . . . . .\r
+ ^ ^ ^ ^\r
+ m_content m_start | m_limit\r
+ m_cursor\r
+\r
+ @post\r
+ u u u u u x x x x x x x . . . . . .\r
+ ^ ^ ^\r
+ | m_cursor m_limit\r
+ m_start\r
+ m_content\r
+ */\r
+ void fill_line_buffer(size_t n = 0)\r
+ {\r
+ // if line buffer is used, m_content points to its data\r
+ assert(m_line_buffer.empty()\r
+ or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));\r
+\r
+ // if line buffer is used, m_limit is set past the end of its data\r
+ assert(m_line_buffer.empty()\r
+ or m_limit == m_content + m_line_buffer.size());\r
+\r
+ // pointer relationships\r
+ assert(m_content <= m_start);\r
+ assert(m_start <= m_cursor);\r
+ assert(m_cursor <= m_limit);\r
+ assert(m_marker == nullptr or m_marker <= m_limit);\r
+\r
+ // number of processed characters (p)\r
+ const auto num_processed_chars = static_cast<size_t>(m_start - m_content);\r
+ // offset for m_marker wrt. to m_start\r
+ const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;\r
+ // number of unprocessed characters (u)\r
+ const auto offset_cursor = m_cursor - m_start;\r
+\r
+ // no stream is used or end of file is reached\r
+ if (m_stream == nullptr or m_stream->eof())\r
+ {\r
+ // m_start may or may not be pointing into m_line_buffer at\r
+ // this point. We trust the standard library to do the right\r
+ // thing. See http://stackoverflow.com/q/28142011/266378\r
+ m_line_buffer.assign(m_start, m_limit);\r
+\r
+ // append n characters to make sure that there is sufficient\r
+ // space between m_cursor and m_limit\r
+ m_line_buffer.append(1, '\x00');\r
+ if (n > 0)\r
+ {\r
+ m_line_buffer.append(n - 1, '\x01');\r
+ }\r
+ }\r
+ else\r
+ {\r
+ // delete processed characters from line buffer\r
+ m_line_buffer.erase(0, num_processed_chars);\r
+ // read next line from input stream\r
+ m_line_buffer_tmp.clear();\r
+ std::getline(*m_stream, m_line_buffer_tmp, '\n');\r
+\r
+ // add line with newline symbol to the line buffer\r
+ m_line_buffer += m_line_buffer_tmp;\r
+ m_line_buffer.push_back('\n');\r
+ }\r
+\r
+ // set pointers\r
+ m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());\r
+ assert(m_content != nullptr);\r
+ m_start = m_content;\r
+ m_marker = m_start + offset_marker;\r
+ m_cursor = m_start + offset_cursor;\r
+ m_limit = m_start + m_line_buffer.size();\r
+ }\r
+\r
+ /// return string representation of last read token\r
+ string_t get_token_string() const\r
+ {\r
+ assert(m_start != nullptr);\r
+ return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),\r
+ static_cast<size_t>(m_cursor - m_start));\r
+ }\r
+\r
+ /*!\r
+ @brief return string value for string tokens\r
+\r
+ The function iterates the characters between the opening and closing\r
+ quotes of the string value. The complete string is the range\r
+ [m_start,m_cursor). Consequently, we iterate from m_start+1 to\r
+ m_cursor-1.\r
+\r
+ We differentiate two cases:\r
+\r
+ 1. Escaped characters. In this case, a new character is constructed\r
+ according to the nature of the escape. Some escapes create new\r
+ characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied\r
+ as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape\r
+ `"\\uxxxx"` need special care. In this case, to_unicode takes care\r
+ of the construction of the values.\r
+ 2. Unescaped characters are copied as is.\r
+\r
+ @pre `m_cursor - m_start >= 2`, meaning the length of the last token\r
+ is at least 2 bytes which is trivially true for any string (which\r
+ consists of at least two quotes).\r
+\r
+ " c1 c2 c3 ... "\r
+ ^ ^\r
+ m_start m_cursor\r
+\r
+ @complexity Linear in the length of the string.\n\r
+\r
+ Lemma: The loop body will always terminate.\n\r
+\r
+ Proof (by contradiction): Assume the loop body does not terminate. As\r
+ the loop body does not contain another loop, one of the called\r
+ functions must never return. The called functions are `std::strtoul`\r
+ and to_unicode. Neither function can loop forever, so the loop body\r
+ will never loop forever which contradicts the assumption that the loop\r
+ body does not terminate, q.e.d.\n\r
+\r
+ Lemma: The loop condition for the for loop is eventually false.\n\r
+\r
+ Proof (by contradiction): Assume the loop does not terminate. Due to\r
+ the above lemma, this can only be due to a tautological loop\r
+ condition; that is, the loop condition i < m_cursor - 1 must always be\r
+ true. Let x be the change of i for any loop iteration. Then\r
+ m_start + 1 + x < m_cursor - 1 must hold to loop indefinitely. This\r
+ can be rephrased to m_cursor - m_start - 2 > x. With the\r
+ precondition, we x <= 0, meaning that the loop condition holds\r
+ indefinitely if i is always decreased. However, observe that the value\r
+ of i is strictly increasing with each iteration, as it is incremented\r
+ by 1 in the iteration expression and never decremented inside the loop\r
+ body. Hence, the loop condition will eventually be false which\r
+ contradicts the assumption that the loop condition is a tautology,\r
+ q.e.d.\r
+\r
+ @return string value of current token without opening and closing\r
+ quotes\r
+ @throw std::out_of_range if to_unicode fails\r
+ */\r
+ string_t get_string() const\r
+ {\r
+ assert(m_cursor - m_start >= 2);\r
+\r
+ string_t result;\r
+ result.reserve(static_cast<size_t>(m_cursor - m_start - 2));\r
+\r
+ // iterate the result between the quotes\r
+ for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)\r
+ {\r
+ // find next escape character\r
+ auto e = std::find(i, m_cursor - 1, '\\');\r
+ if (e != i)\r
+ {\r
+ // see https://github.com/nlohmann/json/issues/365#issuecomment-262874705\r
+ for (auto k = i; k < e; k++)\r
+ {\r
+ result.push_back(static_cast<typename string_t::value_type>(*k));\r
+ }\r
+ i = e - 1; // -1 because of ++i\r
+ }\r
+ else\r
+ {\r
+ // processing escaped character\r
+ // read next character\r
+ ++i;\r
+\r
+ switch (*i)\r
+ {\r
+ // the default escapes\r
+ case 't':\r
+ {\r
+ result += "\t";\r
+ break;\r
+ }\r
+ case 'b':\r
+ {\r
+ result += "\b";\r
+ break;\r
+ }\r
+ case 'f':\r
+ {\r
+ result += "\f";\r
+ break;\r
+ }\r
+ case 'n':\r
+ {\r
+ result += "\n";\r
+ break;\r
+ }\r
+ case 'r':\r
+ {\r
+ result += "\r";\r
+ break;\r
+ }\r
+ case '\\':\r
+ {\r
+ result += "\\";\r
+ break;\r
+ }\r
+ case '/':\r
+ {\r
+ result += "/";\r
+ break;\r
+ }\r
+ case '"':\r
+ {\r
+ result += "\"";\r
+ break;\r
+ }\r
+\r
+ // unicode\r
+ case 'u':\r
+ {\r
+ // get code xxxx from uxxxx\r
+ auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),\r
+ 4).c_str(), nullptr, 16);\r
+\r
+ // check if codepoint is a high surrogate\r
+ if (codepoint >= 0xD800 and codepoint <= 0xDBFF)\r
+ {\r
+ // make sure there is a subsequent unicode\r
+ if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')\r
+ {\r
+ JSON_THROW(std::invalid_argument("missing low surrogate"));\r
+ }\r
+\r
+ // get code yyyy from uxxxx\uyyyy\r
+ auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>\r
+ (i + 7), 4).c_str(), nullptr, 16);\r
+ result += to_unicode(codepoint, codepoint2);\r
+ // skip the next 10 characters (xxxx\uyyyy)\r
+ i += 10;\r
+ }\r
+ else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)\r
+ {\r
+ // we found a lone low surrogate\r
+ JSON_THROW(std::invalid_argument("missing high surrogate"));\r
+ }\r
+ else\r
+ {\r
+ // add unicode character(s)\r
+ result += to_unicode(codepoint);\r
+ // skip the next four characters (xxxx)\r
+ i += 4;\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+\r
+ /*!\r
+ @brief parse string into a built-in arithmetic type as if the current\r
+ locale is POSIX.\r
+\r
+ @note in floating-point case strtod may parse past the token's end -\r
+ this is not an error\r
+\r
+ @note any leading blanks are not handled\r
+ */\r
+ struct strtonum\r
+ {\r
+ public:\r
+ strtonum(const char* start, const char* end)\r
+ : m_start(start), m_end(end)\r
+ {}\r
+\r
+ /*!\r
+ @return true iff parsed successfully as number of type T\r
+\r
+ @param[in,out] val shall contain parsed value, or undefined value\r
+ if could not parse\r
+ */\r
+ template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type>\r
+ bool to(T& val) const\r
+ {\r
+ return parse(val, std::is_integral<T>());\r
+ }\r
+\r
+ private:\r
+ const char* const m_start = nullptr;\r
+ const char* const m_end = nullptr;\r
+\r
+ // floating-point conversion\r
+\r
+ // overloaded wrappers for strtod/strtof/strtold\r
+ // that will be called from parse<floating_point_t>\r
+ static void strtof(float& f, const char* str, char** endptr)\r
+ {\r
+ f = std::strtof(str, endptr);\r
+ }\r
+\r
+ static void strtof(double& f, const char* str, char** endptr)\r
+ {\r
+ f = std::strtod(str, endptr);\r
+ }\r
+\r
+ static void strtof(long double& f, const char* str, char** endptr)\r
+ {\r
+ f = std::strtold(str, endptr);\r
+ }\r
+\r
+ template<typename T>\r
+ bool parse(T& value, /*is_integral=*/std::false_type) const\r
+ {\r
+ // replace decimal separator with locale-specific version,\r
+ // when necessary; data will point to either the original\r
+ // string, or buf, or tempstr containing the fixed string.\r
+ std::string tempstr;\r
+ std::array<char, 64> buf;\r
+ const size_t len = static_cast<size_t>(m_end - m_start);\r
+\r
+ // lexer will reject empty numbers\r
+ assert(len > 0);\r
+\r
+ // since dealing with strtod family of functions, we're\r
+ // getting the decimal point char from the C locale facilities\r
+ // instead of C++'s numpunct facet of the current std::locale\r
+ const auto loc = localeconv();\r
+ assert(loc != nullptr);\r
+ const char decimal_point_char = (loc->decimal_point == nullptr) ? '.' : loc->decimal_point[0];\r
+\r
+ const char* data = m_start;\r
+\r
+ if (decimal_point_char != '.')\r
+ {\r
+ const size_t ds_pos = static_cast<size_t>(std::find(m_start, m_end, '.') - m_start);\r
+\r
+ if (ds_pos != len)\r
+ {\r
+ // copy the data into the local buffer or tempstr, if\r
+ // buffer is too small; replace decimal separator, and\r
+ // update data to point to the modified bytes\r
+ if ((len + 1) < buf.size())\r
+ {\r
+ std::copy(m_start, m_end, buf.begin());\r
+ buf[len] = 0;\r
+ buf[ds_pos] = decimal_point_char;\r
+ data = buf.data();\r
+ }\r
+ else\r
+ {\r
+ tempstr.assign(m_start, m_end);\r
+ tempstr[ds_pos] = decimal_point_char;\r
+ data = tempstr.c_str();\r
+ }\r
+ }\r
+ }\r
+\r
+ char* endptr = nullptr;\r
+ value = 0;\r
+ // this calls appropriate overload depending on T\r
+ strtof(value, data, &endptr);\r
+\r
+ // parsing was successful iff strtof parsed exactly the number\r
+ // of characters determined by the lexer (len)\r
+ const bool ok = (endptr == (data + len));\r
+\r
+ if (ok and (value == static_cast<T>(0.0)) and (*data == '-'))\r
+ {\r
+ // some implementations forget to negate the zero\r
+ value = -0.0;\r
+ }\r
+\r
+ return ok;\r
+ }\r
+\r
+ // integral conversion\r
+\r
+ signed long long parse_integral(char** endptr, /*is_signed*/std::true_type) const\r
+ {\r
+ return std::strtoll(m_start, endptr, 10);\r
+ }\r
+\r
+ unsigned long long parse_integral(char** endptr, /*is_signed*/std::false_type) const\r
+ {\r
+ return std::strtoull(m_start, endptr, 10);\r
+ }\r
+\r
+ template<typename T>\r
+ bool parse(T& value, /*is_integral=*/std::true_type) const\r
+ {\r
+ char* endptr = nullptr;\r
+ errno = 0; // these are thread-local\r
+ const auto x = parse_integral(&endptr, std::is_signed<T>());\r
+\r
+ // called right overload?\r
+ static_assert(std::is_signed<T>() == std::is_signed<decltype(x)>(), "");\r
+\r
+ value = static_cast<T>(x);\r
+\r
+ return (x == static_cast<decltype(x)>(value)) // x fits into destination T\r
+ and (x < 0) == (value < 0) // preserved sign\r
+ //and ((x != 0) or is_integral()) // strto[u]ll did nto fail\r
+ and (errno == 0) // strto[u]ll did not overflow\r
+ and (m_start < m_end) // token was not empty\r
+ and (endptr == m_end); // parsed entire token exactly\r
+ }\r
+ };\r
+\r
+ /*!\r
+ @brief return number value for number tokens\r
+\r
+ This function translates the last token into the most appropriate\r
+ number type (either integer, unsigned integer or floating point),\r
+ which is passed back to the caller via the result parameter.\r
+\r
+ integral numbers that don't fit into the the range of the respective\r
+ type are parsed as number_float_t\r
+\r
+ floating-point values do not satisfy std::isfinite predicate\r
+ are converted to value_t::null\r
+\r
+ throws if the entire string [m_start .. m_cursor) cannot be\r
+ interpreted as a number\r
+\r
+ @param[out] result @ref basic_json object to receive the number.\r
+ @param[in] token the type of the number token\r
+ */\r
+ bool get_number(basic_json& result, const token_type token) const\r
+ {\r
+ assert(m_start != nullptr);\r
+ assert(m_start < m_cursor);\r
+ assert((token == token_type::value_unsigned) or\r
+ (token == token_type::value_integer) or\r
+ (token == token_type::value_float));\r
+\r
+ strtonum num_converter(reinterpret_cast<const char*>(m_start),\r
+ reinterpret_cast<const char*>(m_cursor));\r
+\r
+ switch (token)\r
+ {\r
+ case lexer::token_type::value_unsigned:\r
+ {\r
+ number_unsigned_t val;\r
+ if (num_converter.to(val))\r
+ {\r
+ // parsing successful\r
+ result.m_type = value_t::number_unsigned;\r
+ result.m_value = val;\r
+ return true;\r
+ }\r
+ break;\r
+ }\r
+\r
+ case lexer::token_type::value_integer:\r
+ {\r
+ number_integer_t val;\r
+ if (num_converter.to(val))\r
+ {\r
+ // parsing successful\r
+ result.m_type = value_t::number_integer;\r
+ result.m_value = val;\r
+ return true;\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ break;\r
+ }\r
+ }\r
+\r
+ // parse float (either explicitly or because a previous conversion\r
+ // failed)\r
+ number_float_t val;\r
+ if (num_converter.to(val))\r
+ {\r
+ // parsing successful\r
+ result.m_type = value_t::number_float;\r
+ result.m_value = val;\r
+\r
+ // replace infinity and NAN by null\r
+ if (not std::isfinite(result.m_value.number_float))\r
+ {\r
+ result.m_type = value_t::null;\r
+ result.m_value = basic_json::json_value();\r
+ }\r
+\r
+ return true;\r
+ }\r
+\r
+ // couldn't parse number in any format\r
+ return false;\r
+ }\r
+\r
+ private:\r
+ /// optional input stream\r
+ std::istream* m_stream = nullptr;\r
+ /// line buffer buffer for m_stream\r
+ string_t m_line_buffer {};\r
+ /// used for filling m_line_buffer\r
+ string_t m_line_buffer_tmp {};\r
+ /// the buffer pointer\r
+ const lexer_char_t* m_content = nullptr;\r
+ /// pointer to the beginning of the current symbol\r
+ const lexer_char_t* m_start = nullptr;\r
+ /// pointer for backtracking information\r
+ const lexer_char_t* m_marker = nullptr;\r
+ /// pointer to the current symbol\r
+ const lexer_char_t* m_cursor = nullptr;\r
+ /// pointer to the end of the buffer\r
+ const lexer_char_t* m_limit = nullptr;\r
+ /// the last token type\r
+ token_type last_token_type = token_type::end_of_input;\r
+ };\r
+\r
+ /*!\r
+ @brief syntax analysis\r
+\r
+ This class implements a recursive decent parser.\r
+ */\r
+ class parser\r
+ {\r
+ public:\r
+ /// a parser reading from a string literal\r
+ parser(const char* buff, const parser_callback_t cb = nullptr)\r
+ : callback(cb),\r
+ m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))\r
+ {}\r
+\r
+ /// a parser reading from an input stream\r
+ parser(std::istream& is, const parser_callback_t cb = nullptr)\r
+ : callback(cb), m_lexer(is)\r
+ {}\r
+\r
+ /// a parser reading from an iterator range with contiguous storage\r
+ template<class IteratorType, typename std::enable_if<\r
+ std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value\r
+ , int>::type\r
+ = 0>\r
+ parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)\r
+ : callback(cb),\r
+ m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),\r
+ static_cast<size_t>(std::distance(first, last)))\r
+ {}\r
+\r
+ /// public parser interface\r
+ basic_json parse()\r
+ {\r
+ // read first token\r
+ get_token();\r
+\r
+ basic_json result = parse_internal(true);\r
+ result.assert_invariant();\r
+\r
+ expect(lexer::token_type::end_of_input);\r
+\r
+ // return parser result and replace it with null in case the\r
+ // top-level value was discarded by the callback function\r
+ return result.is_discarded() ? basic_json() : std::move(result);\r
+ }\r
+\r
+ private:\r
+ /// the actual parser\r
+ basic_json parse_internal(bool keep)\r
+ {\r
+ auto result = basic_json(value_t::discarded);\r
+\r
+ switch (last_token)\r
+ {\r
+ case lexer::token_type::begin_object:\r
+ {\r
+ if (keep and (not callback\r
+ or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))\r
+ {\r
+ // explicitly set result to object to cope with {}\r
+ result.m_type = value_t::object;\r
+ result.m_value = value_t::object;\r
+ }\r
+\r
+ // read next token\r
+ get_token();\r
+\r
+ // closing } -> we are done\r
+ if (last_token == lexer::token_type::end_object)\r
+ {\r
+ get_token();\r
+ if (keep and callback and not callback(--depth, parse_event_t::object_end, result))\r
+ {\r
+ result = basic_json(value_t::discarded);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ // no comma is expected here\r
+ unexpect(lexer::token_type::value_separator);\r
+\r
+ // otherwise: parse key-value pairs\r
+ do\r
+ {\r
+ // ugly, but could be fixed with loop reorganization\r
+ if (last_token == lexer::token_type::value_separator)\r
+ {\r
+ get_token();\r
+ }\r
+\r
+ // store key\r
+ expect(lexer::token_type::value_string);\r
+ const auto key = m_lexer.get_string();\r
+\r
+ bool keep_tag = false;\r
+ if (keep)\r
+ {\r
+ if (callback)\r
+ {\r
+ basic_json k(key);\r
+ keep_tag = callback(depth, parse_event_t::key, k);\r
+ }\r
+ else\r
+ {\r
+ keep_tag = true;\r
+ }\r
+ }\r
+\r
+ // parse separator (:)\r
+ get_token();\r
+ expect(lexer::token_type::name_separator);\r
+\r
+ // parse and add value\r
+ get_token();\r
+ auto value = parse_internal(keep);\r
+ if (keep and keep_tag and not value.is_discarded())\r
+ {\r
+ result[key] = std::move(value);\r
+ }\r
+ }\r
+ while (last_token == lexer::token_type::value_separator);\r
+\r
+ // closing }\r
+ expect(lexer::token_type::end_object);\r
+ get_token();\r
+ if (keep and callback and not callback(--depth, parse_event_t::object_end, result))\r
+ {\r
+ result = basic_json(value_t::discarded);\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ case lexer::token_type::begin_array:\r
+ {\r
+ if (keep and (not callback\r
+ or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))\r
+ {\r
+ // explicitly set result to object to cope with []\r
+ result.m_type = value_t::array;\r
+ result.m_value = value_t::array;\r
+ }\r
+\r
+ // read next token\r
+ get_token();\r
+\r
+ // closing ] -> we are done\r
+ if (last_token == lexer::token_type::end_array)\r
+ {\r
+ get_token();\r
+ if (callback and not callback(--depth, parse_event_t::array_end, result))\r
+ {\r
+ result = basic_json(value_t::discarded);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ // no comma is expected here\r
+ unexpect(lexer::token_type::value_separator);\r
+\r
+ // otherwise: parse values\r
+ do\r
+ {\r
+ // ugly, but could be fixed with loop reorganization\r
+ if (last_token == lexer::token_type::value_separator)\r
+ {\r
+ get_token();\r
+ }\r
+\r
+ // parse value\r
+ auto value = parse_internal(keep);\r
+ if (keep and not value.is_discarded())\r
+ {\r
+ result.push_back(std::move(value));\r
+ }\r
+ }\r
+ while (last_token == lexer::token_type::value_separator);\r
+\r
+ // closing ]\r
+ expect(lexer::token_type::end_array);\r
+ get_token();\r
+ if (keep and callback and not callback(--depth, parse_event_t::array_end, result))\r
+ {\r
+ result = basic_json(value_t::discarded);\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ case lexer::token_type::literal_null:\r
+ {\r
+ get_token();\r
+ result.m_type = value_t::null;\r
+ break;\r
+ }\r
+\r
+ case lexer::token_type::value_string:\r
+ {\r
+ const auto s = m_lexer.get_string();\r
+ get_token();\r
+ result = basic_json(s);\r
+ break;\r
+ }\r
+\r
+ case lexer::token_type::literal_true:\r
+ {\r
+ get_token();\r
+ result.m_type = value_t::boolean;\r
+ result.m_value = true;\r
+ break;\r
+ }\r
+\r
+ case lexer::token_type::literal_false:\r
+ {\r
+ get_token();\r
+ result.m_type = value_t::boolean;\r
+ result.m_value = false;\r
+ break;\r
+ }\r
+\r
+ case lexer::token_type::value_unsigned:\r
+ case lexer::token_type::value_integer:\r
+ case lexer::token_type::value_float:\r
+ {\r
+ m_lexer.get_number(result, last_token);\r
+ get_token();\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ // the last token was unexpected\r
+ unexpect(last_token);\r
+ }\r
+ }\r
+\r
+ if (keep and callback and not callback(depth, parse_event_t::value, result))\r
+ {\r
+ result = basic_json(value_t::discarded);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ /// get next token from lexer\r
+ typename lexer::token_type get_token()\r
+ {\r
+ last_token = m_lexer.scan();\r
+ return last_token;\r
+ }\r
+\r
+ void expect(typename lexer::token_type t) const\r
+ {\r
+ if (t != last_token)\r
+ {\r
+ std::string error_msg = "parse error - unexpected ";\r
+ error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token_string() +\r
+ "'") :\r
+ lexer::token_type_name(last_token));\r
+ error_msg += "; expected " + lexer::token_type_name(t);\r
+ JSON_THROW(std::invalid_argument(error_msg));\r
+ }\r
+ }\r
+\r
+ void unexpect(typename lexer::token_type t) const\r
+ {\r
+ if (t == last_token)\r
+ {\r
+ std::string error_msg = "parse error - unexpected ";\r
+ error_msg += (last_token == lexer::token_type::parse_error ? ("'" + m_lexer.get_token_string() +\r
+ "'") :\r
+ lexer::token_type_name(last_token));\r
+ JSON_THROW(std::invalid_argument(error_msg));\r
+ }\r
+ }\r
+\r
+ private:\r
+ /// current level of recursion\r
+ int depth = 0;\r
+ /// callback function\r
+ const parser_callback_t callback = nullptr;\r
+ /// the type of the last read token\r
+ typename lexer::token_type last_token = lexer::token_type::uninitialized;\r
+ /// the lexer\r
+ lexer m_lexer;\r
+ };\r
+\r
+ public:\r
+ /*!\r
+ @brief JSON Pointer\r
+\r
+ A JSON pointer defines a string syntax for identifying a specific value\r
+ within a JSON document. It can be used with functions `at` and\r
+ `operator[]`. Furthermore, JSON pointers are the base for JSON patches.\r
+\r
+ @sa [RFC 6901](https://tools.ietf.org/html/rfc6901)\r
+\r
+ @since version 2.0.0\r
+ */\r
+ class json_pointer\r
+ {\r
+ /// allow basic_json to access private members\r
+ friend class basic_json;\r
+\r
+ public:\r
+ /*!\r
+ @brief create JSON pointer\r
+\r
+ Create a JSON pointer according to the syntax described in\r
+ [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).\r
+\r
+ @param[in] s string representing the JSON pointer; if omitted, the\r
+ empty string is assumed which references the whole JSON\r
+ value\r
+\r
+ @throw std::domain_error if reference token is nonempty and does not\r
+ begin with a slash (`/`); example: `"JSON pointer must be empty or\r
+ begin with /"`\r
+ @throw std::domain_error if a tilde (`~`) is not followed by `0`\r
+ (representing `~`) or `1` (representing `/`); example: `"escape error:\r
+ ~ must be followed with 0 or 1"`\r
+\r
+ @liveexample{The example shows the construction several valid JSON\r
+ pointers as well as the exceptional behavior.,json_pointer}\r
+\r
+ @since version 2.0.0\r
+ */\r
+ explicit json_pointer(const std::string& s = "")\r
+ : reference_tokens(split(s))\r
+ {}\r
+\r
+ /*!\r
+ @brief return a string representation of the JSON pointer\r
+\r
+ @invariant For each JSON pointer `ptr`, it holds:\r
+ @code {.cpp}\r
+ ptr == json_pointer(ptr.to_string());\r
+ @endcode\r
+\r
+ @return a string representation of the JSON pointer\r
+\r
+ @liveexample{The example shows the result of `to_string`.,\r
+ json_pointer__to_string}\r
+\r
+ @since version 2.0.0\r
+ */\r
+ std::string to_string() const noexcept\r
+ {\r
+ return std::accumulate(reference_tokens.begin(),\r
+ reference_tokens.end(), std::string{},\r
+ [](const std::string & a, const std::string & b)\r
+ {\r
+ return a + "/" + escape(b);\r
+ });\r
+ }\r
+\r
+ /// @copydoc to_string()\r
+ operator std::string() const\r
+ {\r
+ return to_string();\r
+ }\r
+\r
+ private:\r
+ /// remove and return last reference pointer\r
+ std::string pop_back()\r
+ {\r
+ if (is_root())\r
+ {\r
+ JSON_THROW(std::domain_error("JSON pointer has no parent"));\r
+ }\r
+\r
+ auto last = reference_tokens.back();\r
+ reference_tokens.pop_back();\r
+ return last;\r
+ }\r
+\r
+ /// return whether pointer points to the root document\r
+ bool is_root() const\r
+ {\r
+ return reference_tokens.empty();\r
+ }\r
+\r
+ json_pointer top() const\r
+ {\r
+ if (is_root())\r
+ {\r
+ JSON_THROW(std::domain_error("JSON pointer has no parent"));\r
+ }\r
+\r
+ json_pointer result = *this;\r
+ result.reference_tokens = {reference_tokens[0]};\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief create and return a reference to the pointed to value\r
+\r
+ @complexity Linear in the number of reference tokens.\r
+ */\r
+ reference get_and_create(reference j) const\r
+ {\r
+ pointer result = &j;\r
+\r
+ // in case no reference tokens exist, return a reference to the\r
+ // JSON value j which will be overwritten by a primitive value\r
+ for (const auto& reference_token : reference_tokens)\r
+ {\r
+ switch (result->m_type)\r
+ {\r
+ case value_t::null:\r
+ {\r
+ if (reference_token == "0")\r
+ {\r
+ // start a new array if reference token is 0\r
+ result = &result->operator[](0);\r
+ }\r
+ else\r
+ {\r
+ // start a new object otherwise\r
+ result = &result->operator[](reference_token);\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ // create an entry in the object\r
+ result = &result->operator[](reference_token);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ // create an entry in the array\r
+ result = &result->operator[](static_cast<size_type>(std::stoi(reference_token)));\r
+ break;\r
+ }\r
+\r
+ /*\r
+ The following code is only reached if there exists a\r
+ reference token _and_ the current value is primitive. In\r
+ this case, we have an error situation, because primitive\r
+ values may only occur as single value; that is, with an\r
+ empty list of reference tokens.\r
+ */\r
+ default:\r
+ {\r
+ JSON_THROW(std::domain_error("invalid value to unflatten"));\r
+ }\r
+ }\r
+ }\r
+\r
+ return *result;\r
+ }\r
+\r
+ /*!\r
+ @brief return a reference to the pointed to value\r
+\r
+ @note This version does not throw if a value is not present, but tries\r
+ to create nested values instead. For instance, calling this function\r
+ with pointer `"/this/that"` on a null value is equivalent to calling\r
+ `operator[]("this").operator[]("that")` on that value, effectively\r
+ changing the null value to an object.\r
+\r
+ @param[in] ptr a JSON value\r
+\r
+ @return reference to the JSON value pointed to by the JSON pointer\r
+\r
+ @complexity Linear in the length of the JSON pointer.\r
+\r
+ @throw std::out_of_range if the JSON pointer can not be resolved\r
+ @throw std::domain_error if an array index begins with '0'\r
+ @throw std::invalid_argument if an array index was not a number\r
+ */\r
+ reference get_unchecked(pointer ptr) const\r
+ {\r
+ for (const auto& reference_token : reference_tokens)\r
+ {\r
+ // convert null values to arrays or objects before continuing\r
+ if (ptr->m_type == value_t::null)\r
+ {\r
+ // check if reference token is a number\r
+ const bool nums = std::all_of(reference_token.begin(),\r
+ reference_token.end(),\r
+ [](const char x)\r
+ {\r
+ return std::isdigit(x);\r
+ });\r
+\r
+ // change value to array for numbers or "-" or to object\r
+ // otherwise\r
+ if (nums or reference_token == "-")\r
+ {\r
+ *ptr = value_t::array;\r
+ }\r
+ else\r
+ {\r
+ *ptr = value_t::object;\r
+ }\r
+ }\r
+\r
+ switch (ptr->m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ // use unchecked object access\r
+ ptr = &ptr->operator[](reference_token);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ // error condition (cf. RFC 6901, Sect. 4)\r
+ if (reference_token.size() > 1 and reference_token[0] == '0')\r
+ {\r
+ JSON_THROW(std::domain_error("array index must not begin with '0'"));\r
+ }\r
+\r
+ if (reference_token == "-")\r
+ {\r
+ // explicitly treat "-" as index beyond the end\r
+ ptr = &ptr->operator[](ptr->m_value.array->size());\r
+ }\r
+ else\r
+ {\r
+ // convert array index to number; unchecked access\r
+ ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));\r
+ }\r
+ }\r
+ }\r
+\r
+ return *ptr;\r
+ }\r
+\r
+ reference get_checked(pointer ptr) const\r
+ {\r
+ for (const auto& reference_token : reference_tokens)\r
+ {\r
+ switch (ptr->m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ // note: at performs range check\r
+ ptr = &ptr->at(reference_token);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ if (reference_token == "-")\r
+ {\r
+ // "-" always fails the range check\r
+ JSON_THROW(std::out_of_range("array index '-' (" +\r
+ std::to_string(ptr->m_value.array->size()) +\r
+ ") is out of range"));\r
+ }\r
+\r
+ // error condition (cf. RFC 6901, Sect. 4)\r
+ if (reference_token.size() > 1 and reference_token[0] == '0')\r
+ {\r
+ JSON_THROW(std::domain_error("array index must not begin with '0'"));\r
+ }\r
+\r
+ // note: at performs range check\r
+ ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));\r
+ }\r
+ }\r
+ }\r
+\r
+ return *ptr;\r
+ }\r
+\r
+ /*!\r
+ @brief return a const reference to the pointed to value\r
+\r
+ @param[in] ptr a JSON value\r
+\r
+ @return const reference to the JSON value pointed to by the JSON\r
+ pointer\r
+ */\r
+ const_reference get_unchecked(const_pointer ptr) const\r
+ {\r
+ for (const auto& reference_token : reference_tokens)\r
+ {\r
+ switch (ptr->m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ // use unchecked object access\r
+ ptr = &ptr->operator[](reference_token);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ if (reference_token == "-")\r
+ {\r
+ // "-" cannot be used for const access\r
+ JSON_THROW(std::out_of_range("array index '-' (" +\r
+ std::to_string(ptr->m_value.array->size()) +\r
+ ") is out of range"));\r
+ }\r
+\r
+ // error condition (cf. RFC 6901, Sect. 4)\r
+ if (reference_token.size() > 1 and reference_token[0] == '0')\r
+ {\r
+ JSON_THROW(std::domain_error("array index must not begin with '0'"));\r
+ }\r
+\r
+ // use unchecked array access\r
+ ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));\r
+ }\r
+ }\r
+ }\r
+\r
+ return *ptr;\r
+ }\r
+\r
+ const_reference get_checked(const_pointer ptr) const\r
+ {\r
+ for (const auto& reference_token : reference_tokens)\r
+ {\r
+ switch (ptr->m_type)\r
+ {\r
+ case value_t::object:\r
+ {\r
+ // note: at performs range check\r
+ ptr = &ptr->at(reference_token);\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ if (reference_token == "-")\r
+ {\r
+ // "-" always fails the range check\r
+ JSON_THROW(std::out_of_range("array index '-' (" +\r
+ std::to_string(ptr->m_value.array->size()) +\r
+ ") is out of range"));\r
+ }\r
+\r
+ // error condition (cf. RFC 6901, Sect. 4)\r
+ if (reference_token.size() > 1 and reference_token[0] == '0')\r
+ {\r
+ JSON_THROW(std::domain_error("array index must not begin with '0'"));\r
+ }\r
+\r
+ // note: at performs range check\r
+ ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));\r
+ }\r
+ }\r
+ }\r
+\r
+ return *ptr;\r
+ }\r
+\r
+ /// split the string input to reference tokens\r
+ static std::vector<std::string> split(const std::string& reference_string)\r
+ {\r
+ std::vector<std::string> result;\r
+\r
+ // special case: empty reference string -> no reference tokens\r
+ if (reference_string.empty())\r
+ {\r
+ return result;\r
+ }\r
+\r
+ // check if nonempty reference string begins with slash\r
+ if (reference_string[0] != '/')\r
+ {\r
+ JSON_THROW(std::domain_error("JSON pointer must be empty or begin with '/'"));\r
+ }\r
+\r
+ // extract the reference tokens:\r
+ // - slash: position of the last read slash (or end of string)\r
+ // - start: position after the previous slash\r
+ for (\r
+ // search for the first slash after the first character\r
+ size_t slash = reference_string.find_first_of('/', 1),\r
+ // set the beginning of the first reference token\r
+ start = 1;\r
+ // we can stop if start == string::npos+1 = 0\r
+ start != 0;\r
+ // set the beginning of the next reference token\r
+ // (will eventually be 0 if slash == std::string::npos)\r
+ start = slash + 1,\r
+ // find next slash\r
+ slash = reference_string.find_first_of('/', start))\r
+ {\r
+ // use the text between the beginning of the reference token\r
+ // (start) and the last slash (slash).\r
+ auto reference_token = reference_string.substr(start, slash - start);\r
+\r
+ // check reference tokens are properly escaped\r
+ for (size_t pos = reference_token.find_first_of('~');\r
+ pos != std::string::npos;\r
+ pos = reference_token.find_first_of('~', pos + 1))\r
+ {\r
+ assert(reference_token[pos] == '~');\r
+\r
+ // ~ must be followed by 0 or 1\r
+ if (pos == reference_token.size() - 1 or\r
+ (reference_token[pos + 1] != '0' and\r
+ reference_token[pos + 1] != '1'))\r
+ {\r
+ JSON_THROW(std::domain_error("escape error: '~' must be followed with '0' or '1'"));\r
+ }\r
+ }\r
+\r
+ // finally, store the reference token\r
+ unescape(reference_token);\r
+ result.push_back(reference_token);\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ private:\r
+ /*!\r
+ @brief replace all occurrences of a substring by another string\r
+\r
+ @param[in,out] s the string to manipulate; changed so that all\r
+ occurrences of @a f are replaced with @a t\r
+ @param[in] f the substring to replace with @a t\r
+ @param[in] t the string to replace @a f\r
+\r
+ @pre The search string @a f must not be empty.\r
+\r
+ @since version 2.0.0\r
+ */\r
+ static void replace_substring(std::string& s,\r
+ const std::string& f,\r
+ const std::string& t)\r
+ {\r
+ assert(not f.empty());\r
+\r
+ for (\r
+ size_t pos = s.find(f); // find first occurrence of f\r
+ pos != std::string::npos; // make sure f was found\r
+ s.replace(pos, f.size(), t), // replace with t\r
+ pos = s.find(f, pos + t.size()) // find next occurrence of f\r
+ );\r
+ }\r
+\r
+ /// escape tilde and slash\r
+ static std::string escape(std::string s)\r
+ {\r
+ // escape "~"" to "~0" and "/" to "~1"\r
+ replace_substring(s, "~", "~0");\r
+ replace_substring(s, "/", "~1");\r
+ return s;\r
+ }\r
+\r
+ /// unescape tilde and slash\r
+ static void unescape(std::string& s)\r
+ {\r
+ // first transform any occurrence of the sequence '~1' to '/'\r
+ replace_substring(s, "~1", "/");\r
+ // then transform any occurrence of the sequence '~0' to '~'\r
+ replace_substring(s, "~0", "~");\r
+ }\r
+\r
+ /*!\r
+ @param[in] reference_string the reference string to the current value\r
+ @param[in] value the value to consider\r
+ @param[in,out] result the result object to insert values to\r
+\r
+ @note Empty objects or arrays are flattened to `null`.\r
+ */\r
+ static void flatten(const std::string& reference_string,\r
+ const basic_json& value,\r
+ basic_json& result)\r
+ {\r
+ switch (value.m_type)\r
+ {\r
+ case value_t::array:\r
+ {\r
+ if (value.m_value.array->empty())\r
+ {\r
+ // flatten empty array as null\r
+ result[reference_string] = nullptr;\r
+ }\r
+ else\r
+ {\r
+ // iterate array and use index as reference string\r
+ for (size_t i = 0; i < value.m_value.array->size(); ++i)\r
+ {\r
+ flatten(reference_string + "/" + std::to_string(i),\r
+ value.m_value.array->operator[](i), result);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ if (value.m_value.object->empty())\r
+ {\r
+ // flatten empty object as null\r
+ result[reference_string] = nullptr;\r
+ }\r
+ else\r
+ {\r
+ // iterate object and use keys as reference string\r
+ for (const auto& element : *value.m_value.object)\r
+ {\r
+ flatten(reference_string + "/" + escape(element.first),\r
+ element.second, result);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ // add primitive value with its reference string\r
+ result[reference_string] = value;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*!\r
+ @param[in] value flattened JSON\r
+\r
+ @return unflattened JSON\r
+ */\r
+ static basic_json unflatten(const basic_json& value)\r
+ {\r
+ if (not value.is_object())\r
+ {\r
+ JSON_THROW(std::domain_error("only objects can be unflattened"));\r
+ }\r
+\r
+ basic_json result;\r
+\r
+ // iterate the JSON object values\r
+ for (const auto& element : *value.m_value.object)\r
+ {\r
+ if (not element.second.is_primitive())\r
+ {\r
+ JSON_THROW(std::domain_error("values in object must be primitive"));\r
+ }\r
+\r
+ // assign value to reference pointed to by JSON pointer; Note\r
+ // that if the JSON pointer is "" (i.e., points to the whole\r
+ // value), function get_and_create returns a reference to\r
+ // result itself. An assignment will then create a primitive\r
+ // value.\r
+ json_pointer(element.first).get_and_create(result) = element.second;\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ private:\r
+ friend bool operator==(json_pointer const& lhs,\r
+ json_pointer const& rhs) noexcept\r
+ {\r
+ return lhs.reference_tokens == rhs.reference_tokens;\r
+ }\r
+\r
+ friend bool operator!=(json_pointer const& lhs,\r
+ json_pointer const& rhs) noexcept\r
+ {\r
+ return !(lhs == rhs);\r
+ }\r
+\r
+ /// the reference tokens\r
+ std::vector<std::string> reference_tokens {};\r
+ };\r
+\r
+ //////////////////////////\r
+ // JSON Pointer support //\r
+ //////////////////////////\r
+\r
+ /// @name JSON Pointer functions\r
+ /// @{\r
+\r
+ /*!\r
+ @brief access specified element via JSON Pointer\r
+\r
+ Uses a JSON pointer to retrieve a reference to the respective JSON value.\r
+ No bound checking is performed. Similar to @ref operator[](const typename\r
+ object_t::key_type&), `null` values are created in arrays and objects if\r
+ necessary.\r
+\r
+ In particular:\r
+ - If the JSON pointer points to an object key that does not exist, it\r
+ is created an filled with a `null` value before a reference to it\r
+ is returned.\r
+ - If the JSON pointer points to an array index that does not exist, it\r
+ is created an filled with a `null` value before a reference to it\r
+ is returned. All indices between the current maximum and the given\r
+ index are also filled with `null`.\r
+ - The special value `-` is treated as a synonym for the index past the\r
+ end.\r
+\r
+ @param[in] ptr a JSON pointer\r
+\r
+ @return reference to the element pointed to by @a ptr\r
+\r
+ @complexity Constant.\r
+\r
+ @throw std::out_of_range if the JSON pointer can not be resolved\r
+ @throw std::domain_error if an array index begins with '0'\r
+ @throw std::invalid_argument if an array index was not a number\r
+\r
+ @liveexample{The behavior is shown in the example.,operatorjson_pointer}\r
+\r
+ @since version 2.0.0\r
+ */\r
+ reference operator[](const json_pointer& ptr)\r
+ {\r
+ return ptr.get_unchecked(this);\r
+ }\r
+\r
+ /*!\r
+ @brief access specified element via JSON Pointer\r
+\r
+ Uses a JSON pointer to retrieve a reference to the respective JSON value.\r
+ No bound checking is performed. The function does not change the JSON\r
+ value; no `null` values are created. In particular, the the special value\r
+ `-` yields an exception.\r
+\r
+ @param[in] ptr JSON pointer to the desired element\r
+\r
+ @return const reference to the element pointed to by @a ptr\r
+\r
+ @complexity Constant.\r
+\r
+ @throw std::out_of_range if the JSON pointer can not be resolved\r
+ @throw std::domain_error if an array index begins with '0'\r
+ @throw std::invalid_argument if an array index was not a number\r
+\r
+ @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}\r
+\r
+ @since version 2.0.0\r
+ */\r
+ const_reference operator[](const json_pointer& ptr) const\r
+ {\r
+ return ptr.get_unchecked(this);\r
+ }\r
+\r
+ /*!\r
+ @brief access specified element via JSON Pointer\r
+\r
+ Returns a reference to the element at with specified JSON pointer @a ptr,\r
+ with bounds checking.\r
+\r
+ @param[in] ptr JSON pointer to the desired element\r
+\r
+ @return reference to the element pointed to by @a ptr\r
+\r
+ @complexity Constant.\r
+\r
+ @throw std::out_of_range if the JSON pointer can not be resolved\r
+ @throw std::domain_error if an array index begins with '0'\r
+ @throw std::invalid_argument if an array index was not a number\r
+\r
+ @liveexample{The behavior is shown in the example.,at_json_pointer}\r
+\r
+ @since version 2.0.0\r
+ */\r
+ reference at(const json_pointer& ptr)\r
+ {\r
+ return ptr.get_checked(this);\r
+ }\r
+\r
+ /*!\r
+ @brief access specified element via JSON Pointer\r
+\r
+ Returns a const reference to the element at with specified JSON pointer @a\r
+ ptr, with bounds checking.\r
+\r
+ @param[in] ptr JSON pointer to the desired element\r
+\r
+ @return reference to the element pointed to by @a ptr\r
+\r
+ @complexity Constant.\r
+\r
+ @throw std::out_of_range if the JSON pointer can not be resolved\r
+ @throw std::domain_error if an array index begins with '0'\r
+ @throw std::invalid_argument if an array index was not a number\r
+\r
+ @liveexample{The behavior is shown in the example.,at_json_pointer_const}\r
+\r
+ @since version 2.0.0\r
+ */\r
+ const_reference at(const json_pointer& ptr) const\r
+ {\r
+ return ptr.get_checked(this);\r
+ }\r
+\r
+ /*!\r
+ @brief return flattened JSON value\r
+\r
+ The function creates a JSON object whose keys are JSON pointers (see [RFC\r
+ 6901](https://tools.ietf.org/html/rfc6901)) and whose values are all\r
+ primitive. The original JSON value can be restored using the @ref\r
+ unflatten() function.\r
+\r
+ @return an object that maps JSON pointers to primitive values\r
+\r
+ @note Empty objects and arrays are flattened to `null` and will not be\r
+ reconstructed correctly by the @ref unflatten() function.\r
+\r
+ @complexity Linear in the size the JSON value.\r
+\r
+ @liveexample{The following code shows how a JSON object is flattened to an\r
+ object whose keys consist of JSON pointers.,flatten}\r
+\r
+ @sa @ref unflatten() for the reverse function\r
+\r
+ @since version 2.0.0\r
+ */\r
+ basic_json flatten() const\r
+ {\r
+ basic_json result(value_t::object);\r
+ json_pointer::flatten("", *this, result);\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief unflatten a previously flattened JSON value\r
+\r
+ The function restores the arbitrary nesting of a JSON value that has been\r
+ flattened before using the @ref flatten() function. The JSON value must\r
+ meet certain constraints:\r
+ 1. The value must be an object.\r
+ 2. The keys must be JSON pointers (see\r
+ [RFC 6901](https://tools.ietf.org/html/rfc6901))\r
+ 3. The mapped values must be primitive JSON types.\r
+\r
+ @return the original JSON from a flattened version\r
+\r
+ @note Empty objects and arrays are flattened by @ref flatten() to `null`\r
+ values and can not unflattened to their original type. Apart from\r
+ this example, for a JSON value `j`, the following is always true:\r
+ `j == j.flatten().unflatten()`.\r
+\r
+ @complexity Linear in the size the JSON value.\r
+\r
+ @liveexample{The following code shows how a flattened JSON object is\r
+ unflattened into the original nested JSON object.,unflatten}\r
+\r
+ @sa @ref flatten() for the reverse function\r
+\r
+ @since version 2.0.0\r
+ */\r
+ basic_json unflatten() const\r
+ {\r
+ return json_pointer::unflatten(*this);\r
+ }\r
+\r
+ /// @}\r
+\r
+ //////////////////////////\r
+ // JSON Patch functions //\r
+ //////////////////////////\r
+\r
+ /// @name JSON Patch functions\r
+ /// @{\r
+\r
+ /*!\r
+ @brief applies a JSON patch\r
+\r
+ [JSON Patch](http://jsonpatch.com) defines a JSON document structure for\r
+ expressing a sequence of operations to apply to a JSON) document. With\r
+ this function, a JSON Patch is applied to the current JSON value by\r
+ executing all operations from the patch.\r
+\r
+ @param[in] json_patch JSON patch document\r
+ @return patched document\r
+\r
+ @note The application of a patch is atomic: Either all operations succeed\r
+ and the patched document is returned or an exception is thrown. In\r
+ any case, the original value is not changed: the patch is applied\r
+ to a copy of the value.\r
+\r
+ @throw std::out_of_range if a JSON pointer inside the patch could not\r
+ be resolved successfully in the current JSON value; example: `"key baz\r
+ not found"`\r
+ @throw invalid_argument if the JSON patch is malformed (e.g., mandatory\r
+ attributes are missing); example: `"operation add must have member path"`\r
+\r
+ @complexity Linear in the size of the JSON value and the length of the\r
+ JSON patch. As usually only a fraction of the JSON value is affected by\r
+ the patch, the complexity can usually be neglected.\r
+\r
+ @liveexample{The following code shows how a JSON patch is applied to a\r
+ value.,patch}\r
+\r
+ @sa @ref diff -- create a JSON patch by comparing two JSON values\r
+\r
+ @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)\r
+ @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)\r
+\r
+ @since version 2.0.0\r
+ */\r
+ basic_json patch(const basic_json& json_patch) const\r
+ {\r
+ // make a working copy to apply the patch to\r
+ basic_json result = *this;\r
+\r
+ // the valid JSON Patch operations\r
+ enum class patch_operations {add, remove, replace, move, copy, test, invalid};\r
+\r
+ const auto get_op = [](const std::string op)\r
+ {\r
+ if (op == "add")\r
+ {\r
+ return patch_operations::add;\r
+ }\r
+ if (op == "remove")\r
+ {\r
+ return patch_operations::remove;\r
+ }\r
+ if (op == "replace")\r
+ {\r
+ return patch_operations::replace;\r
+ }\r
+ if (op == "move")\r
+ {\r
+ return patch_operations::move;\r
+ }\r
+ if (op == "copy")\r
+ {\r
+ return patch_operations::copy;\r
+ }\r
+ if (op == "test")\r
+ {\r
+ return patch_operations::test;\r
+ }\r
+\r
+ return patch_operations::invalid;\r
+ };\r
+\r
+ // wrapper for "add" operation; add value at ptr\r
+ const auto operation_add = [&result](json_pointer & ptr, basic_json val)\r
+ {\r
+ // adding to the root of the target document means replacing it\r
+ if (ptr.is_root())\r
+ {\r
+ result = val;\r
+ }\r
+ else\r
+ {\r
+ // make sure the top element of the pointer exists\r
+ json_pointer top_pointer = ptr.top();\r
+ if (top_pointer != ptr)\r
+ {\r
+ result.at(top_pointer);\r
+ }\r
+\r
+ // get reference to parent of JSON pointer ptr\r
+ const auto last_path = ptr.pop_back();\r
+ basic_json& parent = result[ptr];\r
+\r
+ switch (parent.m_type)\r
+ {\r
+ case value_t::null:\r
+ case value_t::object:\r
+ {\r
+ // use operator[] to add value\r
+ parent[last_path] = val;\r
+ break;\r
+ }\r
+\r
+ case value_t::array:\r
+ {\r
+ if (last_path == "-")\r
+ {\r
+ // special case: append to back\r
+ parent.push_back(val);\r
+ }\r
+ else\r
+ {\r
+ const auto idx = std::stoi(last_path);\r
+ if (static_cast<size_type>(idx) > parent.size())\r
+ {\r
+ // avoid undefined behavior\r
+ JSON_THROW(std::out_of_range("array index " + std::to_string(idx) + " is out of range"));\r
+ }\r
+ else\r
+ {\r
+ // default case: insert add offset\r
+ parent.insert(parent.begin() + static_cast<difference_type>(idx), val);\r
+ }\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ // if there exists a parent it cannot be primitive\r
+ assert(false); // LCOV_EXCL_LINE\r
+ }\r
+ }\r
+ }\r
+ };\r
+\r
+ // wrapper for "remove" operation; remove value at ptr\r
+ const auto operation_remove = [&result](json_pointer & ptr)\r
+ {\r
+ // get reference to parent of JSON pointer ptr\r
+ const auto last_path = ptr.pop_back();\r
+ basic_json& parent = result.at(ptr);\r
+\r
+ // remove child\r
+ if (parent.is_object())\r
+ {\r
+ // perform range check\r
+ auto it = parent.find(last_path);\r
+ if (it != parent.end())\r
+ {\r
+ parent.erase(it);\r
+ }\r
+ else\r
+ {\r
+ JSON_THROW(std::out_of_range("key '" + last_path + "' not found"));\r
+ }\r
+ }\r
+ else if (parent.is_array())\r
+ {\r
+ // note erase performs range check\r
+ parent.erase(static_cast<size_type>(std::stoi(last_path)));\r
+ }\r
+ };\r
+\r
+ // type check\r
+ if (not json_patch.is_array())\r
+ {\r
+ // a JSON patch must be an array of objects\r
+ JSON_THROW(std::invalid_argument("JSON patch must be an array of objects"));\r
+ }\r
+\r
+ // iterate and apply the operations\r
+ for (const auto& val : json_patch)\r
+ {\r
+ // wrapper to get a value for an operation\r
+ const auto get_value = [&val](const std::string & op,\r
+ const std::string & member,\r
+ bool string_type) -> basic_json&\r
+ {\r
+ // find value\r
+ auto it = val.m_value.object->find(member);\r
+\r
+ // context-sensitive error message\r
+ const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";\r
+\r
+ // check if desired value is present\r
+ if (it == val.m_value.object->end())\r
+ {\r
+ JSON_THROW(std::invalid_argument(error_msg + " must have member '" + member + "'"));\r
+ }\r
+\r
+ // check if result is of type string\r
+ if (string_type and not it->second.is_string())\r
+ {\r
+ JSON_THROW(std::invalid_argument(error_msg + " must have string member '" + member + "'"));\r
+ }\r
+\r
+ // no error: return value\r
+ return it->second;\r
+ };\r
+\r
+ // type check\r
+ if (not val.is_object())\r
+ {\r
+ JSON_THROW(std::invalid_argument("JSON patch must be an array of objects"));\r
+ }\r
+\r
+ // collect mandatory members\r
+ const std::string op = get_value("op", "op", true);\r
+ const std::string path = get_value(op, "path", true);\r
+ json_pointer ptr(path);\r
+\r
+ switch (get_op(op))\r
+ {\r
+ case patch_operations::add:\r
+ {\r
+ operation_add(ptr, get_value("add", "value", false));\r
+ break;\r
+ }\r
+\r
+ case patch_operations::remove:\r
+ {\r
+ operation_remove(ptr);\r
+ break;\r
+ }\r
+\r
+ case patch_operations::replace:\r
+ {\r
+ // the "path" location must exist - use at()\r
+ result.at(ptr) = get_value("replace", "value", false);\r
+ break;\r
+ }\r
+\r
+ case patch_operations::move:\r
+ {\r
+ const std::string from_path = get_value("move", "from", true);\r
+ json_pointer from_ptr(from_path);\r
+\r
+ // the "from" location must exist - use at()\r
+ basic_json v = result.at(from_ptr);\r
+\r
+ // The move operation is functionally identical to a\r
+ // "remove" operation on the "from" location, followed\r
+ // immediately by an "add" operation at the target\r
+ // location with the value that was just removed.\r
+ operation_remove(from_ptr);\r
+ operation_add(ptr, v);\r
+ break;\r
+ }\r
+\r
+ case patch_operations::copy:\r
+ {\r
+ const std::string from_path = get_value("copy", "from", true);;\r
+ const json_pointer from_ptr(from_path);\r
+\r
+ // the "from" location must exist - use at()\r
+ result[ptr] = result.at(from_ptr);\r
+ break;\r
+ }\r
+\r
+ case patch_operations::test:\r
+ {\r
+ bool success = false;\r
+ JSON_TRY\r
+ {\r
+ // check if "value" matches the one at "path"\r
+ // the "path" location must exist - use at()\r
+ success = (result.at(ptr) == get_value("test", "value", false));\r
+ }\r
+ JSON_CATCH (std::out_of_range&)\r
+ {\r
+ // ignore out of range errors: success remains false\r
+ }\r
+\r
+ // throw an exception if test fails\r
+ if (not success)\r
+ {\r
+ JSON_THROW(std::domain_error("unsuccessful: " + val.dump()));\r
+ }\r
+\r
+ break;\r
+ }\r
+\r
+ case patch_operations::invalid:\r
+ {\r
+ // op must be "add", "remove", "replace", "move", "copy", or\r
+ // "test"\r
+ JSON_THROW(std::invalid_argument("operation value '" + op + "' is invalid"));\r
+ }\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /*!\r
+ @brief creates a diff as a JSON patch\r
+\r
+ Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can\r
+ be changed into the value @a target by calling @ref patch function.\r
+\r
+ @invariant For two JSON values @a source and @a target, the following code\r
+ yields always `true`:\r
+ @code {.cpp}\r
+ source.patch(diff(source, target)) == target;\r
+ @endcode\r
+\r
+ @note Currently, only `remove`, `add`, and `replace` operations are\r
+ generated.\r
+\r
+ @param[in] source JSON value to compare from\r
+ @param[in] target JSON value to compare against\r
+ @param[in] path helper value to create JSON pointers\r
+\r
+ @return a JSON patch to convert the @a source to @a target\r
+\r
+ @complexity Linear in the lengths of @a source and @a target.\r
+\r
+ @liveexample{The following code shows how a JSON patch is created as a\r
+ diff for two JSON values.,diff}\r
+\r
+ @sa @ref patch -- apply a JSON patch\r
+\r
+ @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)\r
+\r
+ @since version 2.0.0\r
+ */\r
+ static basic_json diff(const basic_json& source,\r
+ const basic_json& target,\r
+ const std::string& path = "")\r
+ {\r
+ // the patch\r
+ basic_json result(value_t::array);\r
+\r
+ // if the values are the same, return empty patch\r
+ if (source == target)\r
+ {\r
+ return result;\r
+ }\r
+\r
+ if (source.type() != target.type())\r
+ {\r
+ // different types: replace value\r
+ result.push_back(\r
+ {\r
+ {"op", "replace"},\r
+ {"path", path},\r
+ {"value", target}\r
+ });\r
+ }\r
+ else\r
+ {\r
+ switch (source.type())\r
+ {\r
+ case value_t::array:\r
+ {\r
+ // first pass: traverse common elements\r
+ size_t i = 0;\r
+ while (i < source.size() and i < target.size())\r
+ {\r
+ // recursive call to compare array values at index i\r
+ auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));\r
+ result.insert(result.end(), temp_diff.begin(), temp_diff.end());\r
+ ++i;\r
+ }\r
+\r
+ // i now reached the end of at least one array\r
+ // in a second pass, traverse the remaining elements\r
+\r
+ // remove my remaining elements\r
+ const auto end_index = static_cast<difference_type>(result.size());\r
+ while (i < source.size())\r
+ {\r
+ // add operations in reverse order to avoid invalid\r
+ // indices\r
+ result.insert(result.begin() + end_index, object(\r
+ {\r
+ {"op", "remove"},\r
+ {"path", path + "/" + std::to_string(i)}\r
+ }));\r
+ ++i;\r
+ }\r
+\r
+ // add other remaining elements\r
+ while (i < target.size())\r
+ {\r
+ result.push_back(\r
+ {\r
+ {"op", "add"},\r
+ {"path", path + "/" + std::to_string(i)},\r
+ {"value", target[i]}\r
+ });\r
+ ++i;\r
+ }\r
+\r
+ break;\r
+ }\r
+\r
+ case value_t::object:\r
+ {\r
+ // first pass: traverse this object's elements\r
+ for (auto it = source.begin(); it != source.end(); ++it)\r
+ {\r
+ // escape the key name to be used in a JSON patch\r
+ const auto key = json_pointer::escape(it.key());\r
+\r
+ if (target.find(it.key()) != target.end())\r
+ {\r
+ // recursive call to compare object values at key it\r
+ auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);\r
+ result.insert(result.end(), temp_diff.begin(), temp_diff.end());\r
+ }\r
+ else\r
+ {\r
+ // found a key that is not in o -> remove it\r
+ result.push_back(object(\r
+ {\r
+ {"op", "remove"},\r
+ {"path", path + "/" + key}\r
+ }));\r
+ }\r
+ }\r
+\r
+ // second pass: traverse other object's elements\r
+ for (auto it = target.begin(); it != target.end(); ++it)\r
+ {\r
+ if (source.find(it.key()) == source.end())\r
+ {\r
+ // found a key that is not in this -> add it\r
+ const auto key = json_pointer::escape(it.key());\r
+ result.push_back(\r
+ {\r
+ {"op", "add"},\r
+ {"path", path + "/" + key},\r
+ {"value", it.value()}\r
+ });\r
+ }\r
+ }\r
+\r
+ break;\r
+ }\r
+\r
+ default:\r
+ {\r
+ // both primitive type: replace value\r
+ result.push_back(\r
+ {\r
+ {"op", "replace"},\r
+ {"path", path},\r
+ {"value", target}\r
+ });\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ return result;\r
+ }\r
+\r
+ /// @}\r
+};\r
+\r
+/////////////\r
+// presets //\r
+/////////////\r
+\r
+/*!\r
+@brief default JSON class\r
+\r
+This type is the default specialization of the @ref basic_json class which\r
+uses the standard template types.\r
+\r
+@since version 1.0.0\r
+*/\r
+using json = basic_json<>;\r
+} // namespace nlohmann\r
+\r
+\r
+///////////////////////\r
+// nonmember support //\r
+///////////////////////\r
+\r
+// specialization of std::swap, and std::hash\r
+namespace std\r
+{\r
+/*!\r
+@brief exchanges the values of two JSON objects\r
+\r
+@since version 1.0.0\r
+*/\r
+template<>\r
+inline void swap(nlohmann::json& j1,\r
+ nlohmann::json& j2) noexcept(\r
+ is_nothrow_move_constructible<nlohmann::json>::value and\r
+ is_nothrow_move_assignable<nlohmann::json>::value\r
+ )\r
+{\r
+ j1.swap(j2);\r
+}\r
+\r
+/// hash value for JSON objects\r
+template<>\r
+struct hash<nlohmann::json>\r
+{\r
+ /*!\r
+ @brief return a hash value for a JSON object\r
+\r
+ @since version 1.0.0\r
+ */\r
+ std::size_t operator()(const nlohmann::json& j) const\r
+ {\r
+ // a naive hashing via the string representation\r
+ const auto& h = hash<nlohmann::json::string_t>();\r
+ return h(j.dump());\r
+ }\r
+};\r
+} // namespace std\r
+\r
+/*!\r
+@brief user-defined string literal for JSON values\r
+\r
+This operator implements a user-defined string literal for JSON objects. It\r
+can be used by adding `"_json"` to a string literal and returns a JSON object\r
+if no parse error occurred.\r
+\r
+@param[in] s a string representation of a JSON object\r
+@param[in] n the length of string @a s\r
+@return a JSON object\r
+\r
+@since version 1.0.0\r
+*/\r
+inline nlohmann::json operator "" _json(const char* s, std::size_t n)\r
+{\r
+ return nlohmann::json::parse(s, s + n);\r
+}\r
+\r
+/*!\r
+@brief user-defined string literal for JSON pointer\r
+\r
+This operator implements a user-defined string literal for JSON Pointers. It\r
+can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer\r
+object if no parse error occurred.\r
+\r
+@param[in] s a string representation of a JSON Pointer\r
+@param[in] n the length of string @a s\r
+@return a JSON pointer object\r
+\r
+@since version 2.0.0\r
+*/\r
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)\r
+{\r
+ return nlohmann::json::json_pointer(std::string(s, n));\r
+}\r
+\r
+// clean up\r
+#undef JSON_CATCH\r
+#undef JSON_DEPRECATED\r
+#undef JSON_THROW\r
+#undef JSON_TRY\r
+\r
+#endif\r