Lines Matching defs:result
6221 auto result = std::char_traits<char_type>::to_int_type(*current);
6223 return result;
7655 // in the result, so we have to subtract with:
7680 // result of the above calculation yields a proper codepoint
8752 std::string result;
8760 result += cs.data();
8765 result.push_back(static_cast<std::string::value_type>(c));
8769 return result;
9185 bool result = false;
9190 result = parse_bson_internal();
9194 result = parse_cbor_internal(true, tag_handler);
9198 result = parse_msgpack_internal();
9203 result = parse_ubjson_internal();
9212 if (result && strict)
9230 return result;
9262 @param[in,out] result A reference to the string variable where the read
9267 bool get_bson_cstr(string_t& result)
9269 auto out = std::back_inserter(result);
9290 @param[in,out] result A reference to the string variable where the read
9297 bool get_bson_string(const NumberType len, string_t& result)
9306 return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
9312 @param[in,out] result A reference to the binary variable where the read
9319 bool get_bson_binary(const NumberType len, binary_t& result)
9331 result.set_subtype(subtype);
9333 return get_binary(input_format_t::bson, len, result);
9981 @param[out] result created string
9985 bool get_cbor_string(string_t& result)
10020 return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
10026 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10032 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10038 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10044 return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
10056 result.append(chunk);
10077 @param[out] result created byte array
10081 bool get_cbor_binary(binary_t& result)
10116 return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
10123 get_binary(input_format_t::cbor, len, result);
10130 get_binary(input_format_t::cbor, len, result);
10137 get_binary(input_format_t::cbor, len, result);
10144 get_binary(input_format_t::cbor, len, result);
10156 result.insert(result.end(), chunk.begin(), chunk.end());
10647 @param[out] result created string
10651 bool get_msgpack_string(string_t& result)
10694 return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
10700 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10706 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10712 return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
10730 @param[out] result created byte array
10734 bool get_msgpack_binary(binary_t& result)
10737 auto assign_and_return_true = [&result](std::int8_t subtype)
10739 result.set_subtype(static_cast<std::uint8_t>(subtype));
10749 get_binary(input_format_t::msgpack, len, result);
10756 get_binary(input_format_t::msgpack, len, result);
10763 get_binary(input_format_t::msgpack, len, result);
10772 get_binary(input_format_t::msgpack, len, result) &&
10782 get_binary(input_format_t::msgpack, len, result) &&
10792 get_binary(input_format_t::msgpack, len, result) &&
10800 get_binary(input_format_t::msgpack, 1, result) &&
10808 get_binary(input_format_t::msgpack, 2, result) &&
10816 get_binary(input_format_t::msgpack, 4, result) &&
10824 get_binary(input_format_t::msgpack, 8, result) &&
10832 get_binary(input_format_t::msgpack, 16, result) &&
10916 @param[out] result created string
10923 bool get_ubjson_string(string_t& result, const bool get_char = true)
10940 return get_number(input_format, len) && get_string(input_format, len, result);
10946 return get_number(input_format, len) && get_string(input_format, len, result);
10952 return get_number(input_format, len) && get_string(input_format, len, result);
10958 return get_number(input_format, len) && get_string(input_format, len, result);
10964 return get_number(input_format, len) && get_string(input_format, len, result);
10974 return get_number(input_format, len) && get_string(input_format, len, result);
10984 return get_number(input_format, len) && get_string(input_format, len, result);
10994 return get_number(input_format, len) && get_string(input_format, len, result);
11073 @param[out] result determined size
11083 bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
11099 result = static_cast<std::size_t>(number);
11115 result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
11131 result = static_cast<std::size_t>(number);
11147 result = static_cast<std::size_t>(number);
11168 result = static_cast<std::size_t>(number);
11183 result = static_cast<std::size_t>(number);
11198 result = conditional_static_cast<std::size_t>(number);
11218 result = detail::conditional_static_cast<std::size_t>(number);
11239 result = dim.at(dim.size() - 1);
11248 result = 0;
11258 result = 1;
11261 result *= i;
11262 if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
11274 result = 0;
11301 @param[out] result pair of the size and the type
11306 bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
11308 result.first = npos; // size
11309 result.second = 0; // type
11316 result.second = get(); // must not ignore 'N', because 'N' maybe the type
11318 && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
11342 bool is_error = get_ubjson_size_value(result.first, is_ndarray);
11350 result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
11357 bool is_error = get_ubjson_size_value(result.first, is_ndarray);
11851 @param[out] result number of type @a NumberType
11862 bool get_number(const input_format_t format, NumberType& result)
11886 std::memcpy(&result, vec.data(), sizeof(NumberType));
11896 @param[out] result string created by reading @a len bytes
11900 @note We can not reserve @a len bytes for the result, because @a len
11907 string_t& result)
11918 result.push_back(static_cast<typename string_t::value_type>(current));
11929 @param[out] result byte array created by reading @a len bytes
11933 @note We can not reserve @a len bytes for the result, because @a len
11940 binary_t& result)
11951 result.push_back(static_cast<std::uint8_t>(current));
12185 @param[in,out] result parsed JSON value
12191 void parse(const bool strict, BasicJsonType& result)
12195 json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
12210 result = value_t::discarded;
12216 if (result.is_discarded())
12218 result = nullptr;
12223 json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
12237 result = value_t::discarded;
12242 result.assert_invariant();
12262 const bool result = sax_parse_internal(sax);
12265 if (result && strict && (get_token() != token_type::end_of_input))
12272 return result;
12703 auto result = *this;
12704 result += n;
12705 return result;
12721 auto result = *this;
12723 return result;
12734 auto result = *this;
12736 return result;
13154 auto result = *this;
13156 return result;
13205 auto result = *this;
13207 return result;
13410 auto result = *this;
13411 result += i;
13412 return result;
13421 auto result = it;
13422 result += i;
13423 return result;
13432 auto result = *this;
13433 result -= i;
13434 return result;
13940 json_pointer result = *this;
13941 result.reference_tokens = {reference_tokens[0]};
13942 return result;
13957 auto* result = &j;
13963 switch (result->type())
13970 result = &result->operator[](0);
13975 result = &result->operator[](reference_token);
13983 result = &result->operator[](reference_token);
13990 result = &result->operator[](array_index<BasicJsonType>(reference_token));
14012 return *result;
14349 std::vector<string_t> result;
14354 return result;
14401 result.push_back(reference_token);
14404 return result;
14411 @param[in,out] result the result object to insert values to
14418 BasicJsonType& result)
14427 result[reference_string] = nullptr;
14435 value.m_value.array->operator[](i), result);
14446 result[reference_string] = nullptr;
14453 flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
14470 result[reference_string] = value;
14495 BasicJsonType result;
14507 // get_and_create returns a reference to result itself. An assignment
14509 json_pointer(element.first).get_and_create(result) = element.second;
14512 return result;
14518 json_pointer<string_t> result;
14519 result.reference_tokens = reference_tokens;
14520 return result;
14525 json_pointer<string_t> result;
14526 result.reference_tokens = std::move(reference_tokens);
14527 return result;
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);
16177 [](size_t result, const typename BasicJsonType::object_t::value_type & el)
16179 return result += calc_bson_element_size(el.first, el.second);
16721 CharType result;
16722 std::memcpy(&result, &x, sizeof(x));
16723 return result;
16863 @note The result is rounded. (Only the upper q bits are returned.)
16944 @brief normalize x such that the result has the exponent E
17129 // "In theory the result of the procedure could be wrong since c is rounded,
17639 // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
17843 @note The result is NOT null-terminated.
17986 in the output are escaped with `\uXXXX` sequences, and the result consists
18563 std::string result = "FF";
18565 result[0] = nibble_to_hex[byte / 16];
18566 result[1] = nibble_to_hex[byte % 16];
18567 return result;
18648 // so we later avoid reversing the result
18767 result of the check is stored in the @a state parameter. The function must
19426 basic_json result;
19428 result["copyright"] = "(C) 2013-2022 Niels Lohmann";
19429 result["name"] = "JSON for Modern C++";
19430 result["url"] = "https://github.com/nlohmann/json";
19431 result["version"]["string"] =
19435 result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
19436 result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
19437 result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
19440 result["platform"] = "win32";
19442 result["platform"] = "linux";
19444 result["platform"] = "apple";
19446 result["platform"] = "unix";
19448 result["platform"] = "unknown";
19452 result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
19454 result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
19456 result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
19463 result["compiler"] = "hp"
19465 result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
19467 result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
19469 result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
19471 result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
19473 result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
19478 result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
19480 result["compiler"]["c++"] = std::to_string(__cplusplus);
19482 result["compiler"]["c++"] = "unknown";
19484 return result;
20442 string_t result;
20443 serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
20454 return result;
21298 auto result = m_value.object->emplace(std::move(key), nullptr);
21299 return set_parent(result.first->second);
21351 auto result = m_value.object->emplace(std::forward<KeyType>(key), nullptr);
21352 return set_parent(result.first->second);
21603 IteratorType result = end();
21641 result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
21647 result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
21657 return result;
21673 IteratorType result = end();
21712 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
21719 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
21730 return result;
21820 auto result = end();
21824 result.m_it.object_iterator = m_value.object->find(key);
21827 return result;
21834 auto result = cend();
21838 result.m_it.object_iterator = m_value.object->find(key);
21841 return result;
21850 auto result = end();
21854 result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));
21857 return result;
21866 auto result = cend();
21870 result.m_it.object_iterator = m_value.object->find(std::forward<KeyType>(key));
21873 return result;
21938 iterator result(this);
21939 result.set_begin();
21940 return result;
21954 const_iterator result(this);
21955 result.set_begin();
21956 return result;
21963 iterator result(this);
21964 result.set_end();
21965 return result;
21979 const_iterator result(this);
21980 result.set_end();
21981 return result;
22424 // create result iterator and set iterator to the result of emplace
22438 iterator result(this);
22443 result.m_it.array_iterator = m_value.array->begin() + insert_pos;
22446 // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
22450 return result;
23191 basic_json result;
23192 parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
23193 return result;
23206 basic_json result;
23207 parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
23208 return result;
23218 basic_json result;
23219 parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
23220 return result;
23384 std::vector<std::uint8_t> result;
23385 to_cbor(j, result);
23386 return result;
23407 std::vector<std::uint8_t> result;
23408 to_msgpack(j, result);
23409 return result;
23432 std::vector<std::uint8_t> result;
23433 to_ubjson(j, result, use_size, use_type);
23434 return result;
23459 std::vector<std::uint8_t> result;
23460 to_bjdata(j, result, use_size, use_type);
23461 return result;
23484 std::vector<std::uint8_t> result;
23485 to_bson(j, result);
23486 return result;
23512 basic_json result;
23513 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23516 return res ? result : basic_json(value_t::discarded);
23528 basic_json result;
23529 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23532 return res ? result : basic_json(value_t::discarded);
23554 basic_json result;
23555 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23559 return res ? result : basic_json(value_t::discarded);
23570 basic_json result;
23571 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23574 return res ? result : basic_json(value_t::discarded);
23585 basic_json result;
23586 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23589 return res ? result : basic_json(value_t::discarded);
23608 basic_json result;
23609 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23613 return res ? result : basic_json(value_t::discarded);
23624 basic_json result;
23625 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23628 return res ? result : basic_json(value_t::discarded);
23639 basic_json result;
23640 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23643 return res ? result : basic_json(value_t::discarded);
23662 basic_json result;
23663 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23667 return res ? result : basic_json(value_t::discarded);
23679 basic_json result;
23680 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23683 return res ? result : basic_json(value_t::discarded);
23694 basic_json result;
23695 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23698 return res ? result : basic_json(value_t::discarded);
23709 basic_json result;
23710 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23713 return res ? result : basic_json(value_t::discarded);
23724 basic_json result;
23725 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23728 return res ? result : basic_json(value_t::discarded);
23747 basic_json result;
23748 detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23752 return res ? result : basic_json(value_t::discarded);
23823 basic_json result(value_t::object);
23824 json_pointer::flatten("", *this, result);
23825 return result;
23848 basic_json& result = *this;
23883 const auto operation_add = [&result](json_pointer & ptr, basic_json val)
23888 result = val;
23896 result.at(top_pointer);
23903 basic_json& parent = result.at(ptr);
23951 const auto operation_remove = [this, &result](json_pointer & ptr)
23956 basic_json& parent = result.at(ptr);
24006 // check if result is of type string
24045 result.at(ptr) = get_value("replace", "value", false);
24055 basic_json v = result.at(from_ptr);
24072 basic_json v = result.at(from_ptr);
24088 success = (result.at(ptr) == get_value("test", "value", false));
24119 basic_json result = *this;
24120 result.patch_inplace(json_patch);
24121 return result;
24131 basic_json result(value_t::array);
24136 return result;
24142 result.push_back(
24146 return result;
24159 result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24167 const auto end_index = static_cast<difference_type>(result.size());
24172 result.insert(result.begin() + end_index, object(
24183 result.push_back(
24207 result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24212 result.push_back(object(
24226 result.push_back(
24248 result.push_back(
24256 return result;