Lines Matching defs:std
280 using value_t = std::false_type;
287 using value_t = std::true_type;
307 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
311 std::is_convertible<detected_t<Op, Args...>, To>;
1541 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
2420 // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
2513 #define JSON_THROW(exception) std::abort()
2561 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2562 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2563 auto it = std::find_if(std::begin(m), std::end(m), \
2564 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2568 j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2573 static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2574 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2575 auto it = std::find_if(std::begin(m), std::end(m), \
2576 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2580 e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2765 // allows to call any std function as if (e.g. with begin):
2766 // using std::begin; begin(x);
2772 using std::std_name; \
2775 using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
2787 using result_of_##std_name = decltype(std_name(std::declval<T>()...)); \
2856 enum class value_t : std::uint8_t
2884 inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
2889 static constexpr std::array<std::uint8_t, 9> order = {{
2896 const auto l_index = static_cast<std::size_t>(lhs);
2897 const auto r_index = static_cast<std::size_t>(rhs);
2903 return std::partial_ordering::unordered;
2916 return std::is_lt(lhs <=> rhs); // *NOPAD*
3022 std::size_t chars_read_total = 0;
3024 std::size_t chars_read_current_line = 0;
3026 std::size_t lines_read = 0;
3065 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
3070 using std::enable_if_t;
3071 using std::index_sequence;
3072 using std::make_index_sequence;
3073 using std::index_sequence_for;
3079 using enable_if_t = typename std::enable_if<B, T>::type;
3092 // to be a drop-in replacement for C++14's `std::integer_sequence`.
3109 static constexpr std::size_t size() noexcept
3119 // `std::index_sequence`.
3165 // replacement for C++14's `std::make_integer_sequence`.
3173 // `std::make_index_sequence`.
3181 // `std::index_sequence_for()`
3206 inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
3208 return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
3270 // This is required as some compilers implement std::iterator_traits in a way that
3278 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
3284 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
3286 using iterator_category = std::random_access_iterator_tag;
3383 std::map,
3384 template<typename U, typename... Args> class ArrayType = std::vector,
3385 class StringType = std::string, class BooleanType = bool,
3386 class NumberIntegerType = std::int64_t,
3387 class NumberUnsignedType = std::uint64_t,
3389 template<typename U> class AllocatorType = std::allocator,
3392 class BinaryType = std::vector<std::uint8_t>>
3440 // (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
3445 template<typename> struct is_basic_json : std::false_type {};
3448 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
3451 // true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
3455 std::integral_constant < bool,
3456 is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
3457 || std::is_same<BasicJsonContext, std::nullptr_t>::value >
3468 struct is_json_ref : std::false_type {};
3471 struct is_json_ref<json_ref<T>> : std::true_type {};
3499 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3502 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3505 using get_template_function = decltype(std::declval<T>().template get<U>());
3509 struct has_from_json : std::false_type {};
3512 // use this trait instead of std::is_constructible or std::is_convertible,
3534 struct has_non_default_from_json : std::false_type {};
3549 struct has_to_json : std::false_type {};
3565 struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
3573 using type = typename std::conditional < has_key_compare<object_t>::value,
3585 template<class...> struct conjunction : std::true_type { };
3589 : std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
3592 template<class B> struct negation : std::integral_constant < bool, !B::value > { };
3595 // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
3598 struct is_default_constructible : std::is_default_constructible<T> {};
3601 struct is_default_constructible<std::pair<T1, T2>>
3605 struct is_default_constructible<const std::pair<T1, T2>>
3609 struct is_default_constructible<std::tuple<Ts...>>
3613 struct is_default_constructible<const std::tuple<Ts...>>
3618 struct is_constructible : std::is_constructible<T, Args...> {};
3621 struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
3624 struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3627 struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
3630 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
3634 struct is_iterator_traits : std::false_type {};
3655 using t_ref = typename std::add_lvalue_reference<T>::type;
3667 static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
3671 using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
3681 struct is_complete_type : std::false_type {};
3684 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3688 struct is_compatible_object_type_impl : std::false_type {};
3712 struct is_constructible_object_type_impl : std::false_type {};
3724 (std::is_move_assignable<ConstructibleObjectType>::value ||
3725 std::is_copy_assignable<ConstructibleObjectType>::value) &&
3728 std::is_same <
3755 using laundered_type = decltype(std::declval<ConstructibleStringType>());
3768 struct is_compatible_array_type_impl : std::false_type {};
3776 // special case for types like std::filesystem::path whose iterator's value_type are themselves
3778 !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
3790 struct is_constructible_array_type_impl : std::false_type {};
3795 enable_if_t<std::is_same<ConstructibleArrayType,
3797 : std::true_type {};
3802 enable_if_t < !std::is_same<ConstructibleArrayType,
3806 (std::is_move_assignable<ConstructibleArrayType>::value ||
3807 std::is_copy_assignable<ConstructibleArrayType>::value)&&
3811 // special case for types like std::filesystem::path whose iterator's value_type are themselves
3813 !std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
3820 std::is_same<value_type,
3835 struct is_compatible_integer_type_impl : std::false_type {};
3840 enable_if_t < std::is_integral<RealIntegerType>::value&&
3841 std::is_integral<CompatibleNumberIntegerType>::value&&
3842 !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3845 using RealLimits = std::numeric_limits<RealIntegerType>;
3846 using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3861 struct is_compatible_type_impl: std::false_type {};
3877 struct is_constructible_tuple : std::false_type {};
3880 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
3883 struct is_json_iterator_of : std::false_type {};
3886 struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
3889 struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
3894 struct is_specialization_of : std::false_type {};
3897 struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
3904 struct is_comparable : std::false_type {};
3908 decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
3909 decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
3910 >> : std::true_type {};
3919 using is_usable_as_key_type = typename std::conditional <
3921 && !(ExcludeObjectKeyType && std::is_same<KeyType,
3926 std::true_type,
3927 std::false_type >::type;
3937 using is_usable_as_basic_json_key_type = typename std::conditional <
3942 std::true_type,
3943 std::false_type >::type;
3946 using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
3950 using has_erase_with_key_type = typename std::conditional <
3954 std::true_type,
3955 std::false_type >::type;
3958 // ordered_map inherits capacity() from std::vector)
3976 template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
3982 template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
3989 using all_integral = conjunction<std::is_integral<Types>...>;
3992 using all_signed = conjunction<std::is_signed<Types>...>;
3995 using all_unsigned = conjunction<std::is_unsigned<Types>...>;
3999 using same_sign = std::integral_constant < bool,
4003 using never_out_of_range = std::integral_constant < bool,
4004 (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
4008 bool OfTypeSigned = std::is_signed<OfType>::value,
4009 bool TSigned = std::is_signed<T>::value>
4017 using CommonType = typename std::common_type<OfType, T>::type;
4018 return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4027 using CommonType = typename std::common_type<OfType, T>::type;
4028 return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4037 using CommonType = typename std::common_type<OfType, T>::type;
4038 return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4048 using CommonType = typename std::common_type<OfType, T>::type;
4049 return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
4050 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
4084 using bool_constant = std::integral_constant<bool, Value>;
4096 using TUnExt = typename std::remove_extent<T>::type;
4097 using TUnCVExt = typename std::remove_cv<TUnExt>::type;
4098 using TUnPtr = typename std::remove_pointer<T>::type;
4099 using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
4101 (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
4102 || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
4162 inline std::size_t concat_length()
4168 inline std::size_t concat_length(const char* cstr, Args&& ... rest);
4171 inline std::size_t concat_length(const StringType& str, Args&& ... rest);
4174 inline std::size_t concat_length(const char /*c*/, Args&& ... rest)
4176 return 1 + concat_length(std::forward<Args>(rest)...);
4180 inline std::size_t concat_length(const char* cstr, Args&& ... rest)
4183 return ::strlen(cstr) + concat_length(std::forward<Args>(rest)...);
4187 inline std::size_t concat_length(const StringType& str, Args&& ... rest)
4189 return str.size() + concat_length(std::forward<Args>(rest)...);
4197 using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
4203 using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
4209 using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
4215 using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
4242 out.append(std::forward<Arg>(arg));
4243 concat_into(out, std::forward<Args>(rest)...);
4251 out += std::forward<Arg>(arg);
4252 concat_into(out, std::forward<Args>(rest)...);
4262 concat_into(out, std::forward<Args>(rest)...);
4273 concat_into(out, std::forward<Args>(rest)...);
4276 template<typename OutStringType = std::string, typename... Args>
4280 str.reserve(concat_length(std::forward<Args>(args)...));
4281 concat_into(str, std::forward<Args>(args)...);
4300 class exception : public std::exception
4316 static std::string name(const std::string& ename, int id_)
4318 return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
4321 static std::string diagnostics(std::nullptr_t /*leaf_element*/)
4327 static std::string diagnostics(const BasicJsonType* leaf_element)
4330 std::vector<std::string> tokens;
4337 for (std::size_t i = 0; i < current->m_parent->m_value.array->size(); ++i)
4341 tokens.emplace_back(std::to_string(i));
4379 auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
4380 [](const std::string & a, const std::string & b)
4393 std::runtime_error m;
4411 static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
4413 std::string w = concat(exception::name("parse_error", id_), "parse error",
4419 static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
4421 std::string w = concat(exception::name("parse_error", id_), "parse error",
4422 (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
4436 const std::size_t byte;
4439 parse_error(int id_, std::size_t byte_, const char* what_arg)
4442 static std::string position_string(const position_t& pos)
4444 return concat(" at line ", std::to_string(pos.lines_read + 1),
4445 ", column ", std::to_string(pos.chars_read_current_line));
4455 static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
4457 std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
4473 static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4475 std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
4490 static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
4492 std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
4507 static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4509 std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
4568 namespace std_fs = std::experimental::filesystem;
4576 namespace std_fs = std::filesystem;
4593 inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
4604 enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
4605 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4662 std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
4664 && !std::is_same<typename BasicJsonType::string_t, StringType>::value
4696 enable_if_t<std::is_enum<EnumType>::value, int> = 0>
4699 typename std::underlying_type<EnumType>::type val;
4708 inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
4715 std::transform(j.rbegin(), j.rend(),
4716 std::front_inserter(l), [](const BasicJsonType & i)
4725 inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
4732 std::transform(j.begin(), j.end(), std::begin(l),
4739 template<typename BasicJsonType, typename T, std::size_t N>
4743 for (std::size_t i = 0; i < N; ++i)
4755 template<typename BasicJsonType, typename T, std::size_t N>
4756 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
4760 for (std::size_t i = 0; i < N; ++i)
4768 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4772 arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
4776 using std::end;
4780 std::transform(j.begin(), j.end(),
4781 std::inserter(ret, end(ret)), [](const BasicJsonType & i)
4787 arr = std::move(ret);
4792 std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
4797 using std::end;
4800 std::transform(
4801 j.begin(), j.end(), std::inserter(ret, end(ret)),
4808 arr = std::move(ret);
4816 !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
4832 template < typename BasicJsonType, typename T, std::size_t... Idx >
4833 std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
4834 identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
4836 return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
4839 template < typename BasicJsonType, typename T, std::size_t N >
4840 auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
4841 -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
4848 return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
4874 std::transform(
4876 std::inserter(ret, ret.begin()),
4881 obj = std::move(ret);
4890 std::is_arithmetic<ArithmeticType>::value&&
4891 !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
4892 !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
4893 !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
4894 !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
4932 template<typename BasicJsonType, typename... Args, std::size_t... Idx>
4933 std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
4935 return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
4939 std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
4941 return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
4942 std::forward<BasicJsonType>(j).at(1).template get<A2>()};
4946 inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
4948 p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
4952 std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
4954 return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4958 inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
4960 t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
4965 -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
4972 return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
4976 typename = enable_if_t < !std::is_constructible <
4978 inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4996 typename = enable_if_t < !std::is_constructible <
4998 inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
5031 noexcept(noexcept(from_json(j, std::forward<T>(val))))
5032 -> decltype(from_json(j, std::forward<T>(val)))
5034 return from_json(j, std::forward<T>(val));
5043 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
5108 void int_to_string( string_type& target, std::size_t value )
5111 using std::to_string;
5117 using difference_type = std::ptrdiff_t;
5121 using iterator_category = std::input_iterator_tag;
5122 using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
5128 std::size_t array_index = 0;
5130 mutable std::size_t array_index_last = 0;
5138 explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
5139 noexcept(std::is_nothrow_move_constructible<IteratorType>::value
5140 && std::is_nothrow_default_constructible<string_type>::value)
5141 : anchor(std::move(it))
5149 noexcept(std::is_nothrow_move_constructible<IteratorType>::value
5150 && std::is_nothrow_move_constructible<string_type>::value) = default;
5152 noexcept(std::is_nothrow_move_assignable<IteratorType>::value
5153 && std::is_nothrow_move_assignable<string_type>::value) = default;
5270 template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
5278 template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
5291 namespace std
5301 : public std::integral_constant<std::size_t, 2> {};
5303 template<std::size_t N, typename IteratorType>
5308 get<N>(std::declval <
5315 } // namespace std
5319 inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
5380 j.m_value = std::move(s);
5385 enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
5413 j.m_value = typename BasicJsonType::binary_t(std::move(b));
5475 j.m_value = std::move(arr);
5481 enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
5485 using std::begin;
5486 using std::end;
5496 static void construct(BasicJsonType& j, const std::vector<bool>& arr)
5511 enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
5512 static void construct(BasicJsonType& j, const std::valarray<T>& arr)
5520 std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
5545 j.m_value = std::move(obj);
5551 enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
5554 using std::begin;
5555 using std::end;
5570 enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
5578 ((std::is_same<std::vector<bool>::reference, BoolRef>::value
5579 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
5580 || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
5581 && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
5583 && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
5590 enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
5599 external_constructor<value_t::string>::construct(j, std::move(s));
5603 enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
5625 enable_if_t<std::is_enum<EnumType>::value, int> = 0>
5628 using underlying_type = typename std::underlying_type<EnumType>::type;
5634 inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
5644 !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
5659 enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
5660 inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
5662 external_constructor<value_t::array>::construct(j, std::move(arr));
5668 external_constructor<value_t::array>::construct(j, std::move(arr));
5681 external_constructor<value_t::object>::construct(j, std::move(obj));
5685 typename BasicJsonType, typename T, std::size_t N,
5686 enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
5694 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
5695 inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
5702 enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
5708 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
5711 j = { std::get<Idx>(t)... };
5717 to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
5731 auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
5732 -> decltype(to_json(j, std::forward<T>(val)), void())
5734 return to_json(j, std::forward<T>(val));
5742 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
5767 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
5768 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
5770 ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
5777 noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
5778 -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
5780 return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
5787 noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
5788 -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
5790 ::nlohmann::to_json(j, std::forward<TargetType>(val));
5823 using subtype_type = std::uint64_t;
5836 byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
5837 : container_type(std::move(b))
5848 byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
5849 : container_type(std::move(b))
5856 return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
5857 std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
5933 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
5942 The hash function tries to rely on std::hash where possible. Furthermore, the
5951 std::size_t hash(const BasicJsonType& j)
5958 const auto type = static_cast<std::size_t>(j.type());
5972 const auto h = std::hash<string_t> {}(element.key());
5991 const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
5997 const auto h = std::hash<bool> {}(j.template get<bool>());
6003 const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
6009 const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
6015 const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
6022 const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
6024 seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
6027 seed = combine(seed, std::hash<std::uint8_t> {}(byte));
6120 explicit file_input_adapter(std::FILE* f) noexcept
6133 std::char_traits<char>::int_type get_character() noexcept
6135 return std::fgetc(m_file);
6140 std::FILE* m_file;
6146 beginning of input. Does not support changing the underlying std::streambuf
6147 in mid-input. Maintains underlying std::istream and std::streambuf to support
6148 subsequent use of standard std::istream operations to process any input
6150 std::istream flags; any input errors (e.g., EOF) will be detected by the first
6151 subsequent call for input from the std::istream.
6164 is->clear(is->rdstate() & std::ios::eofbit);
6168 explicit input_stream_adapter(std::istream& i)
6184 // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
6185 // ensure that std::char_traits<char>::eof() and the character 0xFF do not
6187 std::char_traits<char>::int_type get_character()
6191 if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
6193 is->clear(is->rdstate() | std::ios::eofbit);
6200 std::istream* is = nullptr;
6201 std::streambuf* sb = nullptr;
6211 using char_type = typename std::iterator_traits<IteratorType>::value_type;
6214 : current(std::move(first)), end(std::move(last))
6217 typename std::char_traits<char_type>::int_type get_character()
6221 auto result = std::char_traits<char_type>::to_int_type(*current);
6222 std::advance(current, 1);
6226 return std::char_traits<char_type>::eof();
6251 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
6259 utf8_bytes[0] = std::char_traits<char>::eof();
6270 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6275 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
6276 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6281 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
6282 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6283 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6288 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
6289 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
6290 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6291 utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6297 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6309 std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
6317 utf8_bytes[0] = std::char_traits<char>::eof();
6328 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6333 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
6334 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6339 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
6340 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
6341 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
6350 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
6351 utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
6352 utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
6353 utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
6358 utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
6376 typename std::char_traits<char>::int_type get_character() noexcept
6403 std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
6406 std::size_t utf8_bytes_index = 0;
6408 std::size_t utf8_bytes_filled = 0;
6416 using char_type = typename std::iterator_traits<iterator_type>::value_type;
6421 return adapter_type(std::move(first), std::move(last));
6428 using value_type = typename std::iterator_traits<T>::value_type;
6439 using char_type = typename std::iterator_traits<iterator_type>::value_type;
6445 return adapter_type(base_adapter_type(std::move(first), std::move(last)));
6464 using std::begin;
6465 using std::end;
6472 void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
6474 using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
6492 inline file_input_adapter input_adapter(std::FILE* file)
6497 inline input_stream_adapter input_adapter(std::istream& stream)
6502 inline input_stream_adapter input_adapter(std::istream&& stream)
6508 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
6512 typename std::enable_if <
6513 std::is_pointer<CharT>::value&&
6514 !std::is_array<CharT>::value&&
6515 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
6516 sizeof(typename std::remove_pointer<CharT>::type) == 1,
6520 auto length = std::strlen(reinterpret_cast<const char*>(b));
6525 template<typename T, std::size_t N>
6538 typename std::enable_if <
6539 std::is_pointer<CharT>::value&&
6540 std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
6541 sizeof(typename std::remove_pointer<CharT>::type) == 1,
6543 span_input_adapter(CharT b, std::size_t l)
6547 typename std::enable_if<
6548 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
6555 return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
6664 virtual bool start_object(std::size_t elements) = 0;
6686 virtual bool start_array(std::size_t elements) = 0;
6701 virtual bool parse_error(std::size_t position,
6702 const std::string& last_token,
6793 handle_value(std::move(val));
6797 bool start_object(std::size_t len)
6801 if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6803 JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
6829 bool start_array(std::size_t len)
6833 if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6835 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
6852 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
6882 root = BasicJsonType(std::forward<Value>(v));
6890 ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
6896 *object_element = BasicJsonType(std::forward<Value>(v));
6903 std::vector<BasicJsonType*> ref_stack {};
6977 handle_value(std::move(val));
6981 bool start_object(std::size_t len)
6991 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
6993 JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
7052 bool start_array(std::size_t len)
7061 if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
7063 JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
7102 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
7136 std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
7148 auto value = BasicJsonType(std::forward<Value>(v));
7161 root = std::move(value);
7178 ref_stack.back()->m_value.array->emplace_back(std::move(value));
7195 *object_element = std::move(value);
7202 std::vector<BasicJsonType*> ref_stack {};
7204 std::vector<bool> keep_stack {};
7206 std::vector<bool> key_keep_stack {};
7264 bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
7279 bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
7289 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
7419 using char_int_type = typename std::char_traits<char_type>::int_type;
7425 : ia(std::move(adapter))
7518 bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
7569 case std::char_traits<char_type>::eof():
8158 case std::char_traits<char_type>::eof():
8175 case std::char_traits<char_type>::eof():
8215 f = std::strtof(str, endptr);
8221 f = std::strtod(str, endptr);
8227 f = std::strtold(str, endptr);
8554 const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
8570 const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
8601 token_type scan_literal(const char_type* literal_text, const std::size_t length,
8604 JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
8605 for (std::size_t i = 1; i < length; ++i)
8607 if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
8625 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
8633 `std::char_traits<char>::eof()` in that case. Stores the scanned characters
8653 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
8655 token_string.push_back(std::char_traits<char_type>::to_char_type(current));
8694 if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
8749 std::string get_token_string() const
8752 std::string result;
8758 std::array<char, 9> cs{{}};
8759 static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
8765 result.push_back(static_cast<std::string::value_type>(c));
8853 std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
8858 std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
8863 std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
8888 case std::char_traits<char_type>::eof():
8906 char_int_type current = std::char_traits<char_type>::eof();
8915 std::vector<char_type> token_string {};
8964 using null_function_t = decltype(std::declval<T&>().null());
8968 decltype(std::declval<T&>().boolean(std::declval<bool>()));
8972 decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
8976 decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
8979 using number_float_function_t = decltype(std::declval<T&>().number_float(
8980 std::declval<Float>(), std::declval<const String&>()));
8984 decltype(std::declval<T&>().string(std::declval<String&>()));
8988 decltype(std::declval<T&>().binary(std::declval<Binary&>()));
8992 decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
8996 decltype(std::declval<T&>().key(std::declval<String&>()));
8999 using end_object_function_t = decltype(std::declval<T&>().end_object());
9003 decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
9006 using end_array_function_t = decltype(std::declval<T&>().end_array());
9009 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
9010 std::declval<std::size_t>(), std::declval<const std::string&>(),
9011 std::declval<const Exception&>()));
9083 "Missing/invalid function: bool start_object(std::size_t)");
9089 "Missing/invalid function: bool start_array(std::size_t)");
9094 "Missing/invalid function: bool parse_error(std::size_t, const "
9095 "std::string&, const exception&)");
9150 using char_int_type = typename std::char_traits<char_type>::int_type;
9158 explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
9223 if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
9244 std::int32_t document_size{};
9245 get_number<std::int32_t, true>(input_format_t::bson, document_size);
9247 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
9269 auto out = std::back_inserter(result);
9303 exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
9306 return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
9325 exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
9329 std::uint8_t subtype{};
9330 get_number<std::uint8_t>(input_format_t::bson, subtype);
9347 const std::size_t element_type_parse_position)
9359 std::int32_t len{};
9361 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
9376 std::int32_t len{};
9378 return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
9393 std::int32_t value{};
9394 return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
9399 std::int64_t value{};
9400 return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
9405 std::array<char, 3> cr{{}};
9406 static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
9407 std::string cr_str{cr.data()};
9437 const std::size_t element_type_parse_position = chars_read;
9466 std::int32_t document_size{};
9467 get_number<std::int32_t, true>(input_format_t::bson, document_size);
9469 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
9500 case std::char_traits<char_type>::eof():
9532 std::uint8_t number{};
9538 std::uint16_t number{};
9544 std::uint32_t number{};
9550 std::uint64_t number{};
9579 return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
9583 std::uint8_t number{};
9589 std::uint16_t number{};
9595 std::uint32_t number{};
9601 std::uint64_t number{};
9702 conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
9706 std::uint8_t len{};
9707 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
9712 std::uint16_t len{};
9713 return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
9718 std::uint32_t len{};
9719 return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
9724 std::uint64_t len{};
9725 return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
9729 return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
9756 return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
9760 std::uint8_t len{};
9761 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
9766 std::uint16_t len{};
9767 return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
9772 std::uint32_t len{};
9773 return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
9778 std::uint64_t len{};
9779 return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
9783 return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
9821 std::uint8_t subtype_to_ignore{};
9827 std::uint16_t subtype_to_ignore{};
9833 std::uint32_t subtype_to_ignore{};
9839 std::uint64_t subtype_to_ignore{};
9857 std::uint8_t subtype{};
9864 std::uint16_t subtype{};
9871 std::uint32_t subtype{};
9878 std::uint64_t subtype{};
9939 return std::ldexp(mant, -24);
9942 ? std::numeric_limits<double>::infinity()
9943 : std::numeric_limits<double>::quiet_NaN();
9945 return std::ldexp(mant + 1024, exp - 25);
10025 std::uint8_t len{};
10031 std::uint16_t len{};
10037 std::uint32_t len{};
10043 std::uint64_t len{};
10121 std::uint8_t len{};
10128 std::uint16_t len{};
10135 std::uint32_t len{};
10142 std::uint64_t len{};
10171 @param[in] len the length of the array or static_cast<std::size_t>(-1) for an
10176 bool get_cbor_array(const std::size_t len,
10184 if (len != static_cast<std::size_t>(-1))
10186 for (std::size_t i = 0; i < len; ++i)
10209 @param[in] len the length of the object or static_cast<std::size_t>(-1) for an
10214 bool get_cbor_object(const std::size_t len,
10225 if (len != static_cast<std::size_t>(-1))
10227 for (std::size_t i = 0; i < len; ++i)
10275 case std::char_traits<char_type>::eof():
10426 return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
10445 return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
10527 std::uint8_t number{};
10533 std::uint16_t number{};
10539 std::uint32_t number{};
10545 std::uint64_t number{};
10551 std::int8_t number{};
10557 std::int16_t number{};
10563 std::int32_t number{};
10569 std::int64_t number{};
10575 std::uint16_t len{};
10576 return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
10581 std::uint32_t len{};
10582 return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
10587 std::uint16_t len{};
10588 return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
10593 std::uint32_t len{};
10594 return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
10630 return sax->number_integer(static_cast<std::int8_t>(current));
10699 std::uint8_t len{};
10705 std::uint16_t len{};
10711 std::uint32_t len{};
10737 auto assign_and_return_true = [&result](std::int8_t subtype)
10739 result.set_subtype(static_cast<std::uint8_t>(subtype));
10747 std::uint8_t len{};
10754 std::uint16_t len{};
10761 std::uint32_t len{};
10768 std::uint8_t len{};
10769 std::int8_t subtype{};
10778 std::uint16_t len{};
10779 std::int8_t subtype{};
10788 std::uint32_t len{};
10789 std::int8_t subtype{};
10798 std::int8_t subtype{};
10806 std::int8_t subtype{};
10814 std::int8_t subtype{};
10822 std::int8_t subtype{};
10830 std::int8_t subtype{};
10845 bool get_msgpack_array(const std::size_t len)
10852 for (std::size_t i = 0; i < len; ++i)
10867 bool get_msgpack_object(const std::size_t len)
10875 for (std::size_t i = 0; i < len; ++i)
10939 std::uint8_t len{};
10945 std::int8_t len{};
10951 std::int16_t len{};
10957 std::int32_t len{};
10963 std::int64_t len{};
10973 std::uint16_t len{};
10983 std::uint32_t len{};
10993 std::uint64_t len{};
11001 std::string message;
11018 bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
11020 std::pair<std::size_t, char_int_type> size_and_type;
11035 for (std::size_t i = 0; i < size_and_type.first; ++i)
11047 for (std::size_t i = 0; i < size_and_type.first; ++i)
11083 bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
11094 std::uint8_t number{};
11099 result = static_cast<std::size_t>(number);
11105 std::int8_t number{};
11115 result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
11121 std::int16_t number{};
11131 result = static_cast<std::size_t>(number);
11137 std::int32_t number{};
11147 result = static_cast<std::size_t>(number);
11153 std::int64_t number{};
11163 if (!value_in_range_of<std::size_t>(number))
11168 result = static_cast<std::size_t>(number);
11178 std::uint16_t number{};
11183 result = static_cast<std::size_t>(number);
11193 std::uint32_t number{};
11198 result = conditional_static_cast<std::size_t>(number);
11208 std::uint64_t number{};
11213 if (!value_in_range_of<std::size_t>(number))
11218 result = detail::conditional_static_cast<std::size_t>(number);
11232 std::vector<size_t> dim;
11282 std::string message;
11306 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
11318 && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
11377 case std::char_traits<char_type>::eof(): // EOF
11390 std::uint8_t number{};
11396 std::int8_t number{};
11402 std::int16_t number{};
11408 std::int32_t number{};
11414 std::int64_t number{};
11424 std::uint16_t number{};
11434 std::uint32_t number{};
11444 std::uint64_t number{};
11486 return std::ldexp(mant, -24);
11489 ? std::numeric_limits<double>::infinity()
11490 : std::numeric_limits<double>::quiet_NaN();
11492 return std::ldexp(mant + 1024, exp - 25);
11558 std::pair<std::size_t, char_int_type> size_and_type;
11570 auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
11599 for (std::size_t i = 0; i < size_and_type.first; ++i)
11621 for (std::size_t i = 0; i < size_and_type.first; ++i)
11632 for (std::size_t i = 0; i < size_and_type.first; ++i)
11643 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
11666 std::pair<std::size_t, char_int_type> size_and_type;
11690 for (std::size_t i = 0; i < size_and_type.first; ++i)
11705 for (std::size_t i = 0; i < size_and_type.first; ++i)
11721 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
11750 std::size_t size{};
11759 std::vector<char> number_vector;
11760 for (std::size_t i = 0; i < size; ++i)
11792 return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
11822 `std::char_traits<char_type>::eof()` in that case.
11865 std::array<std::uint8_t, sizeof(NumberType)> vec{};
11866 for (std::size_t i = 0; i < sizeof(NumberType); ++i)
11877 vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
11881 vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
11886 std::memcpy(&result, vec.data(), sizeof(NumberType));
11951 result.push_back(static_cast<std::uint8_t>(current));
11964 if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
11975 std::string get_token_string() const
11977 std::array<char, 3> cr{{}};
11978 static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
11979 return std::string{cr.data()};
11988 std::string exception_message(const input_format_t format,
11989 const std::string& detail,
11990 const std::string& context) const
11992 std::string error_msg = "syntax error while parsing ";
12025 static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
12031 char_int_type current = std::char_traits<char_type>::eof();
12034 std::size_t chars_read = 0;
12069 using bjd_type = std::pair<char_int_type, string_t>;
12080 constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
12132 enum class parse_event_t : std::uint8_t
12150 std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
12174 , m_lexer(std::move(adapter), skip_comments)
12282 std::vector<bool> states;
12295 if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
12340 if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
12366 if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
12564 std::string exception_message(const token_type expected, const std::string& context)
12566 std::string error_msg = "syntax error ";
12653 using difference_type = std::ptrdiff_t;
12659 difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
12836 using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
12846 static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
12849 static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
12850 && std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
12854 /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
12855 /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
12859 using iterator_category = std::bidirectional_iterator_tag;
12866 using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
12871 typename std::conditional<std::is_const<BasicJsonType>::value,
12961 iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
12971 iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
13171 std::advance(m_it.object_iterator, 1);
13177 std::advance(m_it.array_iterator, 1);
13222 std::advance(m_it.object_iterator, -1);
13228 std::advance(m_it.array_iterator, -1);
13254 template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
13290 template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
13373 std::advance(m_it.array_iterator, i);
13480 return *std::next(m_it.array_iterator, n);
13533 internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
13586 class json_reverse_iterator : public std::reverse_iterator<Base>
13589 using difference_type = std::ptrdiff_t;
13591 using base_iterator = std::reverse_iterator<Base>;
13657 auto key() const -> decltype(std::declval<Base>().key())
13751 return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
13770 friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
13791 push_back(std::move(token));
13797 json_pointer& operator/=(std::size_t array_idx)
13799 return *this /= std::to_string(array_idx);
13814 return json_pointer(lhs) /= std::move(token);
13819 friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
13873 reference_tokens.push_back(std::move(token));
13914 unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
13917 || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
13924 if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)())) // NOLINT(runtime/int)
14044 std::all_of(reference_token.begin(), reference_token.end(),
14047 return std::isdigit(x);
14122 "array index '-' (", std::to_string(ptr->m_value.array->size()),
14179 JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_value.array->size()), ") is out of range"), ptr));
14229 "array index '-' (", std::to_string(ptr->m_value.array->size()),
14296 for (std::size_t i = 1; i < reference_token.size(); i++)
14347 static std::vector<string_t> split(const string_t& reference_string)
14349 std::vector<string_t> result;
14368 std::size_t slash = reference_string.find_first_of('/', 1),
14384 for (std::size_t pos = reference_token.find_first_of('~');
14432 for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
14434 flatten(detail::concat(reference_string, '/', std::to_string(i)),
14526 result.reference_tokens = std::move(reference_tokens);
14550 std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
14606 std::vector<string_t> reference_tokens;
14701 : owned_value(std::move(value))
14708 json_ref(std::initializer_list<json_ref> init)
14714 enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
14716 : owned_value(std::forward<Args>(args)...)
14730 return std::move(owned_value);
14823 virtual void write_characters(const CharType* s, std::size_t length) = 0;
14835 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
14838 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
14842 explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
14852 void write_characters(const CharType* s, std::size_t length) override
14858 std::vector<CharType, AllocatorType>& v;
14867 explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
14877 void write_characters(const CharType* s, std::size_t length) override
14879 stream.write(s, static_cast<std::streamsize>(length));
14883 std::basic_ostream<CharType>& stream;
14888 template<typename CharType, typename StringType = std::basic_string<CharType>>
14902 void write_characters(const CharType* s, std::size_t length) override
14911 template<typename CharType, typename StringType = std::basic_string<CharType>>
14915 template<typename AllocatorType = std::allocator<CharType>>
14916 output_adapter(std::vector<CharType, AllocatorType>& vec)
14917 : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
14920 output_adapter(std::basic_ostream<CharType>& s)
14921 : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
14925 : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
14966 explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
15031 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15033 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
15036 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15038 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
15041 write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
15043 else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
15046 write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
15051 write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
15061 write_number(static_cast<std::uint8_t>(0x20 + positive_number));
15063 else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
15066 write_number(static_cast<std::uint8_t>(positive_number));
15068 else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
15071 write_number(static_cast<std::uint16_t>(positive_number));
15073 else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
15076 write_number(static_cast<std::uint32_t>(positive_number));
15081 write_number(static_cast<std::uint64_t>(positive_number));
15091 write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
15093 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15096 write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
15098 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15101 write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
15103 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15106 write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
15111 write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
15118 if (std::isnan(j.m_value.number_float))
15125 else if (std::isinf(j.m_value.number_float))
15145 write_number(static_cast<std::uint8_t>(0x60 + N));
15147 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15150 write_number(static_cast<std::uint8_t>(N));
15152 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15155 write_number(static_cast<std::uint16_t>(N));
15157 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15160 write_number(static_cast<std::uint32_t>(N));
15163 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15166 write_number(static_cast<std::uint64_t>(N));
15183 write_number(static_cast<std::uint8_t>(0x80 + N));
15185 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15188 write_number(static_cast<std::uint8_t>(N));
15190 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15193 write_number(static_cast<std::uint16_t>(N));
15195 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15198 write_number(static_cast<std::uint32_t>(N));
15201 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15204 write_number(static_cast<std::uint64_t>(N));
15220 if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
15222 write_number(static_cast<std::uint8_t>(0xd8));
15223 write_number(static_cast<std::uint8_t>(j.m_value.binary->subtype()));
15225 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
15227 write_number(static_cast<std::uint8_t>(0xd9));
15228 write_number(static_cast<std::uint16_t>(j.m_value.binary->subtype()));
15230 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
15232 write_number(static_cast<std::uint8_t>(0xda));
15233 write_number(static_cast<std::uint32_t>(j.m_value.binary->subtype()));
15235 else if (j.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
15237 write_number(static_cast<std::uint8_t>(0xdb));
15238 write_number(static_cast<std::uint64_t>(j.m_value.binary->subtype()));
15246 write_number(static_cast<std::uint8_t>(0x40 + N));
15248 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15251 write_number(static_cast<std::uint8_t>(N));
15253 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15256 write_number(static_cast<std::uint16_t>(N));
15258 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15261 write_number(static_cast<std::uint32_t>(N));
15264 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15267 write_number(static_cast<std::uint64_t>(N));
15285 write_number(static_cast<std::uint8_t>(0xA0 + N));
15287 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15290 write_number(static_cast<std::uint8_t>(N));
15292 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15295 write_number(static_cast<std::uint16_t>(N));
15297 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15300 write_number(static_cast<std::uint32_t>(N));
15303 else if (N <= (std::numeric_limits<std::uint64_t>::max)())
15306 write_number(static_cast<std::uint64_t>(N));
15356 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15358 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15362 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15364 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15368 write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
15370 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15374 write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
15376 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
15380 write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
15388 write_number(static_cast<std::int8_t>(j.m_value.number_integer));
15390 else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
15391 j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
15395 write_number(static_cast<std::int8_t>(j.m_value.number_integer));
15397 else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
15398 j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
15402 write_number(static_cast<std::int16_t>(j.m_value.number_integer));
15404 else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
15405 j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
15409 write_number(static_cast<std::int32_t>(j.m_value.number_integer));
15411 else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
15412 j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
15416 write_number(static_cast<std::int64_t>(j.m_value.number_integer));
15427 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15429 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
15433 write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
15435 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
15439 write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
15441 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
15445 write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
15447 else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
15451 write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
15469 write_number(static_cast<std::uint8_t>(0xA0 | N));
15471 else if (N <= (std::numeric_limits<std::uint8_t>::max)())
15475 write_number(static_cast<std::uint8_t>(N));
15477 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15481 write_number(static_cast<std::uint16_t>(N));
15483 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15487 write_number(static_cast<std::uint32_t>(N));
15504 write_number(static_cast<std::uint8_t>(0x90 | N));
15506 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15510 write_number(static_cast<std::uint16_t>(N));
15512 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15516 write_number(static_cast<std::uint32_t>(N));
15535 if (N <= (std::numeric_limits<std::uint8_t>::max)())
15537 std::uint8_t output_type{};
15574 write_number(static_cast<std::uint8_t>(N));
15577 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15579 std::uint8_t output_type = use_ext
15584 write_number(static_cast<std::uint16_t>(N));
15586 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15588 std::uint8_t output_type = use_ext
15593 write_number(static_cast<std::uint32_t>(N));
15599 write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
15617 write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
15619 else if (N <= (std::numeric_limits<std::uint16_t>::max)())
15623 write_number(static_cast<std::uint16_t>(N));
15625 else if (N <= (std::numeric_limits<std::uint32_t>::max)())
15629 write_number(static_cast<std::uint32_t>(N));
15723 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
15729 std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
15731 if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
15821 const bool same_prefix = std::all_of(j.begin(), j.end(),
15827 std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
15829 if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
15875 static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
15880 JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
15891 const std::uint8_t element_type)
15922 static std::size_t calc_bson_string_size(const string_t& value)
15924 return sizeof(std::int32_t) + value.size() + 1ul;
15935 write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
15952 static std::size_t calc_bson_integer_size(const std::int64_t value)
15954 return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
15955 ? sizeof(std::int32_t)
15956 : sizeof(std::int64_t);
15963 const std::int64_t value)
15965 if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
15968 write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
15973 write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
15980 static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
15982 return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
15983 ? sizeof(std::int32_t)
15984 : sizeof(std::int64_t);
15993 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
15996 write_number<std::int32_t>(static_cast<std::int32_t>(j.m_value.number_unsigned), true);
15998 else if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16001 write_number<std::int64_t>(static_cast<std::int64_t>(j.m_value.number_unsigned), true);
16005 JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
16022 static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
16024 std::size_t array_index = 0ul;
16026 const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
16028 return result + calc_bson_element_size(std::to_string(array_index++), el);
16031 return sizeof(std::int32_t) + embedded_document_size + 1ul;
16037 static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
16039 return sizeof(std::int32_t) + value.size() + 1ul;
16049 write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
16051 std::size_t array_index = 0ul;
16055 write_bson_element(std::to_string(array_index++), el);
16069 write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
16070 write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
16079 static std::size_t calc_bson_element_size(const string_t& name,
16174 static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
16176 std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
16182 return sizeof(std::int32_t) + document_size + 1ul;
16191 write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
16234 template<typename NumberType, typename std::enable_if<
16235 std::is_floating_point<NumberType>::value, int>::type = 0>
16248 template<typename NumberType, typename std::enable_if<
16249 std::is_unsigned<NumberType>::value, int>::type = 0>
16254 if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
16260 write_number(static_cast<std::uint8_t>(n), use_bjdata);
16262 else if (n <= (std::numeric_limits<std::uint8_t>::max)())
16268 write_number(static_cast<std::uint8_t>(n), use_bjdata);
16270 else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
16276 write_number(static_cast<std::int16_t>(n), use_bjdata);
16278 else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
16284 write_number(static_cast<std::uint16_t>(n), use_bjdata);
16286 else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16292 write_number(static_cast<std::int32_t>(n), use_bjdata);
16294 else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
16300 write_number(static_cast<std::uint32_t>(n), use_bjdata);
16302 else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16308 write_number(static_cast<std::int64_t>(n), use_bjdata);
16310 else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
16316 write_number(static_cast<std::uint64_t>(n), use_bjdata);
16327 for (std::size_t i = 0; i < number.size(); ++i)
16329 oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
16335 template < typename NumberType, typename std::enable_if <
16336 std::is_signed<NumberType>::value&&
16337 !std::is_floating_point<NumberType>::value, int >::type = 0 >
16342 if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
16348 write_number(static_cast<std::int8_t>(n), use_bjdata);
16350 else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
16356 write_number(static_cast<std::uint8_t>(n), use_bjdata);
16358 else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
16364 write_number(static_cast<std::int16_t>(n), use_bjdata);
16366 else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
16374 else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
16380 write_number(static_cast<std::int32_t>(n), use_bjdata);
16382 else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
16390 else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
16396 write_number(static_cast<std::int64_t>(n), use_bjdata);
16408 for (std::size_t i = 0; i < number.size(); ++i)
16410 oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
16431 if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
16435 if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
16439 if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
16443 if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
16447 if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
16451 if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
16455 if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
16465 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
16469 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
16473 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
16477 if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
16481 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
16485 if (use_bjdata && j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
16489 if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
16493 if (use_bjdata && j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
16535 std::map<string_t, CharType> bjdtype = {{"uint8", 'U'}, {"int8", 'i'}, {"uint16", 'u'}, {"int16", 'I'},
16548 std::size_t len = (value.at(key).empty() ? 0 : 1);
16551 len *= static_cast<std::size_t>(el.m_value.number_unsigned);
16573 write_number(static_cast<std::uint8_t>(el.m_value.number_unsigned), true);
16580 write_number(static_cast<std::int8_t>(el.m_value.number_integer), true);
16587 write_number(static_cast<std::uint16_t>(el.m_value.number_unsigned), true);
16594 write_number(static_cast<std::int16_t>(el.m_value.number_integer), true);
16601 write_number(static_cast<std::uint32_t>(el.m_value.number_unsigned), true);
16608 write_number(static_cast<std::int32_t>(el.m_value.number_integer), true);
16615 write_number(static_cast<std::uint64_t>(el.m_value.number_unsigned), true);
16622 write_number(static_cast<std::int64_t>(el.m_value.number_integer), true);
16663 std::array<CharType, sizeof(NumberType)> vec{};
16664 std::memcpy(vec.data(), &n, sizeof(NumberType));
16670 std::reverse(vec.begin(), vec.end());
16682 if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
16683 static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
16709 enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
16710 static constexpr CharType to_char_type(std::uint8_t x) noexcept
16716 enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
16717 static CharType to_char_type(std::uint8_t x) noexcept
16719 static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
16720 static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
16722 std::memcpy(&result, &x, sizeof(x));
16727 enable_if_t<std::is_unsigned<C>::value>* = nullptr>
16728 static constexpr CharType to_char_type(std::uint8_t x) noexcept
16735 std::is_signed<C>::value &&
16736 std::is_signed<char>::value &&
16737 std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
16836 std::memcpy(&target, &source, sizeof(Source));
16844 std::uint64_t f = 0;
16847 constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
16892 const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
16893 const std::uint64_t u_hi = x.f >> 32u;
16894 const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
16895 const std::uint64_t v_hi = y.f >> 32u;
16897 const std::uint64_t p0 = u_lo * v_lo;
16898 const std::uint64_t p1 = u_lo * v_hi;
16899 const std::uint64_t p2 = u_hi * v_lo;
16900 const std::uint64_t p3 = u_hi * v_hi;
16902 const std::uint64_t p0_hi = p0 >> 32u;
16903 const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
16904 const std::uint64_t p1_hi = p1 >> 32u;
16905 const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
16906 const std::uint64_t p2_hi = p2 >> 32u;
16908 std::uint64_t Q = p0_hi + p1_lo + p2_lo;
16919 Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
16921 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
16974 JSON_ASSERT(std::isfinite(value));
16984 static_assert(std::numeric_limits<FloatType>::is_iec559,
16987 constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
16988 constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
16990 constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
16992 using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
16994 const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
16995 const std::uint64_t E = bits >> (kPrecision - 1);
16996 const std::uint64_t F = bits & (kHiddenBit - 1);
17099 std::uint64_t f;
17166 static constexpr std::array<cached_power, 79> kCachedPowers =
17262 JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
17264 const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
17275 inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
17329 inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
17330 std::uint64_t rest, std::uint64_t ten_k)
17391 std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
17392 std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
17401 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
17403 auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
17404 std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
17412 std::uint32_t pow10{};
17440 const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
17441 const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
17466 const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
17482 const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
17544 JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
17546 const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
17547 const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
17587 const std::uint64_t ten_m = one.f;
17673 static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
17676 JSON_ASSERT(std::isfinite(value));
17683 // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
17684 // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
17685 // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
17687 // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
17688 // representation using the corresponding std::from_chars function recovers value exactly". That
17690 // 'std::strtof'.
17726 auto k = static_cast<std::uint32_t>(e);
17781 std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
17795 std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
17805 std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
17808 std::memset(buf + 2, '0', static_cast<size_t>(-n));
17824 std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
17851 JSON_ASSERT(std::isfinite(value));
17854 if (std::signbit(value))
17876 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
17886 JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
17891 constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
17894 JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
17895 JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
17942 static constexpr std::uint8_t UTF8_ACCEPT = 0;
17943 static constexpr std::uint8_t UTF8_REJECT = 1;
17953 : o(std::move(s))
17954 , loc(std::localeconv())
17955 , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
17956 , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
18020 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
18032 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
18049 for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
18060 JSON_ASSERT(std::next(i) == val.m_value.object->cend());
18277 std::uint32_t codepoint{};
18278 std::uint8_t state = UTF8_ACCEPT;
18279 std::size_t bytes = 0; // number of bytes written to string_buffer
18282 std::size_t bytes_after_last_accept = 0;
18283 std::size_t undumped_chars = 0;
18285 for (std::size_t i = 0; i < s.size(); ++i)
18287 const auto byte = static_cast<std::uint8_t>(s[i]);
18353 static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
18354 static_cast<std::uint16_t>(codepoint)));
18360 static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
18361 static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
18362 static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
18397 JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
18489 JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
18561 static std::string hex_bytes(std::uint8_t byte)
18563 std::string result = "FF";
18571 template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
18577 template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
18593 std::is_integral<NumberType>::value ||
18594 std::is_same<NumberType, number_unsigned_t>::value ||
18595 std::is_same<NumberType, number_integer_t>::value ||
18596 std::is_same<NumberType, binary_char_t>::value,
18600 static constexpr std::array<std::array<char, 2>, 100> digits_to_99
18686 if (!std::isfinite(x))
18698 = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
18699 (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
18701 dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
18704 void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
18712 void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
18715 static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
18719 std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
18724 JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
18729 // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
18730 const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
18731 std::fill(end, number_buffer.end(), '\0');
18739 // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
18740 const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
18747 o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
18751 std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
18779 @note The function has been edited: a std::array is used.
18784 static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
18786 static const std::array<std::uint8_t, 400> utf8d =
18807 const std::uint8_t type = utf8d[byte];
18813 std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
18841 JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
18850 std::array<char, 64> number_buffer{{}};
18853 const std::lconv* loc = nullptr;
18860 std::array<char, 512> string_buffer{{}};
18907 template <class Key, class T, class IgnoredLess = std::less<Key>,
18908 class Allocator = std::allocator<std::pair<const Key, T>>>
18909 struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
18913 using Container = std::vector<std::pair<const Key, T>, Allocator>;
18919 using key_compare = std::equal_to<>;
18921 using key_compare = std::equal_to<Key>;
18931 ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
18934 std::pair<iterator, bool> emplace(const key_type& key, T&& t)
18943 Container::emplace_back(key, std::forward<T>(t));
18944 return {std::prev(this->end()), true};
18949 std::pair<iterator, bool> emplace(KeyType && key, T && t)
18958 Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
18959 return {std::prev(this->end()), true};
18971 return emplace(std::forward<KeyType>(key), T{}).first->second;
18983 return at(std::forward<KeyType>(key));
18996 JSON_THROW(std::out_of_range("key not found"));
19011 JSON_THROW(std::out_of_range("key not found"));
19024 JSON_THROW(std::out_of_range("key not found"));
19039 JSON_THROW(std::out_of_range("key not found"));
19052 new (&*it) value_type{std::move(*next)};
19073 new (&*it) value_type{std::move(*next)};
19084 return erase(pos, std::next(pos));
19094 const auto elements_affected = std::distance(first, last);
19095 const auto offset = std::distance(Container::begin(), first);
19117 for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
19120 new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
19204 std::pair<iterator, bool> insert( value_type&& value )
19206 return emplace(value.first, std::move(value.second));
19209 std::pair<iterator, bool> insert( const value_type& value )
19223 using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
19224 std::input_iterator_tag>::value>::type;
19313 return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
19314 std::move(cb), allow_exceptions, ignore_comments);
19348 using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
19390 using difference_type = std::ptrdiff_t;
19392 using size_type = std::size_t;
19398 using pointer = typename std::allocator_traits<allocator_type>::pointer;
19400 using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
19432 detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
19433 std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
19434 std::to_string(NLOHMANN_JSON_VERSION_PATCH));
19457 std::to_string(__GNUC__), '.',
19458 std::to_string(__GNUC_MINOR__), '.',
19459 std::to_string(__GNUC_PATCHLEVEL__))
19478 result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
19480 result["compiler"]["c++"] = std::to_string(__cplusplus);
19504 using default_object_comparator_t = std::less<>;
19506 using default_object_comparator_t = std::less<StringType>;
19514 AllocatorType<std::pair<const StringType,
19559 using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
19565 std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
19566 AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
19706 json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
19712 json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
19718 json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
19724 json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
19730 json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
19737 std::vector<basic_json> stack;
19743 std::move(array->begin(), array->end(), std::back_inserter(stack));
19750 stack.push_back(std::move(it.second));
19757 basic_json current_item(std::move(stack.back()));
19764 std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(), std::back_inserter(stack));
19772 stack.push_back(std::move(it.second));
19788 std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
19789 std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
19796 std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
19797 std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
19804 std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
19805 std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
19812 std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
19813 std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
19861 JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
19921 reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
19924 if (old_capacity != static_cast<std::size_t>(-1))
19991 basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
20004 JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
20005 std::forward<CompatibleType>(val))))
20007 JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
20016 detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
20076 bool is_an_object = std::all_of(init.begin(), init.end(),
20108 std::move(*((*element.m_value.array)[0].m_value.string)),
20109 std::move((*element.m_value.array)[1]));
20152 res.m_value = std::move(init);
20163 res.m_value = binary_t(std::move(init), subtype);
20195 template < class InputIT, typename std::enable_if <
20196 std::is_same<InputIT, typename basic_json_t::iterator>::value ||
20197 std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
20307 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
20381 : m_type(std::move(other.m_type)),
20382 m_value(std::move(other.m_value))
20398 std::is_nothrow_move_constructible<value_t>::value&&
20399 std::is_nothrow_move_assignable<value_t>::value&&
20400 std::is_nothrow_move_constructible<json_value>::value&&
20401 std::is_nothrow_move_assignable<json_value>::value
20407 using std::swap;
20691 auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
20708 template<typename PointerType, typename std::enable_if<
20709 std::is_pointer<PointerType>::value, int>::type = 0>
20710 auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20718 template < typename PointerType, typename std::enable_if <
20719 std::is_pointer<PointerType>::value&&
20720 std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
20721 constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20760 `std::vector<short>`\, (3) A JSON object can be converted to C++
20761 associative containers such as `std::unordered_map<std::string\,
20772 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20814 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20859 std::is_same<BasicJsonType, basic_json_t>::value,
20872 std::is_pointer<PointerType>::value,
20875 -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
20910 noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
20911 -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
20916 static_assert(!std::is_reference<ValueTypeCV>::value,
20948 template<typename PointerType, typename std::enable_if<
20949 std::is_pointer<PointerType>::value, int>::type = 0>
20950 auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
20964 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
20983 typename T, std::size_t N,
20989 std::declval<const basic_json_t&>(), v)))
20997 template<typename ReferenceType, typename std::enable_if<
20998 std::is_reference<ReferenceType>::value, int>::type = 0>
21007 template < typename ReferenceType, typename std::enable_if <
21008 std::is_reference<ReferenceType>::value&&
21009 std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
21024 `std::vector` types for JSON arrays. The character type of @ref string_t
21026 ambiguities as these types implicitly convert to `std::string`.
21039 `std::vector<short>`\, (3) A JSON object can be converted to C++
21040 associative containers such as `std::unordered_map<std::string\,
21045 template < typename ValueType, typename std::enable_if <
21047 detail::negation<std::is_pointer<ValueType>>,
21048 detail::negation<std::is_same<ValueType, std::nullptr_t>>,
21049 detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
21050 detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
21052 detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
21054 detail::negation<std::is_same<ValueType, std::string_view>>,
21057 detail::negation<std::is_same<ValueType, std::any>>,
21113 JSON_CATCH (std::out_of_range&)
21116 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21136 JSON_CATCH (std::out_of_range&)
21139 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21178 auto it = m_value.object->find(std::forward<KeyType>(key));
21181 JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
21216 auto it = m_value.object->find(std::forward<KeyType>(key));
21219 JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
21298 auto result = m_value.object->emplace(std::move(key), nullptr);
21351 auto result = m_value.object->emplace(std::forward<KeyType>(key), nullptr);
21367 auto it = m_value.object->find(std::forward<KeyType>(key));
21381 using value_return_type = std::conditional <
21383 string_t, typename std::decay<ValueType>::type >;
21391 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21416 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21429 return std::forward<ValueType>(default_value);
21442 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21449 const auto it = find(std::forward<KeyType>(key));
21469 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21476 const auto it = find(std::forward<KeyType>(key));
21482 return std::forward<ValueType>(default_value);
21492 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21517 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21530 return std::forward<ValueType>(default_value);
21540 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21551 && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
21555 return value(ptr.convert(), std::forward<ValueType>(default_value));
21593 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21594 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
21622 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
21623 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
21629 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
21630 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
21663 std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
21664 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
21693 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
21694 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
21700 std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
21701 std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
21744 return m_value.object->erase(std::forward<KeyType>(key));
21757 const auto it = m_value.object->find(std::forward<KeyType>(key));
21783 return erase_internal(std::forward<KeyType>(key));
21795 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
21854 result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));
21870 result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));
21891 return is_object() ? m_value.object->count(std::forward<KeyType>(key)) : 0;
21907 return is_object() && m_value.object->find(std::forward<KeyType>(key)) != m_value.object->end();
22276 m_value.array->push_back(std::move(val));
22285 push_back(std::move(val));
22360 std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
22397 m_value.array->emplace_back(std::forward<Args>(args)...);
22404 std::pair<iterator, bool> emplace(Args&& ... args)
22421 auto res = m_value.object->emplace(std::forward<Args>(args)...);
22433 /// @note: This uses std::distance to support GCC 4.8,
22441 auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
22442 m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
22633 std::is_nothrow_move_constructible<value_t>::value&&
22634 std::is_nothrow_move_assignable<value_t>::value&&
22635 std::is_nothrow_move_constructible<json_value>::value&&
22636 std::is_nothrow_move_assignable<json_value>::value
22639 std::swap(m_type, other.m_type);
22640 std::swap(m_value, other.m_value);
22650 std::is_nothrow_move_constructible<value_t>::value&&
22651 std::is_nothrow_move_assignable<value_t>::value&&
22652 std::is_nothrow_move_constructible<json_value>::value&&
22653 std::is_nothrow_move_assignable<json_value>::value
22666 using std::swap;
22682 using std::swap;
22698 using std::swap;
22714 using std::swap;
22730 using std::swap;
22829 if ((lhs.is_number_float() && std::isnan(lhs.m_value.number_float) && rhs.is_number())
22830 || (rhs.is_number_float() && std::isnan(rhs.m_value.number_float) && lhs.is_number()))
22868 requires std::is_scalar_v<ScalarType>
22887 std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
22893 std::partial_ordering::equivalent,
22894 std::partial_ordering::unordered,
22901 requires std::is_scalar_v<ScalarType>
22902 std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
22926 requires std::is_scalar_v<ScalarType>
22947 requires std::is_scalar_v<ScalarType>
22970 template<typename ScalarType, typename std::enable_if<
22971 std::is_scalar<ScalarType>::value, int>::type = 0>
22979 template<typename ScalarType, typename std::enable_if<
22980 std::is_scalar<ScalarType>::value, int>::type = 0>
22999 template<typename ScalarType, typename std::enable_if<
23000 std::is_scalar<ScalarType>::value, int>::type = 0>
23008 template<typename ScalarType, typename std::enable_if<
23009 std::is_scalar<ScalarType>::value, int>::type = 0>
23027 template<typename ScalarType, typename std::enable_if<
23028 std::is_scalar<ScalarType>::value, int>::type = 0>
23036 template<typename ScalarType, typename std::enable_if<
23037 std::is_scalar<ScalarType>::value, int>::type = 0>
23056 template<typename ScalarType, typename std::enable_if<
23057 std::is_scalar<ScalarType>::value, int>::type = 0>
23065 template<typename ScalarType, typename std::enable_if<
23066 std::is_scalar<ScalarType>::value, int>::type = 0>
23086 template<typename ScalarType, typename std::enable_if<
23087 std::is_scalar<ScalarType>::value, int>::type = 0>
23095 template<typename ScalarType, typename std::enable_if<
23096 std::is_scalar<ScalarType>::value, int>::type = 0>
23115 template<typename ScalarType, typename std::enable_if<
23116 std::is_scalar<ScalarType>::value, int>::type = 0>
23124 template<typename ScalarType, typename std::enable_if<
23125 std::is_scalar<ScalarType>::value, int>::type = 0>
23145 friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
23164 /// operator<<(std::ostream&, const basic_json&) instead; that is,
23166 JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
23167 friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
23192 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
23207 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
23229 return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
23238 return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
23258 auto ia = detail::input_adapter(std::forward<InputType>(i));
23260 ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23261 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
23273 auto ia = detail::input_adapter(std::move(first), std::move(last));
23275 ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23276 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
23295 ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23297 : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
23304 /// operator>>(std::istream&, basic_json&) instead; that is,
23306 JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
23307 friend std::istream& operator<<(basic_json& j, std::istream& i)
23314 friend std::istream& operator>>(std::istream& i, basic_json& j)
23382 static std::vector<std::uint8_t> to_cbor(const basic_json& j)
23384 std::vector<std::uint8_t> result;
23391 static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23393 binary_writer<std::uint8_t>(o).write_cbor(j);
23405 static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
23407 std::vector<std::uint8_t> result;
23414 static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23416 binary_writer<std::uint8_t>(o).write_msgpack(j);
23428 static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
23432 std::vector<std::uint8_t> result;
23439 static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
23442 binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
23455 static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
23459 std::vector<std::uint8_t> result;
23466 static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
23469 binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
23482 static std::vector<std::uint8_t> to_bson(const basic_json& j)
23484 std::vector<std::uint8_t> result;
23491 static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23493 binary_writer<std::uint8_t>(o).write_bson(j);
23514 auto ia = detail::input_adapter(std::forward<InputType>(i));
23515 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23530 auto ia = detail::input_adapter(std::move(first), std::move(last));
23531 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23538 static basic_json from_cbor(const T* ptr, std::size_t len,
23558 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23572 auto ia = detail::input_adapter(std::forward<InputType>(i));
23573 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23587 auto ia = detail::input_adapter(std::move(first), std::move(last));
23588 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23595 static basic_json from_msgpack(const T* ptr, std::size_t len,
23612 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23626 auto ia = detail::input_adapter(std::forward<InputType>(i));
23627 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23641 auto ia = detail::input_adapter(std::move(first), std::move(last));
23642 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23649 static basic_json from_ubjson(const T* ptr, std::size_t len,
23666 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23681 auto ia = detail::input_adapter(std::forward<InputType>(i));
23682 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
23696 auto ia = detail::input_adapter(std::move(first), std::move(last));
23697 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
23711 auto ia = detail::input_adapter(std::forward<InputType>(i));
23712 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23726 auto ia = detail::input_adapter(std::move(first), std::move(last));
23727 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23734 static basic_json from_bson(const T* ptr, std::size_t len,
23751 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23852 const auto get_op = [](const std::string & op)
23928 JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
23989 const auto get_value = [&val](const std::string & op,
23990 const std::string & member,
24024 const auto op = get_value("op", "op", true).template get<std::string>();
24025 const auto path = get_value(op, "path", true).template get<std::string>();
24051 const auto from_path = get_value("move", "from", true).template get<std::string>();
24068 const auto from_path = get_value("copy", "from", true).template get<std::string>();
24128 const std::string& path = "")
24154 std::size_t i = 0;
24158 auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));
24175 {"path", detail::concat(path, '/', std::to_string(i))}
24301 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
24314 inline nlohmann::json operator "" _json(const char* s, std::size_t n)
24322 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
24324 return nlohmann::json::json_pointer(std::string(s, n));
24335 namespace std // NOLINT(cert-dcl58-cpp)
24343 std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
24349 // specialization for std::less<value_t>
24361 return std::is_lt(lhs <=> rhs); // *NOPAD*
24368 // C++20 prohibit function specialization in the std namespace.
24383 } // namespace std