Lines Matching defs:const
268 nonesuch(nonesuch const&) = delete;
269 nonesuch(nonesuch const&&) = delete;
270 void operator=(nonesuch const&) = delete;
1792 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
2559 inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2562 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2564 [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2571 inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2574 static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2576 [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2743 friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2744 friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2747 friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2748 friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2756 inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2757 inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2760 inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2761 inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
2792 static constexpr auto const value = ::nlohmann::detail:: \
2851 @sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
2884 inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
2886 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2896 const auto l_index = static_cast<std::size_t>(lhs);
2897 const auto r_index = static_cast<std::size_t>(rhs);
2914 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
2955 inline void replace_substring(StringType& s, const StringType& f,
2956 const StringType& t)
3029 constexpr operator size_t() const
3443 // (e.g. to_json(BasicJsonType&, const T&))
3507 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3518 static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3528 const BasicJsonType&, T&>::value;
3531 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
3543 const BasicJsonType&>::value;
3605 struct is_default_constructible<const std::pair<T1, T2>>
3613 struct is_default_constructible<const std::tuple<Ts...>>
3624 struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
3630 struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
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)
4180 inline std::size_t concat_length(const char* cstr, Args&& ... rest)
4187 inline std::size_t concat_length(const StringType& str, Args&& ... rest)
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()));
4229 inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4236 inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
4259 inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4270 inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
4304 const char* what() const noexcept override
4310 const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
4314 exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
4316 static std::string name(const std::string& ename, int id_)
4327 static std::string diagnostics(const BasicJsonType* leaf_element)
4331 for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
4350 for (const auto& element : *current->m_parent->m_value.object)
4380 [](const std::string & a, const std::string & b)
4411 static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
4419 static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
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)
4455 static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
4463 invalid_iterator(int id_, const char* what_arg)
4473 static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4481 type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
4490 static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
4498 out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
4507 static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
4515 other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
4593 inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
4607 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
4613 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4618 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4623 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4640 inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
4646 b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
4650 inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
4656 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4662 std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
4666 inline void from_json(const BasicJsonType& j, StringType& s)
4673 s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
4677 inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
4683 inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
4689 inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
4697 inline void from_json(const BasicJsonType& j, EnumType& e)
4708 inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
4716 std::front_inserter(l), [](const BasicJsonType & i)
4725 inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
4733 [](const BasicJsonType & elem)
4740 auto from_json(const BasicJsonType& j, T (&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
4750 inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
4752 arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
4756 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
4770 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
4781 std::inserter(ret, end(ret)), [](const BasicJsonType & i)
4794 inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
4802 [](const BasicJsonType & i)
4819 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
4852 inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
4859 bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
4864 inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
4872 const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
4877 [](typename BasicJsonType::object_t::value_type const & p)
4896 inline void from_json(const BasicJsonType& j, ArithmeticType& val)
4902 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
4907 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
4912 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
4917 val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
4978 inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
4985 for (const auto& p : j)
4998 inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
5005 for (const auto& p : j)
5017 inline void from_json(const BasicJsonType& j, std_fs::path& p)
5023 p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
5030 auto operator()(const BasicJsonType& j, T&& val) const
5047 JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
5145 iteration_proxy_value(iteration_proxy_value const&) = default;
5146 iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
5157 const iteration_proxy_value& operator*() const
5180 bool operator==(const iteration_proxy_value& o) const
5186 bool operator!=(const iteration_proxy_value& o) const
5192 const string_type& key() const
5228 typename IteratorType::reference value() const
5248 iteration_proxy(iteration_proxy const&) = default;
5249 iteration_proxy& operator=(iteration_proxy const&) = default;
5255 iteration_proxy_value<IteratorType> begin() const noexcept
5261 iteration_proxy_value<IteratorType> end() const noexcept
5271 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
5279 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
5367 static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
5387 static void construct(BasicJsonType& j, const CompatibleStringType& str)
5400 static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
5461 static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
5483 static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
5496 static void construct(BasicJsonType& j, const std::vector<bool>& arr)
5502 for (const bool x : arr)
5512 static void construct(BasicJsonType& j, const std::valarray<T>& arr)
5531 static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
5552 static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
5583 && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
5584 inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
5591 inline void to_json(BasicJsonType& j, const CompatibleString& s)
5634 inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
5647 inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
5653 inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
5660 inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
5673 inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
5687 const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5689 inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
5695 inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
5703 inline void to_json(BasicJsonType& j, const T& b)
5709 inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
5715 inline void to_json(BasicJsonType& j, const T& t)
5722 inline void to_json(BasicJsonType& j, const std_fs::path& p)
5731 auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
5746 JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
5831 byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
5841 byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
5854 bool operator==(const byte_container_with_subtype& rhs) const
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);
5860 bool operator!=(const byte_container_with_subtype& rhs) const
5875 constexpr subtype_type subtype() const noexcept
5882 constexpr bool has_subtype() const noexcept
5951 std::size_t hash(const BasicJsonType& j)
5958 const auto type = static_cast<std::size_t>(j.type());
5970 for (const auto& element : j.items())
5972 const auto h = std::hash<string_t> {}(element.key());
5982 for (const auto& element : j)
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());
6025 for (const auto byte : j.get_binary())
6127 file_input_adapter(const file_input_adapter&) = delete;
6129 file_input_adapter& operator=(const file_input_adapter&) = delete;
6173 input_stream_adapter(const input_stream_adapter&) = delete;
6236 bool empty() const
6265 const auto wc = input.get_character();
6323 const auto wc = input.get_character();
6348 const auto wc2 = static_cast<unsigned int>(input.get_character());
6349 const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
6476 static adapter_type create(const ContainerType& container)
6485 typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
6508 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
6520 auto length = std::strlen(reinterpret_cast<const char*>(b));
6521 const auto* ptr = reinterpret_cast<const char*>(b);
6544 : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
6555 return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
6640 virtual bool number_float(number_float_t val, const string_t& s) = 0;
6702 const std::string& last_token,
6703 const detail::exception& ex) = 0;
6706 json_sax(const json_sax&) = default;
6708 json_sax& operator=(const json_sax&) = default;
6744 explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
6749 json_sax_dom_parser(const json_sax_dom_parser&) = delete;
6751 json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
6779 bool number_float(number_float_t val, const string_t& /*unused*/)
6852 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
6853 const Exception& ex)
6864 constexpr bool is_errored() const
6909 const bool allow_exceptions = true;
6925 const parser_callback_t cb,
6926 const bool allow_exceptions_ = true)
6933 json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
6935 json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
6963 bool number_float(number_float_t val, const string_t& /*unused*/)
6984 const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
7004 const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
7054 const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
7102 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
7103 const Exception& ex)
7114 constexpr bool is_errored() const
7136 std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
7151 const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
7186 const bool store_element = key_keep_stack.back();
7212 const parser_callback_t callback = nullptr;
7214 const bool allow_exceptions = true;
7249 bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
7289 bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
7363 static const char* token_type_name(const token_type t) noexcept
7431 lexer(const lexer&) = delete;
7446 const auto* loc = localeconv();
7476 const auto factors = { 12u, 8u, 4u, 0u };
7477 for (const auto factor : factors)
7622 const int codepoint1 = get_codepoint();
7637 const int codepoint2 = get_codepoint();
8213 static void strtof(float& f, const char* str, char** endptr) noexcept
8219 static void strtof(double& f, const char* str, char** endptr) noexcept
8225 static void strtof(long double& f, const char* str, char** endptr) noexcept
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,
8713 constexpr number_integer_t get_number_integer() const noexcept
8719 constexpr number_unsigned_t get_number_unsigned() const noexcept
8725 constexpr number_float_t get_number_float() const noexcept
8741 constexpr position_t get_position() const noexcept
8749 std::string get_token_string() const
8753 for (const auto c : token_string)
8774 constexpr const char* get_error_message() const noexcept
8903 const bool ignore_comments = false;
8921 const char* error_message = "";
8929 const char_int_type decimal_point_char = '.';
8980 std::declval<Float>(), std::declval<const String&>()));
9010 std::declval<std::size_t>(), std::declval<const std::string&>(),
9011 std::declval<const Exception&>()));
9075 "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
9094 "Missing/invalid function: bool parse_error(std::size_t, const "
9095 "std::string&, const exception&)");
9158 explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
9164 binary_reader(const binary_reader&) = delete;
9166 binary_reader& operator=(const binary_reader&) = delete;
9179 bool sax_parse(const input_format_t format,
9181 const bool strict = true,
9182 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
9297 bool get_bson_string(const NumberType len, string_t& result)
9319 bool get_bson_binary(const NumberType len, binary_t& result)
9346 bool parse_bson_element_internal(const char_int_type element_type,
9347 const std::size_t element_type_parse_position)
9426 bool parse_bson_element_list(const bool is_array)
9437 const std::size_t element_type_parse_position = chars_read;
9494 bool parse_cbor_internal(const bool get_char,
9495 const cbor_tag_handler_t tag_handler)
9907 const auto byte1_raw = get();
9912 const auto byte2_raw = get();
9918 const auto byte1 = static_cast<unsigned char>(byte1_raw);
9919 const auto byte2 = static_cast<unsigned char>(byte2_raw);
9929 const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
9930 const double val = [&half]
9932 const int exp = (half >> 10u) & 0x1Fu;
9933 const unsigned int mant = half & 0x3FFu;
10176 bool get_cbor_array(const std::size_t len,
10177 const cbor_tag_handler_t tag_handler)
10214 bool get_cbor_object(const std::size_t len,
10215 const cbor_tag_handler_t tag_handler)
10845 bool get_msgpack_array(const std::size_t len)
10867 bool get_msgpack_object(const std::size_t len)
10904 bool parse_ubjson_internal(const bool get_char = true)
10923 bool get_ubjson_string(string_t& result, const bool get_char = true)
11373 bool get_ubjson_value(const char_int_type prefix)
11454 const auto byte1_raw = get();
11459 const auto byte2_raw = get();
11465 const auto byte1 = static_cast<unsigned char>(byte1_raw);
11466 const auto byte2 = static_cast<unsigned char>(byte2_raw);
11476 const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
11477 const double val = [&half]
11479 const int exp = (half >> 10u) & 0x1Fu;
11480 const unsigned int mant = half & 0x3FFu;
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)
11773 const auto result_number = number_lexer.scan();
11774 const auto number_string = number_lexer.get_token_string();
11775 const auto result_remainder = number_lexer.scan();
11862 bool get_number(const input_format_t format, NumberType& result)
11905 bool get_string(const input_format_t format,
11906 const NumberType len,
11938 bool get_binary(const input_format_t format,
11939 const NumberType len,
11962 bool unexpect_eof(const input_format_t format, const char* context) const
11975 std::string get_token_string() const
11988 std::string exception_message(const input_format_t format,
11989 const std::string& detail,
11990 const std::string& context) const
12037 const bool is_little_endian = little_endianness();
12040 const input_format_t input_format = input_format_t::json;
12066 const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
12071 const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
12170 const parser_callback_t<BasicJsonType> cb = nullptr,
12171 const bool allow_exceptions_ = true,
12172 const bool skip_comments = false)
12191 void parse(const bool strict, BasicJsonType& result)
12251 bool accept(const bool strict = true)
12259 bool sax_parse(SAX* sax, const bool strict = true)
12262 const bool result = sax_parse_internal(sax);
12364 const auto res = m_lexer.get_number_float();
12564 std::string exception_message(const token_type expected, const std::string& context)
12595 const parser_callback_t<BasicJsonType> callback = nullptr;
12601 const bool allow_exceptions = true;
12662 constexpr difference_type get_value() const noexcept
12680 constexpr bool is_begin() const noexcept
12686 constexpr bool is_end() const noexcept
12835 /// the iterator with BasicJsonType of different const-ness
12836 using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
12845 // make sure BasicJsonType is basic_json or const basic_json
12847 "iter_impl only accepts (const) basic_json");
12858 /// Note that value_type is required to be non-const, even for constant iterators.
12924 copy from const iterator to const iterator, and (3) conversion from
12925 iterator to const iterator. However conversion from const iterator
12930 @brief const copy constructor
12931 @param[in] other const iterator to copy from
12936 iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
12942 @param[in] other const iterator to copy from
12943 @return const/non-const iterator
12946 iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
12958 @param[in] other non-const iterator to copy from
12961 iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
12967 @param[in] other non-const iterator to copy from
12968 @return const/non-const iterator
12971 iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
13066 reference operator*() const
13110 pointer operator->() const
13255 bool operator==(const IterImpl& other) const
13291 bool operator!=(const IterImpl& other) const
13300 bool operator<(const iter_impl& other) const
13335 bool operator<=(const iter_impl& other) const
13344 bool operator>(const iter_impl& other) const
13353 bool operator>=(const iter_impl& other) const
13408 iter_impl operator+(difference_type i) const
13419 friend iter_impl operator+(difference_type i, const iter_impl& it)
13430 iter_impl operator-(difference_type i) const
13441 difference_type operator-(const iter_impl& other) const
13470 reference operator[](difference_type n) const
13508 const typename object_t::key_type& key() const
13524 reference value() const
13596 explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
13600 explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
13633 json_reverse_iterator operator+(difference_type i) const
13639 json_reverse_iterator operator-(difference_type i) const
13645 difference_type operator-(const json_reverse_iterator& other) const
13651 reference operator[](difference_type n) const
13657 auto key() const -> decltype(std::declval<Base>().key())
13664 reference value() const
13743 explicit json_pointer(const string_t& s = "")
13749 string_t to_string() const
13753 [](const string_t& a, const string_t& b)
13762 operator string_t() const
13770 friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
13779 json_pointer& operator/=(const json_pointer& ptr)
13804 friend json_pointer operator/(const json_pointer& lhs,
13805 const json_pointer& rhs)
13812 friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
13819 friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
13826 json_pointer parent_pointer() const
13852 const string_t& back() const
13864 void push_back(const string_t& token)
13878 bool empty() const noexcept
13895 static typename BasicJsonType::size_type array_index(const string_t& s)
13911 const char* p = s.c_str();
13933 json_pointer top() const
13955 BasicJsonType& get_and_create(BasicJsonType& j) const
13961 for (const auto& reference_token : reference_tokens)
14035 BasicJsonType& get_unchecked(BasicJsonType* ptr) const
14037 for (const auto& reference_token : reference_tokens)
14043 const bool nums =
14045 [](const unsigned char x)
14103 BasicJsonType& get_checked(BasicJsonType* ptr) const
14105 for (const auto& reference_token : reference_tokens)
14148 @brief return a const reference to the pointed to value
14152 @return const reference to the JSON value pointed to by the JSON
14161 const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
14163 for (const auto& reference_token : reference_tokens)
14178 // "-" cannot be used for const access
14210 const BasicJsonType& get_checked(const BasicJsonType* ptr) const
14212 for (const auto& reference_token : reference_tokens)
14259 bool contains(const BasicJsonType* ptr) const
14261 for (const auto& reference_token : reference_tokens)
14306 const auto idx = array_index<BasicJsonType>(reference_token);
14347 static std::vector<string_t> split(const string_t& reference_string)
14416 static void flatten(const string_t& reference_string,
14417 const BasicJsonType& value,
14451 for (const auto& element : *value.m_value.object)
14488 unflatten(const BasicJsonType& value)
14498 for (const auto& element : *value.m_value.object)
14516 json_pointer<string_t> convert() const&
14535 bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
14543 bool operator==(const string_t& rhs) const
14550 std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
14559 friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14560 const json_pointer<RefStringTypeRhs>& rhs) noexcept;
14566 friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14567 const StringType& rhs);
14573 friend bool operator==(const StringType& lhs,
14574 const json_pointer<RefStringTypeRhs>& rhs);
14580 friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14581 const json_pointer<RefStringTypeRhs>& rhs) noexcept;
14587 friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14588 const StringType& rhs);
14594 friend bool operator!=(const StringType& lhs,
14595 const json_pointer<RefStringTypeRhs>& rhs);
14600 friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
14601 const json_pointer<RefStringTypeRhs>& rhs) noexcept;
14612 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14613 const json_pointer<RefStringTypeRhs>& rhs) noexcept
14621 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
14622 const StringType& rhs)
14630 inline bool operator==(const StringType& lhs,
14631 const json_pointer<RefStringTypeRhs>& rhs)
14637 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14638 const json_pointer<RefStringTypeRhs>& rhs) noexcept
14646 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
14647 const StringType& rhs)
14655 inline bool operator!=(const StringType& lhs,
14656 const json_pointer<RefStringTypeRhs>& rhs)
14662 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
14663 const json_pointer<RefStringTypeRhs>& rhs) noexcept
14704 json_ref(const value_type& value)
14721 json_ref(const json_ref&) = delete;
14722 json_ref& operator=(const json_ref&) = delete;
14726 value_type moved_or_copied() const
14735 value_type const& operator*() const
14740 value_type const* operator->() const
14747 value_type const* value_ref = nullptr;
14823 virtual void write_characters(const CharType* s, std::size_t length) = 0;
14827 output_adapter_protocol(const output_adapter_protocol&) = default;
14829 output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
14852 void write_characters(const CharType* s, std::size_t length) override
14877 void write_characters(const CharType* s, std::size_t length) override
14902 void write_characters(const CharType* s, std::size_t length) override
14975 void write_bson(const BasicJsonType& j)
15004 void write_cbor(const BasicJsonType& j)
15058 const auto positive_number = -1 - j.m_value.number_integer;
15142 const auto N = j.m_value.string->size();
15172 reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
15180 const auto N = j.m_value.array->size();
15209 for (const auto& el : *j.m_value.array)
15243 const auto N = j.m_value.binary->size();
15273 reinterpret_cast<const CharType*>(j.m_value.binary->data()),
15282 const auto N = j.m_value.object->size();
15311 for (const auto& el : *j.m_value.object)
15328 void write_msgpack(const BasicJsonType& j)
15465 const auto N = j.m_value.string->size();
15492 reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
15500 const auto N = j.m_value.array->size();
15520 for (const auto& el : *j.m_value.array)
15531 const bool use_ext = j.m_value.binary->has_subtype();
15534 const auto N = j.m_value.binary->size();
15604 reinterpret_cast<const CharType*>(j.m_value.binary->data()),
15613 const auto N = j.m_value.object->size();
15633 for (const auto& el : *j.m_value.object)
15654 void write_ubjson(const BasicJsonType& j, const bool use_count,
15655 const bool use_type, const bool add_prefix = true,
15656 const bool use_bjdata = false)
15706 reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
15722 const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
15723 const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
15724 [this, first_prefix, use_bjdata](const BasicJsonType & v)
15745 for (const auto& el : *j.m_value.array)
15781 reinterpret_cast<const CharType*>(j.m_value.binary->data()),
15820 const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
15821 const bool same_prefix = std::all_of(j.begin(), j.end(),
15822 [this, first_prefix, use_bjdata](const BasicJsonType & v)
15843 for (const auto& el : *j.m_value.object)
15847 reinterpret_cast<const CharType*>(el.first.c_str()),
15875 static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
15877 const auto it = name.find(static_cast<typename string_t::value_type>(0));
15890 void write_bson_entry_header(const string_t& name,
15891 const std::uint8_t element_type)
15895 reinterpret_cast<const CharType*>(name.c_str()),
15902 void write_bson_boolean(const string_t& name,
15903 const bool value)
15912 void write_bson_double(const string_t& name,
15913 const double value)
15922 static std::size_t calc_bson_string_size(const string_t& value)
15930 void write_bson_string(const string_t& name,
15931 const string_t& value)
15937 reinterpret_cast<const CharType*>(value.c_str()),
15944 void write_bson_null(const string_t& name)
15952 static std::size_t calc_bson_integer_size(const std::int64_t value)
15962 void write_bson_integer(const string_t& name,
15963 const std::int64_t value)
15980 static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
15990 void write_bson_unsigned(const string_t& name,
15991 const BasicJsonType& j)
16012 void write_bson_object_entry(const string_t& name,
16013 const typename BasicJsonType::object_t& value)
16022 static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
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)
16037 static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
16045 void write_bson_array(const string_t& name,
16046 const typename BasicJsonType::array_t& value)
16053 for (const auto& el : value)
16064 void write_bson_binary(const string_t& name,
16065 const binary_t& value)
16072 oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
16079 static std::size_t calc_bson_element_size(const string_t& name,
16080 const BasicJsonType& j)
16082 const auto header_size = calc_bson_entry_header_size(name, j);
16127 void write_bson_element(const string_t& name,
16128 const BasicJsonType& j)
16174 static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
16177 [](size_t result, const typename BasicJsonType::object_t::value_type & el)
16189 void write_bson_object(const typename BasicJsonType::object_t& value)
16193 for (const auto& el : value)
16236 void write_number_with_ubjson_prefix(const NumberType n,
16237 const bool add_prefix,
16238 const bool use_bjdata)
16250 void write_number_with_ubjson_prefix(const NumberType n,
16251 const bool add_prefix,
16252 const bool use_bjdata)
16325 const auto number = BasicJsonType(n).dump();
16338 void write_number_with_ubjson_prefix(const NumberType n,
16339 const bool add_prefix,
16340 const bool use_bjdata)
16406 const auto number = BasicJsonType(n).dump();
16419 CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
16533 bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
16549 for (const auto& el : value.at(key))
16571 for (const auto& el : value.at(key))
16578 for (const auto& el : value.at(key))
16585 for (const auto& el : value.at(key))
16592 for (const auto& el : value.at(key))
16599 for (const auto& el : value.at(key))
16606 for (const auto& el : value.at(key))
16613 for (const auto& el : value.at(key))
16620 for (const auto& el : value.at(key))
16627 for (const auto& el : value.at(key))
16634 for (const auto& el : value.at(key))
16660 void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
16676 void write_compact_float(const number_float_t n, detail::input_format_t format)
16746 const bool is_little_endian = little_endianness();
16831 Target reinterpret_bits(const Source source)
16853 static diyfp sub(const diyfp& x, const diyfp& y) noexcept
16865 static diyfp mul(const diyfp& x, const diyfp& y) noexcept
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;
16921 const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
16947 static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
16949 const int delta = x.e - target_exponent;
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);
16998 const bool is_denormal = E == 0;
16999 const diyfp v = is_denormal
17024 const bool lower_boundary_is_closer = F == 0 && E > 1;
17025 const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
17026 const diyfp m_minus = lower_boundary_is_closer
17031 const diyfp w_plus = diyfp::normalize(m_plus);
17034 const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
17257 const int f = kAlpha - e - 1;
17258 const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
17260 const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
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)
17401 const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
17413 const int k = find_largest_pow10(p1, 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;
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;
17626 const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
17628 const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
17631 const diyfp w = diyfp::mul(v, c_minus_k);
17632 const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
17633 const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
17656 const diyfp M_minus(w_minus.f + 1, w_minus.e);
17657 const diyfp M_plus (w_plus.f - 1, w_plus.e );
17696 const boundaries w = compute_boundaries(static_cast<double>(value));
17698 const boundaries w = compute_boundaries(value);
17769 const int k = len;
17770 const int n = len + decimal_exponent;
17848 char* to_chars(char* first, const char* last, FloatType value)
17951 serializer(output_adapter_t<char> s, const char ichar,
17963 serializer(const serializer&) = delete;
17964 serializer& operator=(const serializer&) = delete;
17991 void dump(const BasicJsonType& val,
17992 const bool pretty_print,
17993 const bool ensure_ascii,
17994 const unsigned int indent_step,
17995 const unsigned int current_indent = 0)
18012 const auto new_indent = current_indent + indent_step;
18085 const auto new_indent = current_indent + indent_step;
18146 const auto new_indent = current_indent + indent_step;
18275 void dump_escaped(const string_t& s, const bool ensure_ascii)
18287 const auto byte = static_cast<std::uint8_t>(s[i]);
18564 constexpr const char* nibble_to_hex = "0123456789ABCDEF";
18655 const auto digits_index = static_cast<unsigned>((abs_value % 100));
18663 const auto digits_index = static_cast<unsigned>(abs_value);
18730 const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
18740 const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
18750 const bool value_is_int_like =
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];
18853 const std::lconv* loc = nullptr;
18855 const char thousands_sep = '\0';
18857 const char decimal_point = '\0';
18863 const char indent_char;
18868 const error_handler_t error_handler;
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>;
18927 explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
18929 ordered_map(It first, It last, const Allocator& alloc = Allocator())
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)
18962 T& operator[](const key_type& key)
18974 const T& operator[](const key_type& key) const
18981 const T & operator[](KeyType && key) const
18986 T& at(const key_type& key)
19014 const T& at(const key_type& key) const
19029 const T & at(KeyType && key) const
19042 size_type erase(const key_type& key)
19048 // Since we cannot move const Keys, re-construct them in place
19069 // Since we cannot move const Keys, re-construct them in place
19094 const auto elements_affected = std::distance(first, last);
19095 const auto offset = std::distance(Container::begin(), first);
19107 // Since we cannot move const Keys, we re-construct them in place.
19140 size_type count(const key_type& key) const
19154 size_type count(KeyType && key) const
19166 iterator find(const key_type& key)
19192 const_iterator find(const key_type& key) const
19209 std::pair<iterator, bool> insert( const value_type& value )
19309 const bool allow_exceptions = true,
19310 const bool ignore_comments = false
19386 /// the type of an element const reference
19387 using const_reference = const value_type&;
19399 /// the type of an element const pointer
19404 /// a const iterator for a basic_json container
19405 using const_iterator = iter_impl<const basic_json>;
19408 /// a const reverse iterator for a basic_json container
19514 AllocatorType<std::pair<const StringType,
19703 json_value(const string_t& value) : string(create<string_t>(value)) {}
19709 json_value(const object_t& value) : object(create<object_t>(value)) {}
19715 json_value(const array_t& value) : array(create<array_t>(value)) {}
19721 json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
19727 json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
19850 void assert_invariant(bool check_parents = true) const noexcept
19861 JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
19983 basic_json(const value_t v)
20017 basic_json(const BasicJsonType& val)
20043 JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
20046 JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
20049 JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
20052 JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
20077 [](const detail::json_ref<basic_json>& element_ref)
20126 static basic_json binary(const typename binary_t::container_type& init)
20137 static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
20185 basic_json(size_type cnt, const basic_json& val)
20308 basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
20312 basic_json(const basic_json& other)
20437 string_t dump(const int indent = -1,
20438 const char indent_char = ' ',
20439 const bool ensure_ascii = false,
20440 const error_handler_t error_handler = error_handler_t::strict) const
20459 constexpr value_t type() const noexcept
20466 constexpr bool is_primitive() const noexcept
20473 constexpr bool is_structured() const noexcept
20480 constexpr bool is_null() const noexcept
20487 constexpr bool is_boolean() const noexcept
20494 constexpr bool is_number() const noexcept
20501 constexpr bool is_number_integer() const noexcept
20508 constexpr bool is_number_unsigned() const noexcept
20515 constexpr bool is_number_float() const noexcept
20522 constexpr bool is_object() const noexcept
20529 constexpr bool is_array() const noexcept
20536 constexpr bool is_string() const noexcept
20543 constexpr bool is_binary() const noexcept
20550 constexpr bool is_discarded() const noexcept
20557 constexpr operator value_t() const noexcept
20570 boolean_t get_impl(boolean_t* /*unused*/) const
20587 constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
20599 constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
20611 constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
20623 constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
20635 constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
20647 constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
20659 constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
20671 constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
20680 const and non-const overloads
20682 @tparam ThisType will be deduced as `basic_json` or `const basic_json`
20721 constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
20723 // delegate the call to get_impl_ptr<>() const
20747 `void from_json(const basic_json&, ValueType&)`, and
20749 the form `ValueType from_json(const basic_json&)`
20771 ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
20772 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
20796 `ValueType from_json(const basic_json&)`
20813 ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
20814 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
20838 BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
20861 basic_json get_impl(detail::priority_tag<3> /*unused*/) const
20874 constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
20875 -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
20909 auto get() const noexcept(
20910 noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
20911 -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
20913 // we cannot static_assert on ValueTypeCV being non-const, because
20914 // there is support for get<const basic_json_t>(), which is why we
20963 ValueType & get_to(ValueType& v) const noexcept(noexcept(
20964 JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
20976 ValueType & get_to(ValueType& v) const
20987 Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
20989 std::declval<const basic_json_t&>(), v)))
21010 ReferenceType get_ref() const
21020 The call is realized by calling @ref get() const.
21059 detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
21061 JSON_EXPLICIT operator ValueType() const
21063 // delegate the call to get<>() const
21081 const binary_t& get_binary() const
21088 return *get_ptr<const binary_t*>();
21127 const_reference at(size_type idx) const
21150 reference at(const typename object_t::key_type& key)
21188 const_reference at(const typename object_t::key_type& key) const
21208 const_reference at(KeyType && key) const
21244 const auto old_size = m_value.array->size();
21245 const auto old_capacity = m_value.array->capacity();
21272 const_reference operator[](size_type idx) const
21274 // const operator[] only works for arrays
21307 const_reference operator[](const typename object_t::key_type& key) const
21309 // const operator[] only works for objects
21320 // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
21329 const_reference operator[](T* key) const
21362 const_reference operator[](KeyType && key) const
21364 // const operator[] only works for objects
21378 object_comparator_t, const typename object_t::key_type&, KeyType >;
21392 ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
21398 const auto it = find(key);
21417 ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
21423 const auto it = find(key);
21443 ValueType value(KeyType && key, const ValueType& default_value) const
21449 const auto it = find(std::forward<KeyType>(key));
21470 ReturnType value(KeyType && key, ValueType && default_value) const
21476 const auto it = find(std::forward<KeyType>(key));
21493 ValueType value(const json_pointer& ptr, const ValueType& default_value) const
21518 ReturnType value(const json_pointer& ptr, ValueType && default_value) const
21542 ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
21553 ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
21567 const_reference front() const
21583 const_reference back() const
21757 const auto it = m_value.object->find(std::forward<KeyType>(key));
21770 size_type erase(const typename object_t::key_type& key)
21788 void erase(const size_type idx)
21818 iterator find(const typename object_t::key_type& key)
21832 const_iterator find(const typename object_t::key_type& key) const
21864 const_iterator find(KeyType && key) const
21878 size_type count(const typename object_t::key_type& key) const
21888 size_type count(KeyType && key) const
21896 bool contains(const typename object_t::key_type& key) const
21905 bool contains(KeyType && key) const
21912 bool contains(const json_pointer& ptr) const
21919 bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
21945 const_iterator begin() const noexcept
21950 /// @brief returns a const iterator to the first element
21952 const_iterator cbegin() const noexcept
21970 const_iterator end() const noexcept
21977 const_iterator cend() const noexcept
21993 const_reverse_iterator rbegin() const noexcept
22007 const_reverse_iterator rend() const noexcept
22012 /// @brief returns a const reverse iterator to the last element
22014 const_reverse_iterator crbegin() const noexcept
22019 /// @brief returns a const reverse iterator to one before the first
22021 const_reverse_iterator crend() const noexcept
22058 iteration_proxy<const_iterator> items() const noexcept
22075 bool empty() const noexcept
22114 size_type size() const noexcept
22153 size_type max_size() const noexcept
22275 const auto old_capacity = m_value.array->capacity();
22291 void push_back(const basic_json& val)
22308 const auto old_capacity = m_value.array->capacity();
22315 reference operator+=(const basic_json& val)
22323 void push_back(const typename object_t::value_type& val)
22346 reference operator+=(const typename object_t::value_type& val)
22396 const auto old_capacity = m_value.array->capacity();
22455 iterator insert(const_iterator pos, const basic_json& val)
22482 iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
22751 const auto lhs_type = lhs.type(); \
22752 const auto rhs_type = rhs.type(); \
22843 bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
22852 bool operator==(const_reference rhs) const noexcept
22869 bool operator==(ScalarType rhs) const noexcept
22876 bool operator!=(const_reference rhs) const noexcept
22887 std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
22902 std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
22914 bool operator<=(const_reference rhs) const noexcept
22927 bool operator<=(ScalarType rhs) const noexcept
22935 bool operator>=(const_reference rhs) const noexcept
22948 bool operator>=(ScalarType rhs) const noexcept
23145 friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
23148 const bool pretty_print = o.width() > 0;
23149 const auto indentation = pretty_print ? o.width() : 0;
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)
23187 const parser_callback_t cb = nullptr,
23188 const bool allow_exceptions = true,
23189 const bool ignore_comments = false)
23202 const parser_callback_t cb = nullptr,
23203 const bool allow_exceptions = true,
23204 const bool ignore_comments = false)
23214 const parser_callback_t cb = nullptr,
23215 const bool allow_exceptions = true,
23216 const bool ignore_comments = false)
23227 const bool ignore_comments = false)
23236 const bool ignore_comments = false)
23244 const bool ignore_comments = false)
23255 const bool strict = true,
23256 const bool ignore_comments = false)
23270 const bool strict = true,
23271 const bool ignore_comments = false)
23289 const bool strict = true,
23290 const bool ignore_comments = false)
23294 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23296 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23329 const char* type_name() const noexcept
23382 static std::vector<std::uint8_t> to_cbor(const basic_json& j)
23391 static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23398 static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
23405 static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
23414 static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23421 static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
23428 static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
23429 const bool use_size = false,
23430 const bool use_type = false)
23439 static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
23440 const bool use_size = false, const bool use_type = false)
23447 static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
23448 const bool use_size = false, const bool use_type = false)
23455 static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
23456 const bool use_size = false,
23457 const bool use_type = false)
23466 static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
23467 const bool use_size = false, const bool use_type = false)
23474 static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
23475 const bool use_size = false, const bool use_type = false)
23482 static std::vector<std::uint8_t> to_bson(const basic_json& j)
23491 static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
23498 static void to_bson(const basic_json& j, detail::output_adapter<char> o)
23508 const bool strict = true,
23509 const bool allow_exceptions = true,
23510 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
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);
23524 const bool strict = true,
23525 const bool allow_exceptions = true,
23526 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
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,
23539 const bool strict = true,
23540 const bool allow_exceptions = true,
23541 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23550 const bool strict = true,
23551 const bool allow_exceptions = true,
23552 const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23557 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23558 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23567 const bool strict = true,
23568 const bool allow_exceptions = true)
23573 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23582 const bool strict = true,
23583 const bool allow_exceptions = true)
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,
23596 const bool strict = true,
23597 const bool allow_exceptions = true)
23605 const bool strict = true,
23606 const bool allow_exceptions = true)
23611 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23612 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
23621 const bool strict = true,
23622 const bool allow_exceptions = true)
23627 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23636 const bool strict = true,
23637 const bool allow_exceptions = true)
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,
23650 const bool strict = true,
23651 const bool allow_exceptions = true)
23659 const bool strict = true,
23660 const bool allow_exceptions = true)
23665 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23666 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
23676 const bool strict = true,
23677 const bool allow_exceptions = true)
23682 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
23691 const bool strict = true,
23692 const bool allow_exceptions = true)
23697 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
23706 const bool strict = true,
23707 const bool allow_exceptions = true)
23712 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23721 const bool strict = true,
23722 const bool allow_exceptions = true)
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,
23735 const bool strict = true,
23736 const bool allow_exceptions = true)
23744 const bool strict = true,
23745 const bool allow_exceptions = true)
23750 // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
23751 const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
23765 reference operator[](const json_pointer& ptr)
23772 reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
23779 const_reference operator[](const json_pointer& ptr) const
23786 const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
23793 reference at(const json_pointer& ptr)
23800 reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
23807 const_reference at(const json_pointer& ptr) const
23814 const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
23821 basic_json flatten() const
23830 basic_json unflatten() const
23846 void patch_inplace(const basic_json& json_patch)
23852 const auto get_op = [](const std::string & op)
23883 const auto operation_add = [&result](json_pointer & ptr, basic_json val)
23900 const auto last_path = ptr.back();
23924 const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
23951 const auto operation_remove = [this, &result](json_pointer & ptr)
23954 const auto last_path = ptr.back();
23986 for (const auto& val : json_patch)
23989 const auto get_value = [&val](const std::string & op,
23990 const std::string & member,
23997 const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');
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>();
24069 const json_pointer from_ptr(from_path);
24117 basic_json patch(const basic_json& json_patch) const
24127 static basic_json diff(const basic_json& source, const basic_json& target,
24128 const std::string& path = "")
24167 const auto end_index = static_cast<difference_type>(result.size());
24201 const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
24225 const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
24269 void merge_patch(const basic_json& apply_patch)
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)
24343 std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
24358 ::nlohmann::detail::value_t rhs) const noexcept