_Z11string_joinRKNSt3__16vectorINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS4_IS6_EEEERKS6_: 507| 111k|std::string string_join(const std::vector & values, const std::string & separator) { 508| 111k| std::ostringstream result; 509| 2.94M| for (size_t i = 0; i < values.size(); ++i) { ------------------ | Branch (509:24): [True: 2.83M, False: 111k] ------------------ 510| 2.83M| if (i > 0) { ------------------ | Branch (510:13): [True: 2.72M, False: 106k] ------------------ 511| 2.72M| result << separator; 512| 2.72M| } 513| 2.83M| result << values[i]; 514| 2.83M| } 515| 111k| return result.str(); 516| 111k|} _Z12string_splitRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEES7_: 518| 47.4k|std::vector string_split(const std::string & str, const std::string & delimiter) { 519| 47.4k| std::vector parts; 520| 47.4k| size_t start = 0; 521| 47.4k| size_t end = str.find(delimiter); 522| | 523| 1.11M| while (end != std::string::npos) { ------------------ | Branch (523:12): [True: 1.06M, False: 47.4k] ------------------ 524| 1.06M| parts.push_back(str.substr(start, end - start)); 525| 1.06M| start = end + delimiter.length(); 526| 1.06M| end = str.find(delimiter, start); 527| 1.06M| } 528| | 529| 47.4k| parts.push_back(str.substr(start)); 530| | 531| 47.4k| return parts; 532| 47.4k|} _Z13string_repeatRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm: 534| 136k|std::string string_repeat(const std::string & str, size_t n) { 535| 136k| if (n == 0) { ------------------ | Branch (535:9): [True: 0, False: 136k] ------------------ 536| 0| return ""; 537| 0| } 538| | 539| 136k| std::string result; 540| 136k| result.reserve(str.length() * n); 541| | 542| 884k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (542:24): [True: 748k, False: 136k] ------------------ 543| 748k| result += str; 544| 748k| } 545| | 546| 136k| return result; 547| 136k|} _Z22json_schema_to_grammarRKN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEEb: 1158| 8.54k|std::string json_schema_to_grammar(const json & schema, bool force_gbnf) { 1159| |#ifdef LLAMA_USE_LLGUIDANCE 1160| | if (!force_gbnf) { 1161| | return "%llguidance {}\nstart: %json " + schema.dump(); 1162| | } 1163| |#else 1164| 8.54k| (void)force_gbnf; 1165| 8.54k|#endif // LLAMA_USE_LLGUIDANCE 1166| 8.54k| return build_grammar([&](const common_grammar_builder & callbacks) { 1167| 8.54k| auto copy = schema; 1168| 8.54k| callbacks.resolve_refs(copy); 1169| 8.54k| callbacks.add_schema("", copy); 1170| 8.54k| }); 1171| 8.54k|} _Z13build_grammarRKNSt3__18functionIFvRK22common_grammar_builderEEERK22common_grammar_options: 1173| 8.54k|std::string build_grammar(const std::function & cb, const common_grammar_options & options) { 1174| 8.54k| common_schema_converter converter([&](const std::string &) { return json(); }, options.dotall); 1175| 8.54k| common_grammar_builder builder { 1176| 8.54k| /* .add_rule = */ [&](const std::string & name, const std::string & rule) { 1177| 8.54k| return converter._add_rule(name, rule); 1178| 8.54k| }, 1179| 8.54k| /* .add_schema = */ [&](const std::string & name, const nlohmann::ordered_json & schema) { 1180| 8.54k| return converter.visit(schema, name == "root" ? "" : name); 1181| 8.54k| }, 1182| 8.54k| /* .resolve_refs = */ [&](nlohmann::ordered_json & schema) { 1183| 8.54k| converter.resolve_refs(schema, ""); 1184| 8.54k| } 1185| 8.54k| }; 1186| 8.54k| cb(builder); 1187| 8.54k| converter.check_errors(); 1188| 8.54k| return converter.format_grammar(); 1189| 8.54k|} json-schema-to-grammar.cpp:_ZL14format_literalRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 302| 239k|static std::string format_literal(const std::string & literal) { 303| 239k| std::string escaped = replacePattern(literal, GRAMMAR_LITERAL_ESCAPE_RE, [&](const std::smatch & match) { 304| 239k| char c = match.str()[0]; 305| 239k| return GRAMMAR_LITERAL_ESCAPES.at(c); 306| 239k| }); 307| 239k| return "\"" + escaped + "\""; 308| 239k|} json-schema-to-grammar.cpp:_ZL14replacePatternRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_11basic_regexIcNS_12regex_traitsIcEEEERKNS_8functionIFS5_RKNS_13match_resultsINS_11__wrap_iterIPKcEENS3_INS_9sub_matchISJ_EEEEEEEEE: 284| 239k|static std::string replacePattern(const std::string & input, const std::regex & regex, const std::function & replacement) { 285| 239k| std::smatch match; 286| 239k| std::string result; 287| | 288| 239k| std::string::const_iterator searchStart(input.cbegin()); 289| 239k| std::string::const_iterator searchEnd(input.cend()); 290| | 291| 716k| while (std::regex_search(searchStart, searchEnd, match, regex)) { ------------------ | Branch (291:12): [True: 476k, False: 239k] ------------------ 292| 476k| result.append(searchStart, searchStart + match.position()); 293| 476k| result.append(replacement(match)); 294| 476k| searchStart = match.suffix().first; 295| 476k| } 296| | 297| 239k| result.append(searchStart, searchEnd); 298| | 299| 239k| return result; 300| 239k|} json-schema-to-grammar.cpp:_ZZL14format_literalRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEENK3$_0clERKNS_13match_resultsINS_11__wrap_iterIPKcEENS3_INS_9sub_matchISD_EEEEEE: 303| 476k| std::string escaped = replacePattern(literal, GRAMMAR_LITERAL_ESCAPE_RE, [&](const std::smatch & match) { 304| 476k| char c = match.str()[0]; 305| 476k| return GRAMMAR_LITERAL_ESCAPES.at(c); 306| 476k| }); _ZN23common_schema_converter12resolve_refsERN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapENSt3__16vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdS9_NS1_14adl_serializerENS5_IhNS9_IhEEEEvEERKSB_: 761| 11.7k| void resolve_refs(json & schema, const std::string & url) { 762| | /* 763| | * Resolves all $ref fields in the given schema, fetching any remote schemas, 764| | * replacing each $ref with absolute reference URL and populates _refs with the 765| | * respective referenced (sub)schema dictionaries. 766| | */ 767| 11.7k| std::function visit_refs = [&](json & n) { 768| 11.7k| if (n.is_array()) { 769| 11.7k| for (auto & x : n) { 770| 11.7k| visit_refs(x); 771| 11.7k| } 772| 11.7k| } else if (n.is_object()) { 773| 11.7k| if (n.contains("$ref")) { 774| 11.7k| std::string ref = n["$ref"]; 775| 11.7k| if (_refs.find(ref) == _refs.end()) { 776| 11.7k| json target; 777| 11.7k| if (ref.find("https://") == 0) { 778| 11.7k| std::string base_url = ref.substr(0, ref.find('#')); 779| 11.7k| auto it = _refs.find(base_url); 780| 11.7k| if (it != _refs.end()) { 781| 11.7k| target = it->second; 782| 11.7k| } else { 783| | // Fetch the referenced schema and resolve its refs 784| 11.7k| auto referenced = _fetch_json(ref); 785| 11.7k| resolve_refs(referenced, base_url); 786| 11.7k| _refs[base_url] = referenced; 787| 11.7k| } 788| 11.7k| if (ref.find('#') == std::string::npos || ref.substr(ref.find('#') + 1).empty()) { 789| 11.7k| return; 790| 11.7k| } 791| 11.7k| } else if (ref.find("#/") == 0) { 792| 11.7k| target = schema; 793| 11.7k| n["$ref"] = url + ref; 794| 11.7k| ref = url + ref; 795| 11.7k| } else { 796| 11.7k| _errors.push_back("Unsupported ref: " + ref); 797| 11.7k| return; 798| 11.7k| } 799| 11.7k| std::string pointer = ref.substr(ref.find('#') + 1); 800| 11.7k| std::vector tokens = string_split(pointer, "/"); 801| 11.7k| for (size_t i = 1; i < tokens.size(); ++i) { 802| 11.7k| const std::string& sel = tokens[i]; 803| 11.7k| if (target.is_object() && target.contains(sel)) { 804| 11.7k| target = target[sel]; 805| 11.7k| } else if (target.is_array()) { 806| 11.7k| size_t sel_index; 807| 11.7k| try { 808| 11.7k| sel_index = std::stoull(sel); 809| 11.7k| } catch (const std::invalid_argument & e) { 810| 11.7k| sel_index = target.size(); 811| 11.7k| } 812| 11.7k| if (sel_index >= target.size()) { 813| 11.7k| _errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump()); 814| 11.7k| return; 815| 11.7k| } 816| 11.7k| target = target[sel_index]; 817| 11.7k| } else { 818| 11.7k| _errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump()); 819| 11.7k| return; 820| 11.7k| } 821| 11.7k| } 822| 11.7k| _refs[ref] = target; 823| 11.7k| } 824| 11.7k| } else { 825| 11.7k| for (const auto & kv : n.items()) { 826| 11.7k| visit_refs(kv.value()); 827| 11.7k| } 828| 11.7k| } 829| 11.7k| } 830| 11.7k| }; 831| | 832| 11.7k| visit_refs(schema); 833| 11.7k| } _ZZN23common_schema_converter12resolve_refsERN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapENSt3__16vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdS9_NS1_14adl_serializerENS5_IhNS9_IhEEEEvEERKSB_ENKUlSG_E_clESG_: 767| 4.61M| std::function visit_refs = [&](json & n) { 768| 4.61M| if (n.is_array()) { ------------------ | Branch (768:17): [True: 17.1k, False: 4.60M] ------------------ 769| 4.54M| for (auto & x : n) { ------------------ | Branch (769:31): [True: 4.54M, False: 17.1k] ------------------ 770| 4.54M| visit_refs(x); 771| 4.54M| } 772| 4.60M| } else if (n.is_object()) { ------------------ | Branch (772:24): [True: 68.3k, False: 4.53M] ------------------ 773| 68.3k| if (n.contains("$ref")) { ------------------ | Branch (773:21): [True: 26.9k, False: 41.3k] ------------------ 774| 26.9k| std::string ref = n["$ref"]; 775| 26.9k| if (_refs.find(ref) == _refs.end()) { ------------------ | Branch (775:25): [True: 23.1k, False: 3.87k] ------------------ 776| 23.1k| json target; 777| 23.1k| if (ref.find("https://") == 0) { ------------------ | Branch (777:29): [True: 6.35k, False: 16.7k] ------------------ 778| 6.35k| std::string base_url = ref.substr(0, ref.find('#')); 779| 6.35k| auto it = _refs.find(base_url); 780| 6.35k| if (it != _refs.end()) { ------------------ | Branch (780:33): [True: 3.13k, False: 3.22k] ------------------ 781| 3.13k| target = it->second; 782| 3.22k| } else { 783| | // Fetch the referenced schema and resolve its refs 784| 3.22k| auto referenced = _fetch_json(ref); 785| 3.22k| resolve_refs(referenced, base_url); 786| 3.22k| _refs[base_url] = referenced; 787| 3.22k| } 788| 6.35k| if (ref.find('#') == std::string::npos || ref.substr(ref.find('#') + 1).empty()) { ------------------ | Branch (788:33): [True: 697, False: 5.65k] | Branch (788:33): [True: 3.76k, False: 2.59k] | Branch (788:71): [True: 3.06k, False: 2.59k] ------------------ 789| 3.76k| return; 790| 3.76k| } 791| 16.7k| } else if (ref.find("#/") == 0) { ------------------ | Branch (791:36): [True: 8.21k, False: 8.53k] ------------------ 792| 8.21k| target = schema; 793| 8.21k| n["$ref"] = url + ref; 794| 8.21k| ref = url + ref; 795| 8.53k| } else { 796| 8.53k| _errors.push_back("Unsupported ref: " + ref); 797| 8.53k| return; 798| 8.53k| } 799| 10.8k| std::string pointer = ref.substr(ref.find('#') + 1); 800| 10.8k| std::vector tokens = string_split(pointer, "/"); 801| 17.2k| for (size_t i = 1; i < tokens.size(); ++i) { ------------------ | Branch (801:44): [True: 13.9k, False: 3.30k] ------------------ 802| 13.9k| const std::string& sel = tokens[i]; 803| 13.9k| if (target.is_object() && target.contains(sel)) { ------------------ | Branch (803:33): [True: 8.16k, False: 5.81k] | Branch (803:55): [True: 4.06k, False: 4.09k] ------------------ 804| 4.06k| target = target[sel]; 805| 9.90k| } else if (target.is_array()) { ------------------ | Branch (805:40): [True: 4.50k, False: 5.40k] ------------------ 806| 4.50k| size_t sel_index; 807| 4.50k| try { 808| 4.50k| sel_index = std::stoull(sel); 809| 4.50k| } catch (const std::invalid_argument & e) { 810| 1.26k| sel_index = target.size(); 811| 1.26k| } 812| 4.50k| if (sel_index >= target.size()) { ------------------ | Branch (812:37): [True: 2.09k, False: 2.40k] ------------------ 813| 2.09k| _errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump()); 814| 2.09k| return; 815| 2.09k| } 816| 2.40k| target = target[sel_index]; 817| 5.40k| } else { 818| 5.40k| _errors.push_back("Error resolving ref " + ref + ": " + sel + " not in " + target.dump()); 819| 5.40k| return; 820| 5.40k| } 821| 13.9k| } 822| 3.30k| _refs[ref] = target; 823| 3.30k| } 824| 41.3k| } else { 825| 60.6k| for (const auto & kv : n.items()) { ------------------ | Branch (825:42): [True: 60.6k, False: 41.3k] ------------------ 826| 60.6k| visit_refs(kv.value()); 827| 60.6k| } 828| 41.3k| } 829| 68.3k| } 830| 4.61M| }; _ZN23common_schema_converterC2ERKNSt3__18functionIFN8nlohmann16json_abi_v3_12_010basic_jsonINS3_11ordered_mapENS0_6vectorENS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEblmdSA_NS3_14adl_serializerENS6_IhNSA_IhEEEEvEERKSC_EEEb: 756| 8.54k| : _fetch_json(fetch_json), _dotall(dotall) 757| 8.54k| { 758| 8.54k| _rules["space"] = SPACE_RULE; 759| 8.54k| } _ZN23common_schema_converter12check_errorsEv: 1012| 8.41k| void check_errors() { 1013| 8.41k| if (!_errors.empty()) { ------------------ | Branch (1013:13): [True: 6.67k, False: 1.73k] ------------------ 1014| 6.67k| throw std::invalid_argument("JSON schema conversion failed:\n" + string_join(_errors, "\n")); 1015| 6.67k| } 1016| 1.73k| if (!_warnings.empty()) { ------------------ | Branch (1016:13): [True: 116, False: 1.61k] ------------------ 1017| | fprintf(stderr, "WARNING: JSON schema conversion was incomplete: %s\n", string_join(_warnings, "; ").c_str()); 1018| 116| } 1019| 1.73k| } _ZN23common_schema_converter14format_grammarEv: 1021| 1.73k| std::string format_grammar() { 1022| 1.73k| std::stringstream ss; 1023| 20.7k| for (const auto & kv : _rules) { ------------------ | Branch (1023:30): [True: 20.7k, False: 1.73k] ------------------ 1024| 20.7k| ss << kv.first << " ::= " << kv.second << '\n'; 1025| 20.7k| } 1026| 1.73k| return ss.str(); 1027| 1.73k| } json-schema-to-grammar.cpp:_ZZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEEbENK3$_0clERK22common_grammar_builder: 1166| 8.54k| return build_grammar([&](const common_grammar_builder & callbacks) { 1167| 8.54k| auto copy = schema; 1168| 8.54k| callbacks.resolve_refs(copy); 1169| 8.54k| callbacks.add_schema("", copy); 1170| 8.54k| }); json-schema-to-grammar.cpp:_ZZ13build_grammarRKNSt3__18functionIFvRK22common_grammar_builderEEERK22common_grammar_optionsENK3$_0clERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 1174| 3.22k| common_schema_converter converter([&](const std::string &) { return json(); }, options.dotall); _ZN23common_schema_converter9_add_ruleERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_: 324| 2.67M| std::string _add_rule(const std::string & name, const std::string & rule) { 325| 2.67M| std::string esc_name = regex_replace(name, INVALID_RULE_CHARS_RE, "-"); 326| 2.67M| if (_rules.find(esc_name) == _rules.end() || _rules[esc_name] == rule) { ------------------ | Branch (326:13): [True: 366k, False: 2.30M] | Branch (326:13): [True: 2.64M, False: 28.5k] | Branch (326:54): [True: 2.28M, False: 28.5k] ------------------ 327| 2.64M| _rules[esc_name] = rule; 328| 2.64M| return esc_name; 329| 2.64M| } 330| 28.5k| int i = 0; 331| 76.2k| while (_rules.find(esc_name + std::to_string(i)) != _rules.end() && _rules[esc_name + std::to_string(i)] != rule) { ------------------ | Branch (331:16): [True: 73.9k, False: 2.34k] | Branch (331:16): [True: 47.7k, False: 28.5k] | Branch (331:77): [True: 47.7k, False: 26.1k] ------------------ 332| 47.7k| i++; 333| 47.7k| } 334| 28.5k| std::string key = esc_name + std::to_string(i); 335| 28.5k| _rules[key] = rule; 336| 28.5k| return key; 337| 2.67M| } json-schema-to-grammar.cpp:_ZZ13build_grammarRKNSt3__18functionIFvRK22common_grammar_builderEEERK22common_grammar_optionsENK3$_2clERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKN8nlohmann16json_abi_v3_12_010basic_jsonINSL_11ordered_mapENS_6vectorESH_blmdSF_NSL_14adl_serializerENSO_IhNSF_IhEEEEvEE: 1179| 8.52k| /* .add_schema = */ [&](const std::string & name, const nlohmann::ordered_json & schema) { 1180| 8.52k| return converter.visit(schema, name == "root" ? "" : name); ------------------ | Branch (1180:44): [True: 0, False: 8.52k] ------------------ 1181| 8.52k| }, _ZN23common_schema_converter5visitERKN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapENSt3__16vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdS9_NS1_14adl_serializerENS5_IhNS9_IhEEEEvEERKSB_: 839| 603k| std::string visit(const json & schema, const std::string & name) { 840| 603k| json schema_type = schema.contains("type") ? schema["type"] : json(); ------------------ | Branch (840:28): [True: 75.4k, False: 527k] ------------------ 841| 603k| std::string schema_format = schema.contains("format") ? schema["format"].get() : ""; ------------------ | Branch (841:37): [True: 1.19k, False: 602k] ------------------ 842| 603k| std::string rule_name = is_reserved_name(name) ? name + "-" : name.empty() ? "root" : name; ------------------ | Branch (842:33): [True: 134, False: 603k] | Branch (842:71): [True: 9.49k, False: 593k] ------------------ 843| | 844| 603k| if (schema.contains("$ref")) { ------------------ | Branch (844:13): [True: 48.1k, False: 555k] ------------------ 845| 48.1k| return _add_rule(rule_name, _resolve_ref(schema["$ref"])); 846| 48.1k| } 847| 555k| if (schema.contains("oneOf") || schema.contains("anyOf")) { ------------------ | Branch (847:13): [True: 901, False: 554k] | Branch (847:41): [True: 345, False: 554k] ------------------ 848| 1.24k| std::vector alt_schemas = schema.contains("oneOf") ? schema["oneOf"].get>() : schema["anyOf"].get>(); ------------------ | Branch (848:45): [True: 896, False: 345] ------------------ 849| 1.24k| return _add_rule(rule_name, _generate_union_rule(name, alt_schemas)); 850| 1.24k| } 851| 554k| if (schema_type.is_array()) { ------------------ | Branch (851:13): [True: 6.51k, False: 547k] ------------------ 852| 6.51k| std::vector schema_types; 853| 74.2k| for (const auto & t : schema_type) { ------------------ | Branch (853:33): [True: 74.2k, False: 6.51k] ------------------ 854| 74.2k| json schema_copy(schema); 855| 74.2k| schema_copy["type"] = t; 856| 74.2k| schema_types.push_back(schema_copy); 857| 74.2k| } 858| 6.51k| return _add_rule(rule_name, _generate_union_rule(name, schema_types)); 859| 6.51k| } 860| 547k| if (schema.contains("const")) { ------------------ | Branch (860:13): [True: 2.46k, False: 545k] ------------------ 861| 2.46k| return _add_rule(rule_name, _generate_constant_rule(schema["const"]) + " space"); 862| 2.46k| } 863| 545k| if (schema.contains("enum")) { ------------------ | Branch (863:13): [True: 3.29k, False: 541k] ------------------ 864| 3.29k| std::vector enum_values; 865| 12.2k| for (const auto & v : schema["enum"]) { ------------------ | Branch (865:33): [True: 12.2k, False: 3.29k] ------------------ 866| 12.2k| enum_values.push_back(_generate_constant_rule(v)); 867| 12.2k| } 868| 3.29k| return _add_rule(rule_name, "(" + string_join(enum_values, " | ") + ") space"); 869| 3.29k| } 870| 541k| if ((schema_type.is_null() || schema_type == "object") ------------------ | Branch (870:14): [True: 484k, False: 57.4k] | Branch (870:39): [True: 81, False: 57.3k] ------------------ 871| 484k| && (schema.contains("properties") || ------------------ | Branch (871:21): [True: 3.75k, False: 480k] ------------------ 872| 480k| (schema.contains("additionalProperties") && schema["additionalProperties"] != true))) { ------------------ | Branch (872:22): [True: 664, False: 480k] | Branch (872:65): [True: 664, False: 0] ------------------ 873| 4.42k| std::unordered_set required; 874| 4.42k| if (schema.contains("required") && schema["required"].is_array()) { ------------------ | Branch (874:17): [True: 926, False: 3.49k] | Branch (874:48): [True: 783, False: 143] ------------------ 875| 23.3k| for (const auto & item : schema["required"]) { ------------------ | Branch (875:40): [True: 23.3k, False: 783] ------------------ 876| 23.3k| if (item.is_string()) { ------------------ | Branch (876:25): [True: 12.4k, False: 10.8k] ------------------ 877| 12.4k| required.insert(item.get()); 878| 12.4k| } 879| 23.3k| } 880| 783| } 881| 4.42k| std::vector> properties; 882| 4.42k| if (schema.contains("properties")) { ------------------ | Branch (882:17): [True: 3.75k, False: 664] ------------------ 883| 24.9k| for (const auto & prop : schema["properties"].items()) { ------------------ | Branch (883:40): [True: 24.9k, False: 3.75k] ------------------ 884| 24.9k| properties.emplace_back(prop.key(), prop.value()); 885| 24.9k| } 886| 3.75k| } 887| 4.42k| return _add_rule(rule_name, 888| 4.42k| _build_object_rule( 889| 4.42k| properties, required, name, 890| 4.42k| schema.contains("additionalProperties") ? schema["additionalProperties"] : json())); ------------------ | Branch (890:21): [True: 666, False: 3.75k] ------------------ 891| 4.42k| } 892| 537k| if ((schema_type.is_null() || schema_type == "object" || schema_type == "string") && schema.contains("allOf")) { ------------------ | Branch (892:14): [True: 479k, False: 57.4k] | Branch (892:39): [True: 81, False: 57.3k] | Branch (892:66): [True: 1.25k, False: 56.0k] | Branch (892:94): [True: 1.90k, False: 479k] ------------------ 893| 1.90k| std::unordered_set required; 894| 1.90k| std::vector> properties; 895| 1.90k| std::map enum_values; 896| 1.90k| const std::string& hybrid_name = name; 897| 1.90k| std::function add_component = [&](const json & comp_schema, bool is_required) { 898| 1.90k| if (comp_schema.contains("$ref")) { 899| 1.90k| add_component(_refs[comp_schema["$ref"]], is_required); 900| 1.90k| } else if (comp_schema.contains("properties")) { 901| 1.90k| for (const auto & prop : comp_schema["properties"].items()) { 902| 1.90k| properties.emplace_back(prop.key(), prop.value()); 903| 1.90k| if (is_required) { 904| 1.90k| required.insert(prop.key()); 905| 1.90k| } 906| 1.90k| } 907| 1.90k| } else if (comp_schema.contains("enum")) { 908| 1.90k| for (const auto & v : comp_schema["enum"]) { 909| 1.90k| const auto rule = _generate_constant_rule(v); 910| 1.90k| if (enum_values.find(rule) == enum_values.end()) { 911| 1.90k| enum_values[rule] = 0; 912| 1.90k| } 913| 1.90k| enum_values[rule] += 1; 914| 1.90k| } 915| 1.90k| } else { 916| | // todo warning 917| 1.90k| } 918| 1.90k| }; 919| 29.5k| for (const auto & t : schema["allOf"]) { ------------------ | Branch (919:33): [True: 29.5k, False: 1.90k] ------------------ 920| 29.5k| if (t.contains("anyOf")) { ------------------ | Branch (920:21): [True: 1.11k, False: 28.4k] ------------------ 921| 5.91k| for (const auto & tt : t["anyOf"]) { ------------------ | Branch (921:42): [True: 5.91k, False: 1.11k] ------------------ 922| 5.91k| add_component(tt, false); 923| 5.91k| } 924| 28.4k| } else { 925| 28.4k| add_component(t, true); 926| 28.4k| } 927| 29.5k| } 928| 1.90k| if (!enum_values.empty()) { ------------------ | Branch (928:17): [True: 198, False: 1.70k] ------------------ 929| 198| std::vector enum_intersection; 930| 2.44k| for (const auto & p : enum_values) { ------------------ | Branch (930:37): [True: 2.44k, False: 198] ------------------ 931| 2.44k| if (p.second == schema["allOf"].size()) { ------------------ | Branch (931:25): [True: 68, False: 2.37k] ------------------ 932| 68| enum_intersection.push_back(p.first); 933| 68| } 934| 2.44k| } 935| 198| if (!enum_intersection.empty()) { ------------------ | Branch (935:21): [True: 35, False: 163] ------------------ 936| 35| return _add_rule(rule_name, "(" + string_join(enum_intersection, " | ") + ") space"); 937| 35| } 938| 198| } 939| 1.87k| return _add_rule(rule_name, _build_object_rule(properties, required, hybrid_name, json())); 940| 1.90k| } 941| 535k| if ((schema_type.is_null() || schema_type == "array") && (schema.contains("items") || schema.contains("prefixItems"))) { ------------------ | Branch (941:14): [True: 478k, False: 57.4k] | Branch (941:39): [True: 396, False: 57.0k] | Branch (941:67): [True: 10.5k, False: 467k] | Branch (941:95): [True: 649, False: 467k] ------------------ 942| 11.1k| json items = schema.contains("items") ? schema["items"] : schema["prefixItems"]; ------------------ | Branch (942:26): [True: 10.5k, False: 649] ------------------ 943| 11.1k| if (items.is_array()) { ------------------ | Branch (943:17): [True: 3.37k, False: 7.81k] ------------------ 944| 3.37k| std::string rule = "\"[\" space "; 945| 184k| for (size_t i = 0; i < items.size(); i++) { ------------------ | Branch (945:36): [True: 180k, False: 3.37k] ------------------ 946| 180k| if (i > 0) { ------------------ | Branch (946:25): [True: 177k, False: 3.36k] ------------------ 947| 177k| rule += " \",\" space "; 948| 177k| } 949| 180k| rule += visit(items[i], name + (name.empty() ? "" : "-") + "tuple-" + std::to_string(i)); ------------------ | Branch (949:53): [True: 49.9k, False: 131k] ------------------ 950| 180k| } 951| 3.37k| rule += " \"]\" space"; 952| 3.37k| return _add_rule(rule_name, rule); 953| 3.37k| } 954| 7.81k| std::string item_rule_name = visit(items, name + (name.empty() ? "" : "-") + "item"); ------------------ | Branch (954:63): [True: 73, False: 7.73k] ------------------ 955| 7.81k| int min_items = schema.contains("minItems") ? schema["minItems"].get() : 0; ------------------ | Branch (955:29): [True: 1.50k, False: 6.30k] ------------------ 956| 7.81k| json max_items_json = schema.contains("maxItems") ? schema["maxItems"] : json(); ------------------ | Branch (956:35): [True: 4.75k, False: 3.05k] ------------------ 957| 7.81k| int max_items = max_items_json.is_number_integer() ? max_items_json.get() : std::numeric_limits::max(); ------------------ | Branch (957:29): [True: 4.23k, False: 3.57k] ------------------ 958| | 959| 7.81k| return _add_rule(rule_name, "\"[\" space " + build_repetition(item_rule_name, min_items, max_items, "\",\" space") + " \"]\" space"); 960| 11.1k| } 961| 524k| if ((schema_type.is_null() || schema_type == "string") && schema.contains("pattern")) { ------------------ | Branch (961:14): [True: 466k, False: 57.4k] | Branch (961:39): [True: 1.25k, False: 56.1k] | Branch (961:67): [True: 5.62k, False: 462k] ------------------ 962| 5.62k| return _visit_pattern(schema["pattern"], rule_name); 963| 5.62k| } 964| 518k| if ((schema_type.is_null() || schema_type == "string") && std::regex_match(schema_format, std::regex("^uuid[1-5]?$"))) { ------------------ | Branch (964:13): [True: 1, False: 518k] | Branch (964:14): [True: 461k, False: 57.4k] | Branch (964:39): [True: 1.25k, False: 56.1k] | Branch (964:67): [True: 1, False: 462k] ------------------ 965| 1| return _add_primitive(rule_name == "root" ? "root" : schema_format, PRIMITIVE_RULES.at("uuid")); ------------------ | Branch (965:35): [True: 1, False: 0] ------------------ 966| 1| } 967| 518k| if ((schema_type.is_null() || schema_type == "string") && STRING_FORMAT_RULES.find(schema_format + "-string") != STRING_FORMAT_RULES.end()) { ------------------ | Branch (967:13): [True: 0, False: 518k] | Branch (967:14): [True: 461k, False: 57.4k] | Branch (967:39): [True: 1.25k, False: 56.1k] | Branch (967:67): [True: 0, False: 462k] ------------------ 968| 0| auto prim_name = schema_format + "-string"; 969| 0| return _add_rule(rule_name, _add_primitive(prim_name, STRING_FORMAT_RULES.at(prim_name))); 970| 0| } 971| 518k| if (schema_type == "string" && (schema.contains("minLength") || schema.contains("maxLength"))) { ------------------ | Branch (971:13): [True: 1.25k, False: 517k] | Branch (971:41): [True: 37, False: 1.21k] | Branch (971:73): [True: 297, False: 916] ------------------ 972| 334| std::string char_rule = _add_primitive("char", PRIMITIVE_RULES.at("char")); 973| 334| int min_len = schema.contains("minLength") ? schema["minLength"].get() : 0; ------------------ | Branch (973:27): [True: 37, False: 297] ------------------ 974| 334| int max_len = schema.contains("maxLength") ? schema["maxLength"].get() : std::numeric_limits::max(); ------------------ | Branch (974:27): [True: 298, False: 36] ------------------ 975| 334| return _add_rule(rule_name, "\"\\\"\" " + build_repetition(char_rule, min_len, max_len) + " \"\\\"\" space"); 976| 334| } 977| 518k| if (schema_type == "integer" && (schema.contains("minimum") || schema.contains("exclusiveMinimum") || schema.contains("maximum") || schema.contains("exclusiveMaximum"))) { ------------------ | Branch (977:13): [True: 4.34k, False: 513k] | Branch (977:42): [True: 3.14k, False: 1.20k] | Branch (977:72): [True: 82, False: 1.12k] | Branch (977:111): [True: 683, False: 438] | Branch (977:141): [True: 50, False: 388] ------------------ 978| 3.95k| int64_t min_value = std::numeric_limits::min(); 979| 3.95k| int64_t max_value = std::numeric_limits::max(); 980| 3.95k| if (schema.contains("minimum")) { ------------------ | Branch (980:17): [True: 3.14k, False: 815] ------------------ 981| 3.14k| min_value = schema["minimum"].get(); 982| 3.14k| } else if (schema.contains("exclusiveMinimum")) { ------------------ | Branch (982:24): [True: 82, False: 733] ------------------ 983| 82| min_value = schema["exclusiveMinimum"].get() + 1; 984| 82| } 985| 3.95k| if (schema.contains("maximum")) { ------------------ | Branch (985:17): [True: 1.39k, False: 2.56k] ------------------ 986| 1.39k| max_value = schema["maximum"].get(); 987| 2.56k| } else if (schema.contains("exclusiveMaximum")) { ------------------ | Branch (987:24): [True: 51, False: 2.51k] ------------------ 988| 51| max_value = schema["exclusiveMaximum"].get() - 1; 989| 51| } 990| 3.95k| std::stringstream out; 991| 3.95k| out << "("; 992| 3.95k| build_min_max_int(min_value, max_value, out); 993| 3.95k| out << ") space"; 994| 3.95k| return _add_rule(rule_name, out.str()); 995| 3.95k| } 996| 514k| if (schema.empty() || schema_type == "object") { ------------------ | Branch (996:13): [True: 10.0k, False: 504k] | Branch (996:31): [True: 81, False: 504k] ------------------ 997| 10.1k| return _add_rule(rule_name, _add_primitive("object", PRIMITIVE_RULES.at("object"))); 998| 10.1k| } 999| 504k| if (schema_type.is_null() && schema.is_object()) { ------------------ | Branch (999:13): [True: 451k, False: 53.0k] | Branch (999:38): [True: 11.7k, False: 439k] ------------------ 1000| | // No type constraint and no recognized structural keywords (e.g. {"description": "..."}). 1001| | // Per JSON Schema semantics this is equivalent to {} and accepts any value. 1002| 11.7k| return _add_rule(rule_name, _add_primitive("value", PRIMITIVE_RULES.at("value"))); 1003| 11.7k| } 1004| 492k| if (!schema_type.is_string() || PRIMITIVE_RULES.find(schema_type.get()) == PRIMITIVE_RULES.end()) { ------------------ | Branch (1004:13): [True: 480k, False: 11.6k] | Branch (1004:13): [True: 490k, False: 1.84k] | Branch (1004:41): [True: 9.80k, False: 1.83k] ------------------ 1005| 490k| _errors.push_back("Unrecognized schema: " + schema.dump()); 1006| 490k| return ""; 1007| 490k| } 1008| | // TODO: support minimum, maximum, exclusiveMinimum, exclusiveMaximum at least for zero 1009| 1.84k| return _add_primitive(rule_name == "root" ? "root" : schema_type.get(), PRIMITIVE_RULES.at(schema_type.get())); ------------------ | Branch (1009:31): [True: 22, False: 1.81k] ------------------ 1010| 492k| } json-schema-to-grammar.cpp:_ZL16is_reserved_nameRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 259| 603k|static bool is_reserved_name(const std::string & name) { 260| 603k| static const std::unordered_set RESERVED_NAMES = [] { 261| 603k| std::unordered_set s; 262| 603k| s.insert("root"); 263| 603k| for (const auto & p : PRIMITIVE_RULES) { 264| 603k| s.insert(p.first); 265| 603k| } 266| 603k| for (const auto & p : STRING_FORMAT_RULES) { 267| 603k| s.insert(p.first); 268| 603k| } 269| 603k| return s; 270| 603k| }(); 271| 603k| return RESERVED_NAMES.find(name) != RESERVED_NAMES.end(); 272| 603k|} json-schema-to-grammar.cpp:_ZZL16is_reserved_nameRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEENK3$_0clEv: 260| 1| static const std::unordered_set RESERVED_NAMES = [] { 261| 1| std::unordered_set s; 262| 1| s.insert("root"); 263| 12| for (const auto & p : PRIMITIVE_RULES) { ------------------ | Branch (263:29): [True: 12, False: 1] ------------------ 264| 12| s.insert(p.first); 265| 12| } 266| 6| for (const auto & p : STRING_FORMAT_RULES) { ------------------ | Branch (266:29): [True: 6, False: 1] ------------------ 267| 6| s.insert(p.first); 268| 6| } 269| 1| return s; 270| 1| }(); _ZN23common_schema_converter12_resolve_refERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 626| 48.1k| std::string _resolve_ref(const std::string & ref) { 627| 48.1k| auto it = ref.find('#'); 628| 48.1k| std::string ref_fragment = it != std::string::npos ? ref.substr(it + 1) : ref; ------------------ | Branch (628:36): [True: 42.0k, False: 6.09k] ------------------ 629| 48.1k| static const std::regex nonalphanumeric_regex(R"([^a-zA-Z0-9-]+)"); 630| 48.1k| std::string ref_name = "ref" + std::regex_replace(ref_fragment, nonalphanumeric_regex, "-"); 631| 48.1k| if (_rules.find(ref_name) == _rules.end() && _refs_being_resolved.find(ref) == _refs_being_resolved.end()) { ------------------ | Branch (631:13): [True: 18.0k, False: 30.0k] | Branch (631:13): [True: 11.6k, False: 36.5k] | Branch (631:54): [True: 11.6k, False: 6.43k] ------------------ 632| 11.6k| _refs_being_resolved.insert(ref); 633| 11.6k| json resolved = _refs[ref]; 634| 11.6k| ref_name = visit(resolved, ref_name); 635| 11.6k| _refs_being_resolved.erase(ref); 636| 11.6k| } 637| 48.1k| return ref_name; 638| 48.1k| } _ZN23common_schema_converter20_generate_union_ruleERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERKNS0_6vectorIN8nlohmann16json_abi_v3_12_010basic_jsonINSB_11ordered_mapES9_S6_blmdS4_NSB_14adl_serializerENS9_IhNS4_IhEEEEvEENS4_ISH_EEEE: 339| 7.71k| std::string _generate_union_rule(const std::string & name, const std::vector & alt_schemas) { 340| 7.71k| std::vector rules; 341| 7.71k| rules.reserve(alt_schemas.size()); 342| 184k| for (size_t i = 0; i < alt_schemas.size(); i++) { ------------------ | Branch (342:28): [True: 176k, False: 7.71k] ------------------ 343| 176k| rules.push_back(visit(alt_schemas[i], name + (name.empty() ? "alternative-" : "-") + std::to_string(i))); ------------------ | Branch (343:59): [True: 149k, False: 27.4k] ------------------ 344| 176k| } 345| 7.71k| return string_join(rules, " | "); 346| 7.71k| } _ZN23common_schema_converter23_generate_constant_ruleERKN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapENSt3__16vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdS9_NS1_14adl_serializerENS5_IhNS9_IhEEEEvEE: 835| 22.1k| static std::string _generate_constant_rule(const json & value) { 836| 22.1k| return format_literal(value.dump()); 837| 22.1k| } _ZN23common_schema_converter18_build_object_ruleERKNSt3__16vectorINS0_4pairINS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEN8nlohmann16json_abi_v3_12_010basic_jsonINSA_11ordered_mapES1_S8_blmdS6_NSA_14adl_serializerENS1_IhNS6_IhEEEEvEEEENS6_ISH_EEEERKNS0_13unordered_setIS8_NS0_4hashIS8_EENS0_8equal_toIS8_EENS6_IS8_EEEERKS8_RKSG_: 645| 6.29k| { 646| 6.29k| std::vector required_props; 647| 6.29k| std::vector optional_props; 648| 6.29k| std::unordered_map prop_kv_rule_names; 649| 6.29k| std::vector prop_names; 650| 217k| for (const auto & kv : properties) { ------------------ | Branch (650:30): [True: 217k, False: 6.29k] ------------------ 651| 217k| const auto &prop_name = kv.first; 652| 217k| const auto &prop_schema = kv.second; 653| | 654| 217k| std::string prop_rule_name = visit(prop_schema, name + (name.empty() ? "" : "-") + prop_name); ------------------ | Branch (654:69): [True: 190k, False: 26.4k] ------------------ 655| 217k| prop_kv_rule_names[prop_name] = _add_rule( 656| 217k| name + (name.empty() ? "" : "-") + prop_name + "-kv", ------------------ | Branch (656:25): [True: 190k, False: 26.4k] ------------------ 657| 217k| format_literal(json(prop_name).dump()) + " space \":\" space " + prop_rule_name 658| 217k| ); 659| 217k| if (required.find(prop_name) != required.end()) { ------------------ | Branch (659:17): [True: 191k, False: 25.5k] ------------------ 660| 191k| required_props.push_back(prop_name); 661| 191k| } else { 662| 25.5k| optional_props.push_back(prop_name); 663| 25.5k| } 664| 217k| prop_names.push_back(prop_name); 665| 217k| } 666| 6.29k| if ((additional_properties.is_boolean() && additional_properties.get()) || additional_properties.is_object()) { ------------------ | Branch (666:14): [True: 0, False: 6.29k] | Branch (666:52): [True: 0, False: 0] | Branch (666:90): [True: 479, False: 5.75k] ------------------ 667| 479| std::string sub_name = name + (name.empty() ? "" : "-") + "additional"; ------------------ | Branch (667:44): [True: 4, False: 475] ------------------ 668| 479| std::string value_rule = 669| 479| additional_properties.is_object() ? visit(additional_properties, sub_name + "-value") ------------------ | Branch (669:17): [True: 479, False: 0] ------------------ 670| 479| : _add_primitive("value", PRIMITIVE_RULES.at("value")); 671| | 672| 479| auto key_rule = 673| 479| prop_names.empty() ? _add_primitive("string", PRIMITIVE_RULES.at("string")) ------------------ | Branch (673:17): [True: 474, False: 5] ------------------ 674| 479| : _add_rule(sub_name + "-k", _not_strings(prop_names)); 675| 479| std::string kv_rule = _add_rule(sub_name + "-kv", key_rule + " \":\" space " + value_rule); 676| 479| prop_kv_rule_names["*"] = kv_rule; 677| 479| optional_props.push_back("*"); 678| 479| } 679| | 680| 6.29k| std::string rule = "\"{\" space "; 681| 197k| for (size_t i = 0; i < required_props.size(); i++) { ------------------ | Branch (681:28): [True: 191k, False: 6.29k] ------------------ 682| 191k| if (i > 0) { ------------------ | Branch (682:17): [True: 190k, False: 1.14k] ------------------ 683| 190k| rule += " \",\" space "; 684| 190k| } 685| 191k| rule += prop_kv_rule_names[required_props[i]]; 686| 191k| } 687| | 688| 6.29k| if (!optional_props.empty()) { ------------------ | Branch (688:13): [True: 4.11k, False: 2.17k] ------------------ 689| 4.11k| rule += " ("; 690| 4.11k| if (!required_props.empty()) { ------------------ | Branch (690:17): [True: 28, False: 4.08k] ------------------ 691| 28| rule += " \",\" space ( "; 692| 28| } 693| | 694| 4.11k| std::function &, bool)> get_recursive_refs = [&](const std::vector & ks, bool first_is_optional) { 695| 4.11k| std::string res; 696| 4.11k| if (ks.empty()) { 697| 4.11k| return res; 698| 4.11k| } 699| 4.11k| const std::string& k = ks[0]; 700| 4.11k| std::string kv_rule_name = prop_kv_rule_names[k]; 701| 4.11k| std::string comma_ref = "( \",\" space " + kv_rule_name + " )"; 702| 4.11k| if (first_is_optional) { 703| 4.11k| res = comma_ref + (k == "*" ? "*" : "?"); 704| 4.11k| } else { 705| 4.11k| res = kv_rule_name + (k == "*" ? " " + comma_ref + "*" : ""); 706| 4.11k| } 707| 4.11k| if (ks.size() > 1) { 708| 4.11k| res += " " + _add_rule( 709| 4.11k| name + (name.empty() ? "" : "-") + k + "-rest", 710| 4.11k| get_recursive_refs(std::vector(ks.begin() + 1, ks.end()), true) 711| 4.11k| ); 712| 4.11k| } 713| 4.11k| return res; 714| 4.11k| }; 715| | 716| 28.5k| for (size_t i = 0; i < optional_props.size(); i++) { ------------------ | Branch (716:32): [True: 24.4k, False: 4.11k] ------------------ 717| 24.4k| if (i > 0) { ------------------ | Branch (717:21): [True: 20.3k, False: 4.11k] ------------------ 718| 20.3k| rule += " | "; 719| 20.3k| } 720| 24.4k| rule += get_recursive_refs(std::vector(optional_props.begin() + i, optional_props.end()), false); 721| 24.4k| } 722| 4.11k| if (!required_props.empty()) { ------------------ | Branch (722:17): [True: 28, False: 4.08k] ------------------ 723| 28| rule += " )"; 724| 28| } 725| 4.11k| rule += " )?"; 726| 4.11k| } 727| | 728| 6.29k| rule += " \"}\" space"; 729| | 730| 6.29k| return rule; 731| 6.29k| } _ZZN23common_schema_converter18_build_object_ruleERKNSt3__16vectorINS0_4pairINS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEN8nlohmann16json_abi_v3_12_010basic_jsonINSA_11ordered_mapES1_S8_blmdS6_NSA_14adl_serializerENS1_IhNS6_IhEEEEvEEEENS6_ISH_EEEERKNS0_13unordered_setIS8_NS0_4hashIS8_EENS0_8equal_toIS8_EENS6_IS8_EEEERKS8_RKSG_ENKUlRKNS1_IS8_SR_EEbE_clES11_b: 694| 727k| std::function &, bool)> get_recursive_refs = [&](const std::vector & ks, bool first_is_optional) { 695| 727k| std::string res; 696| 727k| if (ks.empty()) { ------------------ | Branch (696:21): [True: 0, False: 727k] ------------------ 697| 0| return res; 698| 0| } 699| 727k| const std::string& k = ks[0]; 700| 727k| std::string kv_rule_name = prop_kv_rule_names[k]; 701| 727k| std::string comma_ref = "( \",\" space " + kv_rule_name + " )"; 702| 727k| if (first_is_optional) { ------------------ | Branch (702:21): [True: 702k, False: 24.4k] ------------------ 703| 702k| res = comma_ref + (k == "*" ? "*" : "?"); ------------------ | Branch (703:40): [True: 180, False: 702k] ------------------ 704| 702k| } else { 705| 24.4k| res = kv_rule_name + (k == "*" ? " " + comma_ref + "*" : ""); ------------------ | Branch (705:43): [True: 500, False: 23.9k] ------------------ 706| 24.4k| } 707| 727k| if (ks.size() > 1) { ------------------ | Branch (707:21): [True: 702k, False: 24.4k] ------------------ 708| 702k| res += " " + _add_rule( 709| 702k| name + (name.empty() ? "" : "-") + k + "-rest", ------------------ | Branch (709:33): [True: 577k, False: 125k] ------------------ 710| 702k| get_recursive_refs(std::vector(ks.begin() + 1, ks.end()), true) 711| 702k| ); 712| 702k| } 713| 727k| return res; 714| 727k| }; _ZZN23common_schema_converter5visitERKN8nlohmann16json_abi_v3_12_010basic_jsonINS1_11ordered_mapENSt3__16vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdS9_NS1_14adl_serializerENS5_IhNS9_IhEEEEvEERKSB_ENKUlSH_bE_clESH_b: 897| 40.6k| std::function add_component = [&](const json & comp_schema, bool is_required) { 898| 40.6k| if (comp_schema.contains("$ref")) { ------------------ | Branch (898:21): [True: 6.23k, False: 34.3k] ------------------ 899| 6.23k| add_component(_refs[comp_schema["$ref"]], is_required); 900| 34.3k| } else if (comp_schema.contains("properties")) { ------------------ | Branch (900:28): [True: 2.36k, False: 31.9k] ------------------ 901| 192k| for (const auto & prop : comp_schema["properties"].items()) { ------------------ | Branch (901:44): [True: 192k, False: 2.36k] ------------------ 902| 192k| properties.emplace_back(prop.key(), prop.value()); 903| 192k| if (is_required) { ------------------ | Branch (903:29): [True: 191k, False: 875] ------------------ 904| 191k| required.insert(prop.key()); 905| 191k| } 906| 192k| } 907| 31.9k| } else if (comp_schema.contains("enum")) { ------------------ | Branch (907:28): [True: 2.43k, False: 29.5k] ------------------ 908| 7.48k| for (const auto & v : comp_schema["enum"]) { ------------------ | Branch (908:41): [True: 7.48k, False: 2.43k] ------------------ 909| 7.48k| const auto rule = _generate_constant_rule(v); 910| 7.48k| if (enum_values.find(rule) == enum_values.end()) { ------------------ | Branch (910:29): [True: 2.44k, False: 5.03k] ------------------ 911| 2.44k| enum_values[rule] = 0; 912| 2.44k| } 913| 7.48k| enum_values[rule] += 1; 914| 7.48k| } 915| 29.5k| } else { 916| | // todo warning 917| 29.5k| } 918| 40.6k| }; json-schema-to-grammar.cpp:_ZL16build_repetitionRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEiiS7_: 17| 47.9k|static std::string build_repetition(const std::string & item_rule, int min_items, int max_items, const std::string & separator_rule = "") { 18| 47.9k| auto has_max = max_items != std::numeric_limits::max(); 19| | 20| 47.9k| if (max_items == 0) { ------------------ | Branch (20:9): [True: 698, False: 47.2k] ------------------ 21| 698| return ""; 22| 698| } 23| 47.2k| if (min_items == 0 && max_items == 1) { ------------------ | Branch (23:9): [True: 35.6k, False: 11.5k] | Branch (23:27): [True: 25.6k, False: 10.0k] ------------------ 24| 25.6k| return item_rule + "?"; 25| 25.6k| } 26| | 27| 21.6k| if (separator_rule.empty()) { ------------------ | Branch (27:9): [True: 17.1k, False: 4.41k] ------------------ 28| 17.1k| if (min_items == 1 && !has_max) { ------------------ | Branch (28:13): [True: 3.20k, False: 13.9k] | Branch (28:31): [True: 784, False: 2.42k] ------------------ 29| 784| return item_rule + "+"; 30| 784| } 31| 16.4k| if (min_items == 0 && !has_max) { ------------------ | Branch (31:13): [True: 7.12k, False: 9.27k] | Branch (31:31): [True: 2.96k, False: 4.16k] ------------------ 32| 2.96k| return item_rule + "*"; 33| 2.96k| } 34| 13.4k| return item_rule + "{" + std::to_string(min_items) + "," + (has_max ? std::to_string(max_items) : "") + "}"; ------------------ | Branch (34:69): [True: 11.7k, False: 1.66k] ------------------ 35| 16.4k| } 36| | 37| 4.41k| auto result = item_rule + " " + build_repetition("(" + separator_rule + " " + item_rule + ")", min_items == 0 ? 0 : min_items - 1, has_max ? max_items - 1 : max_items); ------------------ | Branch (37:100): [True: 2.92k, False: 1.49k] | Branch (37:136): [True: 1.11k, False: 3.30k] ------------------ 38| 4.41k| if (min_items == 0) { ------------------ | Branch (38:9): [True: 2.92k, False: 1.49k] ------------------ 39| 2.92k| result = "(" + result + ")?"; 40| 2.92k| } 41| 4.41k| return result; 42| 21.6k|} _ZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_: 348| 5.61k| std::string _visit_pattern(const std::string & pattern, const std::string & name) { 349| 5.61k| if (!(pattern.front() == '^' && pattern.back() == '$')) { ------------------ | Branch (349:15): [True: 4.66k, False: 949] | Branch (349:41): [True: 3.90k, False: 764] ------------------ 350| 1.71k| _errors.push_back("Pattern must start with '^' and end with '$'"); 351| 1.71k| return ""; 352| 1.71k| } 353| 3.90k| std::string sub_pattern = pattern.substr(1, pattern.length() - 2); 354| 3.90k| std::unordered_map sub_rule_ids; 355| | 356| 3.90k| size_t i = 0; 357| 3.90k| size_t length = sub_pattern.length(); 358| | 359| 3.90k| using literal_or_rule = std::pair; 360| 3.90k| auto to_rule = [&](const literal_or_rule & ls) { 361| 3.90k| auto is_literal = ls.second; 362| 3.90k| auto s = ls.first; 363| 3.90k| return is_literal ? "\"" + s + "\"" : s; 364| 3.90k| }; 365| 3.90k| std::function transform = [&]() -> literal_or_rule { 366| 3.90k| size_t start = i; 367| 3.90k| std::vector seq; 368| | 369| 3.90k| auto get_dot = [&]() { 370| 3.90k| std::string rule; 371| 3.90k| if (_dotall) { 372| 3.90k| rule = "[\\U00000000-\\U0010FFFF]"; 373| 3.90k| } else { 374| 3.90k| rule = "[^\\x0A\\x0D]"; 375| 3.90k| } 376| 3.90k| return _add_rule("dot", rule); 377| 3.90k| }; 378| | 379| | // Joins the sequence, merging consecutive literals together. 380| 3.90k| auto join_seq = [&]() { 381| 3.90k| std::vector ret; 382| | 383| 3.90k| std::string literal; 384| 3.90k| auto flush_literal = [&]() { 385| 3.90k| if (literal.empty()) { 386| 3.90k| return false; 387| 3.90k| } 388| 3.90k| ret.emplace_back(literal, true); 389| 3.90k| literal.clear(); 390| 3.90k| return true; 391| 3.90k| }; 392| | 393| 3.90k| for (const auto & item : seq) { 394| 3.90k| auto is_literal = item.second; 395| 3.90k| if (is_literal) { 396| 3.90k| literal += item.first; 397| 3.90k| } else { 398| 3.90k| flush_literal(); 399| 3.90k| ret.push_back(item); 400| 3.90k| } 401| 3.90k| } 402| 3.90k| flush_literal(); 403| | 404| 3.90k| std::vector results; 405| 3.90k| results.reserve(ret.size()); 406| 3.90k| for (const auto & item : ret) { 407| 3.90k| results.push_back(to_rule(item)); 408| 3.90k| } 409| 3.90k| return std::make_pair(string_join(results, " "), false); 410| 3.90k| }; 411| | 412| 3.90k| while (i < length) { 413| 3.90k| char c = sub_pattern[i]; 414| 3.90k| if (c == '.') { 415| 3.90k| seq.emplace_back(get_dot(), false); 416| 3.90k| i++; 417| 3.90k| } else if (c == '(') { 418| 3.90k| i++; 419| 3.90k| if (i < length && sub_pattern[i] == '?') { 420| 3.90k| if (i + 1 < length && sub_pattern[i + 1] == ':') { 421| 3.90k| i += 2; // skip "?:" for non-capturing group, treat as regular group 422| 3.90k| } else { 423| | // lookahead/lookbehind (?=, ?!, ?<=, ? 0) { 428| 3.90k| if (sub_pattern[i] == '\\' && i + 1 < length) { 429| 3.90k| i += 2; // skip escaped character 430| 3.90k| } else { 431| 3.90k| if (sub_pattern[i] == '(') depth++; 432| 3.90k| else if (sub_pattern[i] == ')') depth--; 433| 3.90k| i++; 434| 3.90k| } 435| 3.90k| } 436| 3.90k| continue; 437| 3.90k| } 438| 3.90k| } 439| 3.90k| seq.emplace_back("(" + to_rule(transform()) + ")", false); 440| 3.90k| } else if (c == ')') { 441| 3.90k| i++; 442| 3.90k| if (start > 0 && sub_pattern[start - 1] != '(' && (start < 2 || sub_pattern[start - 2] != '?' || sub_pattern[start - 1] != ':')) { 443| 3.90k| _errors.push_back("Unbalanced parentheses"); 444| 3.90k| } 445| 3.90k| return join_seq(); 446| 3.90k| } else if (c == '[') { 447| 3.90k| std::string square_brackets = std::string(1, c); 448| 3.90k| i++; 449| 3.90k| while (i < length && sub_pattern[i] != ']') { 450| 3.90k| if (sub_pattern[i] == '\\') { 451| 3.90k| square_brackets += sub_pattern.substr(i, 2); 452| 3.90k| i += 2; 453| 3.90k| } else { 454| 3.90k| square_brackets += sub_pattern[i]; 455| 3.90k| i++; 456| 3.90k| } 457| 3.90k| } 458| 3.90k| if (i >= length) { 459| 3.90k| _errors.push_back("Unbalanced square brackets"); 460| 3.90k| } 461| 3.90k| square_brackets += ']'; 462| 3.90k| i++; 463| 3.90k| seq.emplace_back(square_brackets, false); 464| 3.90k| } else if (c == '|') { 465| 3.90k| seq.emplace_back("|", false); 466| 3.90k| i++; 467| 3.90k| } else if (c == '*' || c == '+' || c == '?') { 468| 3.90k| seq.back() = std::make_pair(to_rule(seq.back()) + c, false); 469| 3.90k| i++; 470| 3.90k| } else if (c == '{') { 471| 3.90k| std::string curly_brackets = std::string(1, c); 472| 3.90k| i++; 473| 3.90k| while (i < length && sub_pattern[i] != '}') { 474| 3.90k| curly_brackets += sub_pattern[i]; 475| 3.90k| i++; 476| 3.90k| } 477| 3.90k| if (i >= length) { 478| 3.90k| _errors.push_back("Unbalanced curly brackets"); 479| 3.90k| } 480| 3.90k| curly_brackets += '}'; 481| 3.90k| i++; 482| 3.90k| auto nums = string_split(curly_brackets.substr(1, curly_brackets.length() - 2), ","); 483| 3.90k| int min_times = 0; 484| 3.90k| int max_times = std::numeric_limits::max(); 485| 3.90k| try { 486| 3.90k| if (nums.size() == 1) { 487| 3.90k| min_times = max_times = std::stoi(nums[0]); 488| 3.90k| } else if (nums.size() != 2) { 489| 3.90k| _errors.push_back("Wrong number of values in curly brackets"); 490| 3.90k| } else { 491| 3.90k| if (!nums[0].empty()) { 492| 3.90k| min_times = std::stoi(nums[0]); 493| 3.90k| } 494| 3.90k| if (!nums[1].empty()) { 495| 3.90k| max_times = std::stoi(nums[1]); 496| 3.90k| } 497| 3.90k| } 498| 3.90k| } catch (const std::invalid_argument & e) { 499| 3.90k| _errors.push_back("Invalid number in curly brackets"); 500| 3.90k| return std::make_pair("", false); 501| 3.90k| } 502| 3.90k| auto &last = seq.back(); 503| 3.90k| auto &sub = last.first; 504| 3.90k| auto sub_is_literal = last.second; 505| | 506| 3.90k| if (!sub_is_literal) { 507| 3.90k| std::string & sub_id = sub_rule_ids[sub]; 508| 3.90k| if (sub_id.empty()) { 509| 3.90k| sub_id = _add_rule(name + "-" + std::to_string(sub_rule_ids.size()), sub); 510| 3.90k| } 511| 3.90k| sub = sub_id; 512| 3.90k| } 513| 3.90k| seq.back().first = build_repetition( 514| 3.90k| sub_is_literal ? "\"" + sub + "\"" : sub, 515| 3.90k| min_times, 516| 3.90k| max_times, 517| 3.90k| "" 518| 3.90k| ); 519| 3.90k| seq.back().second = false; 520| 3.90k| } else { 521| 3.90k| std::string literal; 522| 3.90k| auto is_non_literal = [&](char c) { 523| 3.90k| return NON_LITERAL_SET.find(c) != NON_LITERAL_SET.end(); 524| 3.90k| }; 525| 3.90k| while (i < length) { 526| 3.90k| if (sub_pattern[i] == '\\' && i < length - 1) { 527| 3.90k| char next = sub_pattern[i + 1]; 528| 3.90k| if (ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.find(next) != ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.end()) { 529| 3.90k| i++; 530| 3.90k| literal += sub_pattern[i]; 531| 3.90k| i++; 532| 3.90k| } else { 533| 3.90k| literal += sub_pattern.substr(i, 2); 534| 3.90k| i += 2; 535| 3.90k| } 536| 3.90k| } else if (sub_pattern[i] == '"') { 537| 3.90k| literal += "\\\""; 538| 3.90k| i++; 539| 3.90k| } else if (!is_non_literal(sub_pattern[i]) && 540| 3.90k| (i == length - 1 || literal.empty() || sub_pattern[i + 1] == '.' || !is_non_literal(sub_pattern[i + 1]))) { 541| 3.90k| literal += sub_pattern[i]; 542| 3.90k| i++; 543| 3.90k| } else { 544| 3.90k| break; 545| 3.90k| } 546| 3.90k| } 547| 3.90k| if (!literal.empty()) { 548| 3.90k| seq.emplace_back(literal, true); 549| 3.90k| } 550| 3.90k| } 551| 3.90k| } 552| 3.90k| return join_seq(); 553| 3.90k| }; 554| 3.90k| return _add_rule(name, "\"\\\"\" (" + to_rule(transform()) + ") \"\\\"\" space"); 555| 5.61k| } _ZZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_ENKUlvE_clEv: 365| 95.3k| std::function transform = [&]() -> literal_or_rule { 366| 95.3k| size_t start = i; 367| 95.3k| std::vector seq; 368| | 369| 95.3k| auto get_dot = [&]() { 370| 95.3k| std::string rule; 371| 95.3k| if (_dotall) { 372| 95.3k| rule = "[\\U00000000-\\U0010FFFF]"; 373| 95.3k| } else { 374| 95.3k| rule = "[^\\x0A\\x0D]"; 375| 95.3k| } 376| 95.3k| return _add_rule("dot", rule); 377| 95.3k| }; 378| | 379| | // Joins the sequence, merging consecutive literals together. 380| 95.3k| auto join_seq = [&]() { 381| 95.3k| std::vector ret; 382| | 383| 95.3k| std::string literal; 384| 95.3k| auto flush_literal = [&]() { 385| 95.3k| if (literal.empty()) { 386| 95.3k| return false; 387| 95.3k| } 388| 95.3k| ret.emplace_back(literal, true); 389| 95.3k| literal.clear(); 390| 95.3k| return true; 391| 95.3k| }; 392| | 393| 95.3k| for (const auto & item : seq) { 394| 95.3k| auto is_literal = item.second; 395| 95.3k| if (is_literal) { 396| 95.3k| literal += item.first; 397| 95.3k| } else { 398| 95.3k| flush_literal(); 399| 95.3k| ret.push_back(item); 400| 95.3k| } 401| 95.3k| } 402| 95.3k| flush_literal(); 403| | 404| 95.3k| std::vector results; 405| 95.3k| results.reserve(ret.size()); 406| 95.3k| for (const auto & item : ret) { 407| 95.3k| results.push_back(to_rule(item)); 408| 95.3k| } 409| 95.3k| return std::make_pair(string_join(results, " "), false); 410| 95.3k| }; 411| | 412| 2.30M| while (i < length) { ------------------ | Branch (412:20): [True: 2.21M, False: 83.3k] ------------------ 413| 2.21M| char c = sub_pattern[i]; 414| 2.21M| if (c == '.') { ------------------ | Branch (414:21): [True: 1.59M, False: 620k] ------------------ 415| 1.59M| seq.emplace_back(get_dot(), false); 416| 1.59M| i++; 417| 1.59M| } else if (c == '(') { ------------------ | Branch (417:28): [True: 94.6k, False: 526k] ------------------ 418| 94.6k| i++; 419| 94.6k| if (i < length && sub_pattern[i] == '?') { ------------------ | Branch (419:25): [True: 94.4k, False: 195] | Branch (419:39): [True: 4.00k, False: 90.4k] ------------------ 420| 4.00k| if (i + 1 < length && sub_pattern[i + 1] == ':') { ------------------ | Branch (420:29): [True: 4.00k, False: 3] | Branch (420:47): [True: 842, False: 3.15k] ------------------ 421| 842| i += 2; // skip "?:" for non-capturing group, treat as regular group 422| 3.16k| } else { 423| | // lookahead/lookbehind (?=, ?!, ?<=, ? 0) { ------------------ | Branch (427:36): [True: 95.3k, False: 42] | Branch (427:50): [True: 92.2k, False: 3.11k] ------------------ 428| 92.2k| if (sub_pattern[i] == '\\' && i + 1 < length) { ------------------ | Branch (428:37): [True: 236, False: 91.9k] | Branch (428:63): [True: 236, False: 0] ------------------ 429| 236| i += 2; // skip escaped character 430| 91.9k| } else { 431| 91.9k| if (sub_pattern[i] == '(') depth++; ------------------ | Branch (431:41): [True: 2.30k, False: 89.6k] ------------------ 432| 89.6k| else if (sub_pattern[i] == ')') depth--; ------------------ | Branch (432:46): [True: 4.04k, False: 85.6k] ------------------ 433| 91.9k| i++; 434| 91.9k| } 435| 92.2k| } 436| 3.16k| continue; 437| 3.16k| } 438| 4.00k| } 439| 91.4k| seq.emplace_back("(" + to_rule(transform()) + ")", false); 440| 526k| } else if (c == ')') { ------------------ | Branch (440:28): [True: 11.0k, False: 515k] ------------------ 441| 11.0k| i++; 442| 11.0k| if (start > 0 && sub_pattern[start - 1] != '(' && (start < 2 || sub_pattern[start - 2] != '?' || sub_pattern[start - 1] != ':')) { ------------------ | Branch (442:25): [True: 10.7k, False: 247] | Branch (442:38): [True: 180, False: 10.5k] | Branch (442:72): [True: 0, False: 180] | Branch (442:85): [True: 0, False: 180] | Branch (442:118): [True: 0, False: 180] ------------------ 443| 0| _errors.push_back("Unbalanced parentheses"); 444| 0| } 445| 11.0k| return join_seq(); 446| 515k| } else if (c == '[') { ------------------ | Branch (446:28): [True: 10.2k, False: 504k] ------------------ 447| 10.2k| std::string square_brackets = std::string(1, c); 448| 10.2k| i++; 449| 1.51M| while (i < length && sub_pattern[i] != ']') { ------------------ | Branch (449:28): [True: 1.51M, False: 833] | Branch (449:42): [True: 1.50M, False: 9.44k] ------------------ 450| 1.50M| if (sub_pattern[i] == '\\') { ------------------ | Branch (450:29): [True: 43.7k, False: 1.45M] ------------------ 451| 43.7k| square_brackets += sub_pattern.substr(i, 2); 452| 43.7k| i += 2; 453| 1.45M| } else { 454| 1.45M| square_brackets += sub_pattern[i]; 455| 1.45M| i++; 456| 1.45M| } 457| 1.50M| } 458| 10.2k| if (i >= length) { ------------------ | Branch (458:25): [True: 833, False: 9.44k] ------------------ 459| 833| _errors.push_back("Unbalanced square brackets"); 460| 833| } 461| 10.2k| square_brackets += ']'; 462| 10.2k| i++; 463| 10.2k| seq.emplace_back(square_brackets, false); 464| 504k| } else if (c == '|') { ------------------ | Branch (464:28): [True: 137k, False: 367k] ------------------ 465| 137k| seq.emplace_back("|", false); 466| 137k| i++; 467| 367k| } else if (c == '*' || c == '+' || c == '?') { ------------------ | Branch (467:28): [True: 405, False: 366k] | Branch (467:40): [True: 2.38k, False: 364k] | Branch (467:52): [True: 3.97k, False: 360k] ------------------ 468| 6.76k| seq.back() = std::make_pair(to_rule(seq.back()) + c, false); 469| 6.76k| i++; 470| 360k| } else if (c == '{') { ------------------ | Branch (470:28): [True: 36.6k, False: 323k] ------------------ 471| 36.6k| std::string curly_brackets = std::string(1, c); 472| 36.6k| i++; 473| 4.78M| while (i < length && sub_pattern[i] != '}') { ------------------ | Branch (473:28): [True: 4.78M, False: 1.08k] | Branch (473:42): [True: 4.74M, False: 35.5k] ------------------ 474| 4.74M| curly_brackets += sub_pattern[i]; 475| 4.74M| i++; 476| 4.74M| } 477| 36.6k| if (i >= length) { ------------------ | Branch (477:25): [True: 1.08k, False: 35.5k] ------------------ 478| 1.08k| _errors.push_back("Unbalanced curly brackets"); 479| 1.08k| } 480| 36.6k| curly_brackets += '}'; 481| 36.6k| i++; 482| 36.6k| auto nums = string_split(curly_brackets.substr(1, curly_brackets.length() - 2), ","); 483| 36.6k| int min_times = 0; 484| 36.6k| int max_times = std::numeric_limits::max(); 485| 36.6k| try { 486| 36.6k| if (nums.size() == 1) { ------------------ | Branch (486:29): [True: 6.85k, False: 29.7k] ------------------ 487| 6.85k| min_times = max_times = std::stoi(nums[0]); 488| 29.7k| } else if (nums.size() != 2) { ------------------ | Branch (488:36): [True: 941, False: 28.8k] ------------------ 489| 941| _errors.push_back("Wrong number of values in curly brackets"); 490| 28.8k| } else { 491| 28.8k| if (!nums[0].empty()) { ------------------ | Branch (491:33): [True: 27.0k, False: 1.77k] ------------------ 492| 27.0k| min_times = std::stoi(nums[0]); 493| 27.0k| } 494| 28.8k| if (!nums[1].empty()) { ------------------ | Branch (494:33): [True: 27.5k, False: 1.26k] ------------------ 495| 27.5k| max_times = std::stoi(nums[1]); 496| 27.5k| } 497| 28.8k| } 498| 36.6k| } catch (const std::invalid_argument & e) { 499| 977| _errors.push_back("Invalid number in curly brackets"); 500| 977| return std::make_pair("", false); 501| 977| } 502| 35.6k| auto &last = seq.back(); 503| 35.6k| auto &sub = last.first; 504| 35.6k| auto sub_is_literal = last.second; 505| | 506| 35.6k| if (!sub_is_literal) { ------------------ | Branch (506:25): [True: 8.40k, False: 27.2k] ------------------ 507| 8.40k| std::string & sub_id = sub_rule_ids[sub]; 508| 8.40k| if (sub_id.empty()) { ------------------ | Branch (508:29): [True: 4.67k, False: 3.72k] ------------------ 509| 4.67k| sub_id = _add_rule(name + "-" + std::to_string(sub_rule_ids.size()), sub); 510| 4.67k| } 511| 8.40k| sub = sub_id; 512| 8.40k| } 513| 35.6k| seq.back().first = build_repetition( 514| 35.6k| sub_is_literal ? "\"" + sub + "\"" : sub, ------------------ | Branch (514:25): [True: 27.2k, False: 8.40k] ------------------ 515| 35.6k| min_times, 516| 35.6k| max_times, 517| 35.6k| "" 518| 35.6k| ); 519| 35.6k| seq.back().second = false; 520| 323k| } else { 521| 323k| std::string literal; 522| 323k| auto is_non_literal = [&](char c) { 523| 323k| return NON_LITERAL_SET.find(c) != NON_LITERAL_SET.end(); 524| 323k| }; 525| 25.7M| while (i < length) { ------------------ | Branch (525:28): [True: 25.7M, False: 1.27k] ------------------ 526| 25.7M| if (sub_pattern[i] == '\\' && i < length - 1) { ------------------ | Branch (526:29): [True: 61.2k, False: 25.6M] | Branch (526:55): [True: 61.2k, False: 6] ------------------ 527| 61.2k| char next = sub_pattern[i + 1]; 528| 61.2k| if (ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.find(next) != ESCAPED_IN_REGEXPS_BUT_NOT_IN_LITERALS.end()) { ------------------ | Branch (528:33): [True: 512, False: 60.7k] ------------------ 529| 512| i++; 530| 512| literal += sub_pattern[i]; 531| 512| i++; 532| 60.7k| } else { 533| 60.7k| literal += sub_pattern.substr(i, 2); 534| 60.7k| i += 2; 535| 60.7k| } 536| 25.6M| } else if (sub_pattern[i] == '"') { ------------------ | Branch (536:36): [True: 388, False: 25.6M] ------------------ 537| 388| literal += "\\\""; 538| 388| i++; 539| 25.6M| } else if (!is_non_literal(sub_pattern[i]) && ------------------ | Branch (539:36): [True: 25.3M, False: 298k] ------------------ 540| 25.3M| (i == length - 1 || literal.empty() || sub_pattern[i + 1] == '.' || !is_non_literal(sub_pattern[i + 1]))) { ------------------ | Branch (540:34): [True: 1.26k, False: 25.3M] | Branch (540:53): [True: 323k, False: 25.0M] | Branch (540:72): [True: 26.0k, False: 25.0M] | Branch (540:101): [True: 24.9M, False: 23.7k] ------------------ 541| 25.3M| literal += sub_pattern[i]; 542| 25.3M| i++; 543| 25.3M| } else { 544| 322k| break; 545| 322k| } 546| 25.7M| } 547| 323k| if (!literal.empty()) { ------------------ | Branch (547:25): [True: 323k, False: 0] ------------------ 548| 323k| seq.emplace_back(literal, true); 549| 323k| } 550| 323k| } 551| 2.21M| } 552| 83.3k| return join_seq(); 553| 95.3k| }; _ZZZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_ENKUlvE_clEvENKUlvE_clEv: 369| 1.59M| auto get_dot = [&]() { 370| 1.59M| std::string rule; 371| 1.59M| if (_dotall) { ------------------ | Branch (371:21): [True: 0, False: 1.59M] ------------------ 372| 0| rule = "[\\U00000000-\\U0010FFFF]"; 373| 1.59M| } else { 374| 1.59M| rule = "[^\\x0A\\x0D]"; 375| 1.59M| } 376| 1.59M| return _add_rule("dot", rule); 377| 1.59M| }; _ZZZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_ENKUlvE_clEvENKUlvE0_clEv: 380| 94.1k| auto join_seq = [&]() { 381| 94.1k| std::vector ret; 382| | 383| 94.1k| std::string literal; 384| 94.1k| auto flush_literal = [&]() { 385| 94.1k| if (literal.empty()) { 386| 94.1k| return false; 387| 94.1k| } 388| 94.1k| ret.emplace_back(literal, true); 389| 94.1k| literal.clear(); 390| 94.1k| return true; 391| 94.1k| }; 392| | 393| 2.15M| for (const auto & item : seq) { ------------------ | Branch (393:40): [True: 2.15M, False: 94.1k] ------------------ 394| 2.15M| auto is_literal = item.second; 395| 2.15M| if (is_literal) { ------------------ | Branch (395:25): [True: 291k, False: 1.86M] ------------------ 396| 291k| literal += item.first; 397| 1.86M| } else { 398| 1.86M| flush_literal(); 399| 1.86M| ret.push_back(item); 400| 1.86M| } 401| 2.15M| } 402| 94.1k| flush_literal(); 403| | 404| 94.1k| std::vector results; 405| 94.1k| results.reserve(ret.size()); 406| 2.13M| for (const auto & item : ret) { ------------------ | Branch (406:40): [True: 2.13M, False: 94.1k] ------------------ 407| 2.13M| results.push_back(to_rule(item)); 408| 2.13M| } 409| 94.1k| return std::make_pair(string_join(results, " "), false); 410| 94.1k| }; _ZZZZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_ENKUlvE_clEvENKUlvE0_clEvENKUlvE_clEv: 384| 1.95M| auto flush_literal = [&]() { 385| 1.95M| if (literal.empty()) { ------------------ | Branch (385:25): [True: 1.68M, False: 271k] ------------------ 386| 1.68M| return false; 387| 1.68M| } 388| 271k| ret.emplace_back(literal, true); 389| 271k| literal.clear(); 390| 271k| return true; 391| 1.95M| }; _ZZZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_ENKUlvE_clEvENKUlcE_clEc: 522| 50.6M| auto is_non_literal = [&](char c) { 523| 50.6M| return NON_LITERAL_SET.find(c) != NON_LITERAL_SET.end(); 524| 50.6M| }; _ZZN23common_schema_converter14_visit_patternERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_ENKUlRKNS0_4pairIS6_bEEE_clESC_: 360| 2.23M| auto to_rule = [&](const literal_or_rule & ls) { 361| 2.23M| auto is_literal = ls.second; 362| 2.23M| auto s = ls.first; 363| 2.23M| return is_literal ? "\"" + s + "\"" : s; ------------------ | Branch (363:20): [True: 273k, False: 1.96M] ------------------ 364| 2.23M| }; _ZN23common_schema_converter14_add_primitiveERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEERK11BuiltinRule: 733| 46.5k| std::string _add_primitive(const std::string & name, const BuiltinRule & rule) { 734| 46.5k| auto n = _add_rule(name, rule.content); 735| 114k| for (const auto & dep : rule.deps) { ------------------ | Branch (735:31): [True: 114k, False: 46.5k] ------------------ 736| 114k| BuiltinRule dep_rule; 737| 114k| auto it = PRIMITIVE_RULES.find(dep); 738| 114k| if (it == PRIMITIVE_RULES.end()) { ------------------ | Branch (738:17): [True: 0, False: 114k] ------------------ 739| 0| it = STRING_FORMAT_RULES.find(dep); 740| 0| if (it == STRING_FORMAT_RULES.end()) { ------------------ | Branch (740:21): [True: 0, False: 0] ------------------ 741| 0| _errors.push_back("Rule " + dep + " not known"); 742| 0| continue; 743| 0| } 744| 0| } 745| 114k| if (_rules.find(dep) == _rules.end()) { ------------------ | Branch (745:17): [True: 22.0k, False: 92.0k] ------------------ 746| 22.0k| _add_primitive(dep, it->second); 747| 22.0k| } 748| 114k| } 749| 46.5k| return n; 750| 46.5k| } json-schema-to-grammar.cpp:_ZL17build_min_max_intllRNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEEib: 44| 17.3k|static void build_min_max_int(int64_t min_value, int64_t max_value, std::stringstream & out, int decimals_left = 16, bool top_level = true) { 45| 17.3k| auto has_min = min_value != std::numeric_limits::min(); 46| 17.3k| auto has_max = max_value != std::numeric_limits::max(); 47| | 48| 17.3k| auto digit_range = [&](char from, char to) { 49| 17.3k| out << "["; 50| 17.3k| if (from == to) { 51| 17.3k| out << from; 52| 17.3k| } else { 53| 17.3k| out << from << "-" << to; 54| 17.3k| } 55| 17.3k| out << "]"; 56| 17.3k| }; 57| 17.3k| auto more_digits = [&](int min_digits, int max_digits) { 58| 17.3k| out << "[0-9]"; 59| 17.3k| if (min_digits == max_digits && min_digits == 1) { 60| 17.3k| return; 61| 17.3k| } 62| 17.3k| out << "{"; 63| 17.3k| out << min_digits; 64| 17.3k| if (max_digits != min_digits) { 65| 17.3k| out << ","; 66| 17.3k| if (max_digits != std::numeric_limits::max()) { 67| 17.3k| out << max_digits; 68| 17.3k| } 69| 17.3k| } 70| 17.3k| out << "}"; 71| 17.3k| }; 72| 17.3k| std::function uniform_range = 73| 17.3k| [&](const std::string_view & from, const std::string_view & to) { 74| 17.3k| size_t i = 0; 75| 17.3k| while (i < from.length() && i < to.length() && from[i] == to[i]) { 76| 17.3k| i++; 77| 17.3k| } 78| 17.3k| if (i > 0) { 79| 17.3k| out << "\"" << from.substr(0, i) << "\""; 80| 17.3k| } 81| 17.3k| if (i < from.length() && i < to.length()) { 82| 17.3k| if (i > 0) { 83| 17.3k| out << " "; 84| 17.3k| } 85| 17.3k| auto sub_len = from.length() - i - 1; 86| 17.3k| if (sub_len > 0) { 87| 17.3k| auto from_sub = from.substr(i + 1); 88| 17.3k| auto to_sub = to.substr(i + 1); 89| 17.3k| auto sub_zeros = string_repeat("0", sub_len); 90| 17.3k| auto sub_nines = string_repeat("9", sub_len); 91| | 92| 17.3k| auto to_reached = false; 93| 17.3k| out << "("; 94| 17.3k| if (from_sub == sub_zeros) { 95| 17.3k| digit_range(from[i], to[i] - 1); 96| 17.3k| out << " "; 97| 17.3k| more_digits(sub_len, sub_len); 98| 17.3k| } else { 99| 17.3k| out << "[" << from[i] << "] "; 100| 17.3k| out << "("; 101| 17.3k| uniform_range(from_sub, sub_nines); 102| 17.3k| out << ")"; 103| 17.3k| if (from[i] < to[i] - 1) { 104| 17.3k| out << " | "; 105| 17.3k| if (to_sub == sub_nines) { 106| 17.3k| digit_range(from[i] + 1, to[i]); 107| 17.3k| to_reached = true; 108| 17.3k| } else { 109| 17.3k| digit_range(from[i] + 1, to[i] - 1); 110| 17.3k| } 111| 17.3k| out << " "; 112| 17.3k| more_digits(sub_len, sub_len); 113| 17.3k| } 114| 17.3k| } 115| 17.3k| if (!to_reached) { 116| 17.3k| out << " | "; 117| 17.3k| digit_range(to[i], to[i]); 118| 17.3k| out << " "; 119| 17.3k| uniform_range(sub_zeros, to_sub); 120| 17.3k| } 121| 17.3k| out << ")"; 122| 17.3k| } else { 123| 17.3k| out << "[" << from[i] << "-" << to[i] << "]"; 124| 17.3k| } 125| 17.3k| } 126| 17.3k| }; 127| | 128| 17.3k| if (has_min && has_max) { ------------------ | Branch (128:9): [True: 16.2k, False: 1.08k] | Branch (128:20): [True: 1.76k, False: 14.5k] ------------------ 129| 1.76k| if (min_value < 0 && max_value < 0) { ------------------ | Branch (129:13): [True: 377, False: 1.39k] | Branch (129:30): [True: 308, False: 69] ------------------ 130| 308| out << "\"-\" ("; 131| 308| build_min_max_int(-max_value, -min_value, out, decimals_left, /* top_level= */ true); 132| 308| out << ")"; 133| 308| return; 134| 308| } 135| | 136| 1.46k| if (min_value < 0) { ------------------ | Branch (136:13): [True: 69, False: 1.39k] ------------------ 137| 69| out << "\"-\" ("; 138| 69| build_min_max_int(0, -min_value, out, decimals_left, /* top_level= */ true); 139| 69| out << ") | "; 140| 69| min_value = 0; 141| 69| } 142| | 143| 1.46k| auto min_s = std::to_string(min_value); 144| 1.46k| auto max_s = std::to_string(max_value); 145| 1.46k| auto min_digits = min_s.length(); 146| 1.46k| auto max_digits = max_s.length(); 147| | 148| 9.87k| for (auto digits = min_digits; digits < max_digits; digits++) { ------------------ | Branch (148:40): [True: 8.41k, False: 1.46k] ------------------ 149| 8.41k| uniform_range(min_s, string_repeat("9", digits)); 150| 8.41k| min_s = "1" + string_repeat("0", digits); 151| 8.41k| out << " | "; 152| 8.41k| } 153| 1.46k| uniform_range(min_s, max_s); 154| 1.46k| return; 155| 1.76k| } 156| | 157| 15.5k| auto less_decimals = std::max(decimals_left - 1, 1); 158| | 159| 15.5k| if (has_min) { ------------------ | Branch (159:9): [True: 14.5k, False: 1.08k] ------------------ 160| 14.5k| if (min_value < 0) { ------------------ | Branch (160:13): [True: 338, False: 14.1k] ------------------ 161| 338| out << "\"-\" ("; 162| 338| build_min_max_int(std::numeric_limits::min(), -min_value, out, decimals_left, /* top_level= */ false); 163| 338| out << ") | [0] | [1-9] "; 164| 338| more_digits(0, decimals_left - 1); 165| 14.1k| } else if (min_value == 0) { ------------------ | Branch (165:20): [True: 799, False: 13.3k] ------------------ 166| 799| if (top_level) { ------------------ | Branch (166:17): [True: 454, False: 345] ------------------ 167| 454| out << "[0] | [1-9] "; 168| 454| more_digits(0, less_decimals); 169| 454| } else { 170| 345| more_digits(1, decimals_left); 171| 345| } 172| 13.3k| } else if (min_value <= 9) { ------------------ | Branch (172:20): [True: 1.75k, False: 11.6k] ------------------ 173| 1.75k| char c = '0' + min_value; 174| 1.75k| auto range_start = top_level ? '1' : '0'; ------------------ | Branch (174:32): [True: 322, False: 1.43k] ------------------ 175| 1.75k| if (c > range_start) { ------------------ | Branch (175:17): [True: 1.44k, False: 315] ------------------ 176| 1.44k| digit_range(range_start, c - 1); 177| 1.44k| out << " "; 178| 1.44k| more_digits(1, less_decimals); 179| 1.44k| out << " | "; 180| 1.44k| } 181| 1.75k| digit_range(c, '9'); 182| 1.75k| out << " "; 183| 1.75k| more_digits(0, less_decimals); 184| 11.6k| } else { 185| 11.6k| auto min_s = std::to_string(min_value); 186| 11.6k| auto len = min_s.length(); 187| 11.6k| auto c = min_s[0]; 188| | 189| 11.6k| if (c > '1') { ------------------ | Branch (189:17): [True: 9.44k, False: 2.17k] ------------------ 190| 9.44k| digit_range(top_level ? '1' : '0', c - 1); ------------------ | Branch (190:29): [True: 1.17k, False: 8.26k] ------------------ 191| 9.44k| out << " "; 192| 9.44k| more_digits(len, less_decimals); 193| 9.44k| out << " | "; 194| 9.44k| } 195| 11.6k| digit_range(c, c); 196| 11.6k| out << " ("; 197| 11.6k| build_min_max_int(std::stoll(min_s.substr(1)), std::numeric_limits::max(), out, less_decimals, /* top_level= */ false); 198| 11.6k| out << ")"; 199| 11.6k| if (c < '9') { ------------------ | Branch (199:17): [True: 10.1k, False: 1.41k] ------------------ 200| 10.1k| out << " | "; 201| 10.1k| digit_range(c + 1, '9'); 202| 10.1k| out << " "; 203| 10.1k| more_digits(len - 1, less_decimals); 204| 10.1k| } 205| 11.6k| } 206| 14.5k| return; 207| 14.5k| } 208| | 209| 1.08k| if (has_max) { ------------------ | Branch (209:9): [True: 1.07k, False: 5] ------------------ 210| 1.07k| if (max_value >= 0) { ------------------ | Branch (210:13): [True: 691, False: 385] ------------------ 211| 691| if (top_level) { ------------------ | Branch (211:17): [True: 354, False: 337] ------------------ 212| 354| out << "\"-\" [1-9] "; 213| 354| more_digits(0, less_decimals); 214| 354| out << " | "; 215| 354| } 216| 691| build_min_max_int(0, max_value, out, decimals_left, /* top_level= */ true); 217| 691| } else { 218| 385| out << "\"-\" ("; 219| 385| build_min_max_int(-max_value, std::numeric_limits::max(), out, decimals_left, /* top_level= */ false); 220| 385| out << ")"; 221| 385| } 222| 1.07k| return; 223| 1.07k| } 224| | 225| 5| throw std::runtime_error("At least one of min_value or max_value must be set"); 226| 1.08k|} json-schema-to-grammar.cpp:_ZZL17build_min_max_intllRNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEEibENK3$_0clERKNS_17basic_string_viewIcS2_EESB_: 73| 70.2k| [&](const std::string_view & from, const std::string_view & to) { 74| 70.2k| size_t i = 0; 75| 72.2k| while (i < from.length() && i < to.length() && from[i] == to[i]) { ------------------ | Branch (75:20): [True: 71.9k, False: 310] | Branch (75:41): [True: 71.6k, False: 272] | Branch (75:60): [True: 1.96k, False: 69.6k] ------------------ 76| 1.96k| i++; 77| 1.96k| } 78| 70.2k| if (i > 0) { ------------------ | Branch (78:17): [True: 1.79k, False: 68.4k] ------------------ 79| 1.79k| out << "\"" << from.substr(0, i) << "\""; 80| 1.79k| } 81| 70.2k| if (i < from.length() && i < to.length()) { ------------------ | Branch (81:17): [True: 69.9k, False: 310] | Branch (81:38): [True: 69.6k, False: 272] ------------------ 82| 69.6k| if (i > 0) { ------------------ | Branch (82:21): [True: 1.47k, False: 68.2k] ------------------ 83| 1.47k| out << " "; 84| 1.47k| } 85| 69.6k| auto sub_len = from.length() - i - 1; 86| 69.6k| if (sub_len > 0) { ------------------ | Branch (86:21): [True: 59.9k, False: 9.72k] ------------------ 87| 59.9k| auto from_sub = from.substr(i + 1); 88| 59.9k| auto to_sub = to.substr(i + 1); 89| 59.9k| auto sub_zeros = string_repeat("0", sub_len); 90| 59.9k| auto sub_nines = string_repeat("9", sub_len); 91| | 92| 59.9k| auto to_reached = false; 93| 59.9k| out << "("; 94| 59.9k| if (from_sub == sub_zeros) { ------------------ | Branch (94:25): [True: 58.0k, False: 1.90k] ------------------ 95| 58.0k| digit_range(from[i], to[i] - 1); 96| 58.0k| out << " "; 97| 58.0k| more_digits(sub_len, sub_len); 98| 58.0k| } else { 99| 1.90k| out << "[" << from[i] << "] "; 100| 1.90k| out << "("; 101| 1.90k| uniform_range(from_sub, sub_nines); 102| 1.90k| out << ")"; 103| 1.90k| if (from[i] < to[i] - 1) { ------------------ | Branch (103:29): [True: 1.60k, False: 307] ------------------ 104| 1.60k| out << " | "; 105| 1.60k| if (to_sub == sub_nines) { ------------------ | Branch (105:33): [True: 1.47k, False: 125] ------------------ 106| 1.47k| digit_range(from[i] + 1, to[i]); 107| 1.47k| to_reached = true; 108| 1.47k| } else { 109| 125| digit_range(from[i] + 1, to[i] - 1); 110| 125| } 111| 1.60k| out << " "; 112| 1.60k| more_digits(sub_len, sub_len); 113| 1.60k| } 114| 1.90k| } 115| 59.9k| if (!to_reached) { ------------------ | Branch (115:25): [True: 58.4k, False: 1.47k] ------------------ 116| 58.4k| out << " | "; 117| 58.4k| digit_range(to[i], to[i]); 118| 58.4k| out << " "; 119| 58.4k| uniform_range(sub_zeros, to_sub); 120| 58.4k| } 121| 59.9k| out << ")"; 122| 59.9k| } else { 123| 9.72k| out << "[" << from[i] << "-" << to[i] << "]"; 124| 9.72k| } 125| 69.6k| } 126| 70.2k| }; json-schema-to-grammar.cpp:_ZZL17build_min_max_intllRNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEEibENK3$_2clEii: 57| 83.9k| auto more_digits = [&](int min_digits, int max_digits) { 58| 83.9k| out << "[0-9]"; 59| 83.9k| if (min_digits == max_digits && min_digits == 1) { ------------------ | Branch (59:13): [True: 61.9k, False: 22.0k] | Branch (59:41): [True: 9.66k, False: 52.2k] ------------------ 60| 9.66k| return; 61| 9.66k| } 62| 74.3k| out << "{"; 63| 74.3k| out << min_digits; 64| 74.3k| if (max_digits != min_digits) { ------------------ | Branch (64:13): [True: 22.0k, False: 52.2k] ------------------ 65| 22.0k| out << ","; 66| 22.0k| if (max_digits != std::numeric_limits::max()) { ------------------ | Branch (66:17): [True: 22.0k, False: 0] ------------------ 67| 22.0k| out << max_digits; 68| 22.0k| } 69| 22.0k| } 70| 74.3k| out << "}"; 71| 74.3k| }; json-schema-to-grammar.cpp:_ZZL17build_min_max_intllRNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEEibENK3$_1clEcc: 48| 152k| auto digit_range = [&](char from, char to) { 49| 152k| out << "["; 50| 152k| if (from == to) { ------------------ | Branch (50:13): [True: 73.5k, False: 79.1k] ------------------ 51| 73.5k| out << from; 52| 79.1k| } else { 53| 79.1k| out << from << "-" << to; 54| 79.1k| } 55| 152k| out << "]"; 56| 152k| }; json-schema-to-grammar.cpp:_ZZ13build_grammarRKNSt3__18functionIFvRK22common_grammar_builderEEERK22common_grammar_optionsENK3$_3clERN8nlohmann16json_abi_v3_12_010basic_jsonINSD_11ordered_mapENS_6vectorENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEblmdSK_NSD_14adl_serializerENSG_IhNSK_IhEEEEvEE: 1182| 8.54k| /* .resolve_refs = */ [&](nlohmann::ordered_json & schema) { 1183| 8.54k| converter.resolve_refs(schema, ""); 1184| 8.54k| } LLVMFuzzerTestOneInput: 20| 11.2k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 21| | 22| 11.2k| try { 23| 11.2k| json_schema_to_grammar(json::parse(data, data + size)); 24| 11.2k| } catch (...) { 25| 9.53k| return 0; 26| 9.53k| } 27| | 28| 1.73k| return 0; 29| 11.2k|} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvED2Ev: 21296| 39.2M| { 21297| 39.2M| assert_invariant(false); 21298| 39.2M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE16assert_invariantEb: 20700| 117M| { 20701| 117M| JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr); ------------------ | | 2571| 117M| #define JSON_ASSERT(x) assert(x) ------------------ 20702| 117M| JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr); ------------------ | | 2571| 117M| #define JSON_ASSERT(x) assert(x) ------------------ 20703| 117M| JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr); ------------------ | | 2571| 117M| #define JSON_ASSERT(x) assert(x) ------------------ 20704| 117M| JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr); ------------------ | | 2571| 117M| #define JSON_ASSERT(x) assert(x) ------------------ 20705| | 20706| |#if JSON_DIAGNOSTICS 20707| | JSON_TRY 20708| | { 20709| | // cppcheck-suppress assertWithSideEffect 20710| | JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j) 20711| | { 20712| | return j.m_parent == this; 20713| | })); 20714| | } 20715| | JSON_CATCH(...) {} // LCOV_EXCL_LINE 20716| |#endif 20717| 117M| static_cast(check_parents); 20718| 117M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dataD2Ev: 24257| 39.2M| { 24258| 39.2M| m_value.destroy(m_type); 24259| 39.2M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_value7destroyENS0_6detail7value_tE: 20572| 46.7M| { 20573| 46.7M| if ( 20574| 46.7M| (t == value_t::object && object == nullptr) || ------------------ | Branch (20574:18): [True: 219k, False: 46.5M] | Branch (20574:42): [True: 0, False: 219k] ------------------ 20575| 46.7M| (t == value_t::array && array == nullptr) || ------------------ | Branch (20575:18): [True: 624k, False: 46.1M] | Branch (20575:41): [True: 0, False: 624k] ------------------ 20576| 46.7M| (t == value_t::string && string == nullptr) || ------------------ | Branch (20576:18): [True: 70.3k, False: 46.6M] | Branch (20576:42): [True: 0, False: 70.3k] ------------------ 20577| 46.7M| (t == value_t::binary && binary == nullptr) ------------------ | Branch (20577:18): [True: 0, False: 46.7M] | Branch (20577:42): [True: 0, False: 0] ------------------ 20578| 46.7M| ) 20579| 0| { 20580| | //not initialized (e.g. due to exception in the ctor) 20581| 0| return; 20582| 0| } 20583| 46.7M| if (t == value_t::array || t == value_t::object) ------------------ | Branch (20583:17): [True: 624k, False: 46.1M] | Branch (20583:40): [True: 219k, False: 45.8M] ------------------ 20584| 843k| { 20585| | // flatten the current json_value to a heap-allocated stack 20586| 843k| std::vector stack; 20587| | 20588| | // move the top-level items to stack 20589| 843k| if (t == value_t::array) ------------------ | Branch (20589:21): [True: 624k, False: 219k] ------------------ 20590| 624k| { 20591| 624k| stack.reserve(array->size()); 20592| 624k| std::move(array->begin(), array->end(), std::back_inserter(stack)); 20593| 624k| } 20594| 219k| else 20595| 219k| { 20596| 219k| stack.reserve(object->size()); 20597| 219k| for (auto&& it : *object) ------------------ | Branch (20597:36): [True: 13.8k, False: 219k] ------------------ 20598| 13.8k| { 20599| 13.8k| stack.push_back(std::move(it.second)); 20600| 13.8k| } 20601| 219k| } 20602| | 20603| 9.19M| while (!stack.empty()) ------------------ | Branch (20603:24): [True: 8.35M, False: 843k] ------------------ 20604| 8.35M| { 20605| | // move the last item to local variable to be processed 20606| 8.35M| basic_json current_item(std::move(stack.back())); 20607| 8.35M| stack.pop_back(); 20608| | 20609| | // if current_item is array/object, move 20610| | // its children to the stack to be processed later 20611| 8.35M| if (current_item.is_array()) ------------------ | Branch (20611:25): [True: 623k, False: 7.73M] ------------------ 20612| 623k| { 20613| 623k| std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack)); 20614| | 20615| 623k| current_item.m_data.m_value.array->clear(); 20616| 623k| } 20617| 7.73M| else if (current_item.is_object()) ------------------ | Branch (20617:30): [True: 211k, False: 7.52M] ------------------ 20618| 211k| { 20619| 211k| for (auto&& it : *current_item.m_data.m_value.object) ------------------ | Branch (20619:40): [True: 159k, False: 211k] ------------------ 20620| 159k| { 20621| 159k| stack.push_back(std::move(it.second)); 20622| 159k| } 20623| | 20624| 211k| current_item.m_data.m_value.object->clear(); 20625| 211k| } 20626| | 20627| | // it's now safe that current_item get destructed 20628| | // since it doesn't have any children 20629| 8.35M| } 20630| 843k| } 20631| | 20632| 46.7M| switch (t) 20633| 46.7M| { 20634| 219k| case value_t::object: ------------------ | Branch (20634:17): [True: 219k, False: 46.5M] ------------------ 20635| 219k| { 20636| 219k| AllocatorType alloc; 20637| 219k| std::allocator_traits::destroy(alloc, object); 20638| 219k| std::allocator_traits::deallocate(alloc, object, 1); 20639| 219k| break; 20640| 0| } 20641| | 20642| 624k| case value_t::array: ------------------ | Branch (20642:17): [True: 624k, False: 46.1M] ------------------ 20643| 624k| { 20644| 624k| AllocatorType alloc; 20645| 624k| std::allocator_traits::destroy(alloc, array); 20646| 624k| std::allocator_traits::deallocate(alloc, array, 1); 20647| 624k| break; 20648| 0| } 20649| | 20650| 70.3k| case value_t::string: ------------------ | Branch (20650:17): [True: 70.3k, False: 46.6M] ------------------ 20651| 70.3k| { 20652| 70.3k| AllocatorType alloc; 20653| 70.3k| std::allocator_traits::destroy(alloc, string); 20654| 70.3k| std::allocator_traits::deallocate(alloc, string, 1); 20655| 70.3k| break; 20656| 0| } 20657| | 20658| 0| case value_t::binary: ------------------ | Branch (20658:17): [True: 0, False: 46.7M] ------------------ 20659| 0| { 20660| 0| AllocatorType alloc; 20661| 0| std::allocator_traits::destroy(alloc, binary); 20662| 0| std::allocator_traits::deallocate(alloc, binary, 1); 20663| 0| break; 20664| 0| } 20665| | 20666| 38.3M| case value_t::null: ------------------ | Branch (20666:17): [True: 38.3M, False: 8.36M] ------------------ 20667| 38.3M| case value_t::boolean: ------------------ | Branch (20667:17): [True: 7.56k, False: 46.7M] ------------------ 20668| 38.4M| case value_t::number_integer: ------------------ | Branch (20668:17): [True: 44.1k, False: 46.6M] ------------------ 20669| 45.4M| case value_t::number_unsigned: ------------------ | Branch (20669:17): [True: 7.05M, False: 39.6M] ------------------ 20670| 45.8M| case value_t::number_float: ------------------ | Branch (20670:17): [True: 339k, False: 46.4M] ------------------ 20671| 45.8M| case value_t::discarded: ------------------ | Branch (20671:17): [True: 0, False: 46.7M] ------------------ 20672| 45.8M| default: ------------------ | Branch (20672:17): [True: 0, False: 46.7M] ------------------ 20673| 45.8M| { 20674| 45.8M| break; 20675| 45.8M| } 20676| 46.7M| } 20677| 46.7M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2EOSE_: 21241| 30.6M| : json_base_class_t(std::forward(other)), 21242| 30.6M| m_data(std::move(other.m_data)) // cppcheck-suppress[accessForwarded] TODO check 21243| |#if JSON_DIAGNOSTIC_POSITIONS 21244| | , start_position(other.start_position) // cppcheck-suppress[accessForwarded] TODO check 21245| | , end_position(other.end_position) // cppcheck-suppress[accessForwarded] TODO check 21246| |#endif 21247| 30.6M| { 21248| | // check that passed value is valid 21249| 30.6M| other.assert_invariant(false); // cppcheck-suppress[accessForwarded] 21250| | 21251| | // invalidate payload 21252| 30.6M| other.m_data.m_type = value_t::null; 21253| 30.6M| other.m_data.m_value = {}; 21254| | 21255| |#if JSON_DIAGNOSTIC_POSITIONS 21256| | other.start_position = std::string::npos; 21257| | other.end_position = std::string::npos; 21258| |#endif 21259| | 21260| 30.6M| set_parents(); 21261| 30.6M| assert_invariant(); 21262| 30.6M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE11set_parentsEv: 20721| 38.5M| { 20722| |#if JSON_DIAGNOSTICS 20723| | switch (m_data.m_type) 20724| | { 20725| | case value_t::array: 20726| | { 20727| | for (auto& element : *m_data.m_value.array) 20728| | { 20729| | element.m_parent = this; 20730| | } 20731| | break; 20732| | } 20733| | 20734| | case value_t::object: 20735| | { 20736| | for (auto& element : *m_data.m_value.object) 20737| | { 20738| | element.second.m_parent = this; 20739| | } 20740| | break; 20741| | } 20742| | 20743| | case value_t::null: 20744| | case value_t::string: 20745| | case value_t::boolean: 20746| | case value_t::number_integer: 20747| | case value_t::number_unsigned: 20748| | case value_t::number_float: 20749| | case value_t::binary: 20750| | case value_t::discarded: 20751| | default: 20752| | break; 20753| | } 20754| |#endif 20755| 38.5M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8is_arrayEv: 21406| 16.7M| { 21407| 16.7M| return m_data.m_type == value_t::array; 21408| 16.7M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE9is_objectEv: 21399| 7.80M| { 21400| 7.80M| return m_data.m_type == value_t::object; 21401| 7.80M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE5parseIPKhEESE_T_SI_NS2_8functionIFbiNS0_6detail13parse_event_tERSE_EEEbb: 24076| 11.2k| { 24077| 11.2k| basic_json result; 24078| 11.2k| parser(detail::input_adapter(std::move(first), std::move(last)), std::move(cb), allow_exceptions, ignore_comments).parse(true, result); // cppcheck-suppress[accessMoved] 24079| 11.2k| return result; 24080| 11.2k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2EDn: 20841| 193k| : basic_json(value_t::null) 20842| 193k| { 20843| 193k| assert_invariant(); 20844| 193k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2ENS0_6detail7value_tE: 20833| 1.03M| : m_data(v) 20834| 1.03M| { 20835| 1.03M| assert_invariant(); 20836| 1.03M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dataC2ENS0_6detail7value_tE: 24240| 1.03M| : m_type(v), m_value(v) 24241| 1.03M| { 24242| 1.03M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2ENS0_6detail7value_tE: 20471| 1.03M| { 20472| 1.03M| switch (t) 20473| 1.03M| { 20474| 219k| case value_t::object: ------------------ | Branch (20474:17): [True: 219k, False: 818k] ------------------ 20475| 219k| { 20476| 219k| object = create(); 20477| 219k| break; 20478| 0| } 20479| | 20480| 624k| case value_t::array: ------------------ | Branch (20480:17): [True: 624k, False: 412k] ------------------ 20481| 624k| { 20482| 624k| array = create(); 20483| 624k| break; 20484| 0| } 20485| | 20486| 0| case value_t::string: ------------------ | Branch (20486:17): [True: 0, False: 1.03M] ------------------ 20487| 0| { 20488| 0| string = create(""); 20489| 0| break; 20490| 0| } 20491| | 20492| 0| case value_t::binary: ------------------ | Branch (20492:17): [True: 0, False: 1.03M] ------------------ 20493| 0| { 20494| 0| binary = create(); 20495| 0| break; 20496| 0| } 20497| | 20498| 0| case value_t::boolean: ------------------ | Branch (20498:17): [True: 0, False: 1.03M] ------------------ 20499| 0| { 20500| 0| boolean = static_cast(false); 20501| 0| break; 20502| 0| } 20503| | 20504| 0| case value_t::number_integer: ------------------ | Branch (20504:17): [True: 0, False: 1.03M] ------------------ 20505| 0| { 20506| 0| number_integer = static_cast(0); 20507| 0| break; 20508| 0| } 20509| | 20510| 0| case value_t::number_unsigned: ------------------ | Branch (20510:17): [True: 0, False: 1.03M] ------------------ 20511| 0| { 20512| 0| number_unsigned = static_cast(0); 20513| 0| break; 20514| 0| } 20515| | 20516| 0| case value_t::number_float: ------------------ | Branch (20516:17): [True: 0, False: 1.03M] ------------------ 20517| 0| { 20518| 0| number_float = static_cast(0.0); 20519| 0| break; 20520| 0| } 20521| | 20522| 193k| case value_t::null: ------------------ | Branch (20522:17): [True: 193k, False: 843k] ------------------ 20523| 193k| { 20524| 193k| object = nullptr; // silence warning, see #821 20525| 193k| break; 20526| 0| } 20527| | 20528| 0| case value_t::discarded: ------------------ | Branch (20528:17): [True: 0, False: 1.03M] ------------------ 20529| 0| default: ------------------ | Branch (20529:17): [True: 0, False: 1.03M] ------------------ 20530| 0| { 20531| 0| object = nullptr; // silence warning, see #821 20532| 0| if (JSON_HEDLEY_UNLIKELY(t == value_t::null)) ------------------ | | 1691| 0|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 0] | | ------------------ ------------------ 20533| 0| { 20534| 0| JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 20535| 0| } 20536| 0| break; 20537| 0| } 20538| 1.03M| } 20539| 1.03M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createINS3_ISA_SE_NS2_4lessIvEENS8_INS2_4pairIKSA_SE_EEEEEEJEEEPT_DpOT0_: 20396| 219k| { 20397| 219k| AllocatorType alloc; 20398| 219k| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 219k| auto deleter = [&](T * obj) 20401| 219k| { 20402| 219k| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 219k| }; 20404| 219k| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 219k| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 219k| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 219k| return obj.release(); 20408| 219k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createINS4_ISE_NS8_ISE_EEEEJEEEPT_DpOT0_: 20396| 624k| { 20397| 624k| AllocatorType alloc; 20398| 624k| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 624k| auto deleter = [&](T * obj) 20401| 624k| { 20402| 624k| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 624k| }; 20404| 624k| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 624k| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 624k| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 624k| return obj.release(); 20408| 624k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJS9_S9_RKS9_EEET_DpOT0_: 4477| 89|{ 4478| 89| OutStringType str; 4479| 89| str.reserve(concat_length(args...)); 4480| 89| concat_into(str, std::forward(args)...); 4481| 89| return str; 4482| 89|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJS9_S9_EEEmRKT_DpRKT0_: 4387| 89|{ 4388| 89| return str.size() + concat_length(rest...); 4389| 89|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJS9_EEEmRKT_DpRKT0_: 4387| 2.79k|{ 4388| 2.79k| return str.size() + concat_length(rest...); 4389| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEmRKT_DpRKT0_: 4387| 5.49k|{ 4388| 5.49k| return str.size() + concat_length(rest...); 4389| 5.49k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthEv: 4362| 14.8k|{ 4363| 14.8k| return 0; 4364| 14.8k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JS9_RKS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_: 4440| 89|{ 4441| 89| out.append(std::forward(arg)); 4442| 89| concat_into(out, std::forward(rest)...); 4443| 89|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JRKS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_: 4440| 2.79k|{ 4441| 2.79k| out.append(std::forward(arg)); 4442| 2.79k| concat_into(out, std::forward(rest)...); 4443| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_JETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_: 4440| 2.79k|{ 4441| 2.79k| out.append(std::forward(arg)); 4442| 2.79k| concat_into(out, std::forward(rest)...); 4443| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRT_: 4393| 14.8k|{} _ZN8nlohmann16json_abi_v3_12_06detail9exception4nameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEi: 4527| 2.79k| { 4528| 2.79k| return concat("[json.exception.", ename, '.', std::to_string(id_), "] "); 4529| 2.79k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA17_KcRKS9_cS9_RA3_SA_EEET_DpOT0_: 4477| 2.79k|{ 4478| 2.79k| OutStringType str; 4479| 2.79k| str.reserve(concat_length(args...)); 4480| 2.79k| concat_into(str, std::forward(args)...); 4481| 2.79k| return str; 4482| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEcS9_A3_cEEEmPKcDpRKT_: 4380| 2.79k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 2.79k| return ::strlen(cstr) + concat_length(rest...); 4383| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJcS9_A3_cEEEmRKT_DpRKT0_: 4387| 2.79k|{ 4388| 2.79k| return str.size() + concat_length(rest...); 4389| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEA3_cEEEmcDpRKT_: 4374| 2.79k|{ 4375| 2.79k| return 1 + concat_length(rest...); 4376| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJA3_cEEEmRKT_DpRKT0_: 4387| 2.79k|{ 4388| 2.79k| return str.size() + concat_length(rest...); 4389| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJEEEmPKcDpRKT_: 4380| 4.63k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 4.63k| return ::strlen(cstr) + concat_length(rest...); 4383| 4.63k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA17_KcJRKS9_cS9_RA3_SA_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSI_OSJ_DpOT1_: 4440| 2.79k|{ 4441| 2.79k| out.append(std::forward(arg)); 4442| 2.79k| concat_into(out, std::forward(rest)...); 4443| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_JcS9_RA3_KcETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSG_OSH_DpOT1_: 4440| 2.79k|{ 4441| 2.79k| out.append(std::forward(arg)); 4442| 2.79k| concat_into(out, std::forward(rest)...); 4443| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEcJS9_RA3_KcETnNS3_9enable_ifIXaantsr24detect_string_can_appendIT_T0_EE5valuesr27detect_string_can_append_opISE_SF_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4449| 2.79k|{ 4450| 2.79k| out += std::forward(arg); 4451| 2.79k| concat_into(out, std::forward(rest)...); 4452| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JRA3_KcETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 2.79k|{ 4441| 2.79k| out.append(std::forward(arg)); 4442| 2.79k| concat_into(out, std::forward(rest)...); 4443| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA3_KcJETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 2.79k|{ 4441| 2.79k| out.append(std::forward(arg)); 4442| 2.79k| concat_into(out, std::forward(rest)...); 4443| 2.79k|} _ZN8nlohmann16json_abi_v3_12_06detail9exception11diagnosticsEDn: 4532| 2.71k| { 4533| 2.71k| return ""; 4534| 2.71k| } _ZN8nlohmann16json_abi_v3_12_06detail9exceptionC2EiPKc: 4524| 2.79k| exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing) _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6parserINS0_6detail22iterator_input_adapterIPKhEEEENSG_6parserISE_T_EESM_NS2_8functionIFbiNSG_13parse_event_tERSE_EEEbb: 20153| 11.2k| { 20154| 11.2k| return ::nlohmann::detail::parser(std::move(adapter), 20155| 11.2k| std::move(cb), allow_exceptions, ignore_comments); 20156| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail6parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEEC2EOSK_NS4_8functionIFbiNS1_13parse_event_tERSG_EEEbb: 12933| 11.2k| : callback(std::move(cb)) 12934| 11.2k| , m_lexer(std::move(adapter), skip_comments) 12935| 11.2k| , allow_exceptions(allow_exceptions_) 12936| 11.2k| { 12937| | // read first token 12938| 11.2k| get_token(); 12939| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEEC2EOSK_b: 7147| 11.2k| : ia(std::move(adapter)) 7148| 11.2k| , ignore_comments(ignore_comments_) 7149| 11.2k| , decimal_point_char(static_cast(get_decimal_point())) 7150| 11.2k| {} _ZN8nlohmann16json_abi_v3_12_06detail11char_traitsIhE3eofEv: 3753| 137M| { 3754| 137M| return static_cast(std::char_traits::eof()); 3755| 137M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE17get_decimal_pointEv: 7167| 11.2k| { 7168| 11.2k| const auto* loc = localeconv(); 7169| 11.2k| JSON_ASSERT(loc != nullptr); ------------------ | | 2571| 11.2k| #define JSON_ASSERT(x) assert(x) ------------------ 7170| 11.2k| return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point); ------------------ | Branch (7170:16): [True: 0, False: 11.2k] ------------------ 7171| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail6parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE9get_tokenEv: 13332| 16.4M| { 13333| 16.4M| return last_token = m_lexer.scan(); 13334| 16.4M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE4scanEv: 8541| 16.4M| { 8542| | // initially, skip the BOM 8543| 16.4M| if (position.chars_read_total == 0 && !skip_bom()) ------------------ | Branch (8543:13): [True: 11.2k, False: 16.4M] | Branch (8543:47): [True: 24, False: 11.2k] ------------------ 8544| 24| { 8545| 24| error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given"; 8546| 24| return token_type::parse_error; 8547| 24| } 8548| | 8549| | // read next character and ignore whitespace 8550| 16.4M| skip_whitespace(); 8551| | 8552| | // ignore comments 8553| 16.4M| while (ignore_comments && current == '/') ------------------ | Branch (8553:16): [True: 0, False: 16.4M] | Branch (8553:35): [True: 0, False: 0] ------------------ 8554| 0| { 8555| 0| if (!scan_comment()) ------------------ | Branch (8555:17): [True: 0, False: 0] ------------------ 8556| 0| { 8557| 0| return token_type::parse_error; 8558| 0| } 8559| | 8560| | // skip following whitespace 8561| 0| skip_whitespace(); 8562| 0| } 8563| | 8564| 16.4M| switch (current) 8565| 16.4M| { 8566| | // structural characters 8567| 624k| case '[': ------------------ | Branch (8567:13): [True: 624k, False: 15.8M] ------------------ 8568| 624k| return token_type::begin_array; 8569| 18.4k| case ']': ------------------ | Branch (8569:13): [True: 18.4k, False: 16.4M] ------------------ 8570| 18.4k| return token_type::end_array; 8571| 219k| case '{': ------------------ | Branch (8571:13): [True: 219k, False: 16.2M] ------------------ 8572| 219k| return token_type::begin_object; 8573| 141k| case '}': ------------------ | Branch (8573:13): [True: 141k, False: 16.3M] ------------------ 8574| 141k| return token_type::end_object; 8575| 179k| case ':': ------------------ | Branch (8575:13): [True: 179k, False: 16.3M] ------------------ 8576| 179k| return token_type::name_separator; 8577| 7.59M| case ',': ------------------ | Branch (8577:13): [True: 7.59M, False: 8.89M] ------------------ 8578| 7.59M| return token_type::value_separator; 8579| | 8580| | // literals 8581| 7.31k| case 't': ------------------ | Branch (8581:13): [True: 7.31k, False: 16.4M] ------------------ 8582| 7.31k| { 8583| 7.31k| std::array true_literal = {{static_cast('t'), static_cast('r'), static_cast('u'), static_cast('e')}}; 8584| 7.31k| return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true); 8585| 0| } 8586| 293| case 'f': ------------------ | Branch (8586:13): [True: 293, False: 16.4M] ------------------ 8587| 293| { 8588| 293| std::array false_literal = {{static_cast('f'), static_cast('a'), static_cast('l'), static_cast('s'), static_cast('e')}}; 8589| 293| return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false); 8590| 0| } 8591| 9.04k| case 'n': ------------------ | Branch (8591:13): [True: 9.04k, False: 16.4M] ------------------ 8592| 9.04k| { 8593| 9.04k| std::array null_literal = {{static_cast('n'), static_cast('u'), static_cast('l'), static_cast('l')}}; 8594| 9.04k| return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null); 8595| 0| } 8596| | 8597| | // string 8598| 251k| case '\"': ------------------ | Branch (8598:13): [True: 251k, False: 16.2M] ------------------ 8599| 251k| return scan_string(); 8600| | 8601| | // number 8602| 47.9k| case '-': ------------------ | Branch (8602:13): [True: 47.9k, False: 16.4M] ------------------ 8603| 2.75M| case '0': ------------------ | Branch (8603:13): [True: 2.70M, False: 13.7M] ------------------ 8604| 3.00M| case '1': ------------------ | Branch (8604:13): [True: 247k, False: 16.2M] ------------------ 8605| 3.03M| case '2': ------------------ | Branch (8605:13): [True: 35.2k, False: 16.4M] ------------------ 8606| 3.30M| case '3': ------------------ | Branch (8606:13): [True: 268k, False: 16.2M] ------------------ 8607| 3.70M| case '4': ------------------ | Branch (8607:13): [True: 395k, False: 16.0M] ------------------ 8608| 3.93M| case '5': ------------------ | Branch (8608:13): [True: 229k, False: 16.2M] ------------------ 8609| 4.71M| case '6': ------------------ | Branch (8609:13): [True: 778k, False: 15.7M] ------------------ 8610| 4.74M| case '7': ------------------ | Branch (8610:13): [True: 33.4k, False: 16.4M] ------------------ 8611| 4.91M| case '8': ------------------ | Branch (8611:13): [True: 175k, False: 16.3M] ------------------ 8612| 7.43M| case '9': ------------------ | Branch (8612:13): [True: 2.51M, False: 13.9M] ------------------ 8613| 7.43M| return scan_number(); 8614| | 8615| | // end of input (the null byte is needed when parsing from 8616| | // string literals) 8617| 1.55k| case '\0': ------------------ | Branch (8617:13): [True: 1.55k, False: 16.4M] ------------------ 8618| 9.09k| case char_traits::eof(): ------------------ | Branch (8618:13): [True: 7.53k, False: 16.4M] ------------------ 8619| 9.09k| return token_type::end_of_input; 8620| | 8621| | // error 8622| 163| default: ------------------ | Branch (8622:13): [True: 163, False: 16.4M] ------------------ 8623| 163| error_message = "invalid literal"; 8624| 163| return token_type::parse_error; 8625| 16.4M| } 8626| 16.4M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE8skip_bomEv: 8518| 11.2k| { 8519| 11.2k| if (get() == 0xEF) ------------------ | Branch (8519:13): [True: 24, False: 11.2k] ------------------ 8520| 24| { 8521| | // check if we completely parse the BOM 8522| 24| return get() == 0xBB && get() == 0xBF; ------------------ | Branch (8522:20): [True: 11, False: 13] | Branch (8522:37): [True: 0, False: 11] ------------------ 8523| 24| } 8524| | 8525| | // the first character is not the beginning of the BOM; unget it to 8526| | // process is later 8527| 11.2k| unget(); 8528| 11.2k| return true; 8529| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE3getEv: 8364| 129M| { 8365| 129M| ++position.chars_read_total; 8366| 129M| ++position.chars_read_current_line; 8367| | 8368| 129M| if (next_unget) ------------------ | Branch (8368:13): [True: 7.45M, False: 122M] ------------------ 8369| 7.45M| { 8370| | // just reset the next_unget variable and work with current 8371| 7.45M| next_unget = false; 8372| 7.45M| } 8373| 122M| else 8374| 122M| { 8375| 122M| current = ia.get_character(); 8376| 122M| } 8377| | 8378| 129M| if (JSON_HEDLEY_LIKELY(current != char_traits::eof())) ------------------ | | 1690| 129M|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 129M, False: 10.3k] | | ------------------ ------------------ 8379| 129M| { 8380| 129M| token_string.push_back(char_traits::to_char_type(current)); 8381| 129M| } 8382| | 8383| 129M| if (current == '\n') ------------------ | Branch (8383:13): [True: 97.4k, False: 129M] ------------------ 8384| 97.4k| { 8385| 97.4k| ++position.lines_read; 8386| 97.4k| position.chars_read_current_line = 0; 8387| 97.4k| } 8388| | 8389| 129M| return current; 8390| 129M| } _ZN8nlohmann16json_abi_v3_12_06detail22iterator_input_adapterIPKhE13get_characterEv: 6616| 122M| { 6617| 122M| if (JSON_HEDLEY_LIKELY(current != end)) ------------------ | | 1690| 122M|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 122M, False: 8.98k] | | ------------------ ------------------ 6618| 122M| { 6619| 122M| auto result = char_traits::to_int_type(*current); 6620| 122M| std::advance(current, 1); 6621| 122M| return result; 6622| 122M| } 6623| | 6624| 8.98k| return char_traits::eof(); 6625| 122M| } _ZN8nlohmann16json_abi_v3_12_06detail11char_traitsIhE11to_int_typeEh: 3743| 122M| { 3744| 122M| return static_cast(c); 3745| 122M| } _ZN8nlohmann16json_abi_v3_12_06detail11char_traitsIhE12to_char_typeEm: 3748| 137M| { 3749| 137M| return static_cast(i); 3750| 137M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE5ungetEv: 8401| 7.45M| { 8402| 7.45M| next_unget = true; 8403| | 8404| 7.45M| --position.chars_read_total; 8405| | 8406| | // in case we "unget" a newline, we have to also decrement the lines_read 8407| 7.45M| if (position.chars_read_current_line == 0) ------------------ | Branch (8407:13): [True: 18.0k, False: 7.43M] ------------------ 8408| 18.0k| { 8409| 18.0k| if (position.lines_read > 0) ------------------ | Branch (8409:17): [True: 18.0k, False: 0] ------------------ 8410| 18.0k| { 8411| 18.0k| --position.lines_read; 8412| 18.0k| } 8413| 18.0k| } 8414| 7.43M| else 8415| 7.43M| { 8416| 7.43M| --position.chars_read_current_line; 8417| 7.43M| } 8418| | 8419| 7.45M| if (JSON_HEDLEY_LIKELY(current != char_traits::eof())) ------------------ | | 1690| 7.45M|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 7.44M, False: 1.38k] | | ------------------ ------------------ 8420| 7.44M| { 8421| | JSON_ASSERT(!token_string.empty()); ------------------ | | 2571| 7.44M| #define JSON_ASSERT(x) assert(x) ------------------ 8422| 7.44M| token_string.pop_back(); 8423| 7.44M| } 8424| 7.45M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE15skip_whitespaceEv: 8532| 16.4M| { 8533| 16.4M| do 8534| 17.1M| { 8535| 17.1M| get(); 8536| 17.1M| } 8537| 17.1M| while (current == ' ' || current == '\t' || current == '\n' || current == '\r'); ------------------ | Branch (8537:16): [True: 10.9k, False: 17.1M] | Branch (8537:34): [True: 736, False: 17.1M] | Branch (8537:53): [True: 79.4k, False: 17.0M] | Branch (8537:72): [True: 593k, False: 16.4M] ------------------ 8538| 16.4M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12scan_literalESJ_mNS1_10lexer_baseISG_E10token_typeE: 8327| 16.6k| { 8328| 16.6k| JSON_ASSERT(char_traits::to_char_type(current) == literal_text[0]); ------------------ | | 2571| 16.6k| #define JSON_ASSERT(x) assert(x) ------------------ 8329| 66.7k| for (std::size_t i = 1; i < length; ++i) ------------------ | Branch (8329:33): [True: 50.1k, False: 16.5k] ------------------ 8330| 50.1k| { 8331| 50.1k| if (JSON_HEDLEY_UNLIKELY(char_traits::to_char_type(get()) != literal_text[i])) ------------------ | | 1691| 50.1k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 70, False: 50.0k] | | ------------------ ------------------ 8332| 70| { 8333| 70| error_message = "invalid literal"; 8334| 70| return token_type::parse_error; 8335| 70| } 8336| 50.1k| } 8337| 16.5k| return return_type; 8338| 16.6k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE11scan_stringEv: 7278| 251k| { 7279| | // reset token_buffer (ignore opening quote) 7280| 251k| reset(); 7281| | 7282| | // we entered the function by reading an open quote 7283| 251k| JSON_ASSERT(current == '\"'); ------------------ | | 2571| 251k| #define JSON_ASSERT(x) assert(x) ------------------ 7284| | 7285| 102M| while (true) ------------------ | Branch (7285:16): [True: 102M, Folded] ------------------ 7286| 102M| { 7287| | // get next character 7288| 102M| switch (get()) 7289| 102M| { 7290| | // end of file while parsing string 7291| 856| case char_traits::eof(): ------------------ | Branch (7291:17): [True: 856, False: 102M] ------------------ 7292| 856| { 7293| 856| error_message = "invalid string: missing closing quote"; 7294| 856| return token_type::parse_error; 7295| 0| } 7296| | 7297| | // closing quote 7298| 249k| case '\"': ------------------ | Branch (7298:17): [True: 249k, False: 102M] ------------------ 7299| 249k| { 7300| 249k| return token_type::value_string; 7301| 0| } 7302| | 7303| | // escapes 7304| 212k| case '\\': ------------------ | Branch (7304:17): [True: 212k, False: 102M] ------------------ 7305| 212k| { 7306| 212k| switch (get()) 7307| 212k| { 7308| | // quotation mark 7309| 3.39k| case '\"': ------------------ | Branch (7309:25): [True: 3.39k, False: 208k] ------------------ 7310| 3.39k| add('\"'); 7311| 3.39k| break; 7312| | // reverse solidus 7313| 158k| case '\\': ------------------ | Branch (7313:25): [True: 158k, False: 53.8k] ------------------ 7314| 158k| add('\\'); 7315| 158k| break; 7316| | // solidus 7317| 505| case '/': ------------------ | Branch (7317:25): [True: 505, False: 211k] ------------------ 7318| 505| add('/'); 7319| 505| break; 7320| | // backspace 7321| 35.2k| case 'b': ------------------ | Branch (7321:25): [True: 35.2k, False: 176k] ------------------ 7322| 35.2k| add('\b'); 7323| 35.2k| break; 7324| | // form feed 7325| 642| case 'f': ------------------ | Branch (7325:25): [True: 642, False: 211k] ------------------ 7326| 642| add('\f'); 7327| 642| break; 7328| | // line feed 7329| 2.33k| case 'n': ------------------ | Branch (7329:25): [True: 2.33k, False: 209k] ------------------ 7330| 2.33k| add('\n'); 7331| 2.33k| break; 7332| | // carriage return 7333| 901| case 'r': ------------------ | Branch (7333:25): [True: 901, False: 211k] ------------------ 7334| 901| add('\r'); 7335| 901| break; 7336| | // tab 7337| 2.76k| case 't': ------------------ | Branch (7337:25): [True: 2.76k, False: 209k] ------------------ 7338| 2.76k| add('\t'); 7339| 2.76k| break; 7340| | 7341| | // unicode escapes 7342| 8.08k| case 'u': ------------------ | Branch (7342:25): [True: 8.08k, False: 203k] ------------------ 7343| 8.08k| { 7344| 8.08k| const int codepoint1 = get_codepoint(); 7345| 8.08k| int codepoint = codepoint1; // start with codepoint1 7346| | 7347| 8.08k| if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1)) ------------------ | | 1691| 8.08k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 56, False: 8.03k] | | ------------------ ------------------ 7348| 56| { 7349| 56| error_message = "invalid string: '\\u' must be followed by 4 hex digits"; 7350| 56| return token_type::parse_error; 7351| 56| } 7352| | 7353| | // check if code point is a high surrogate 7354| 8.03k| if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF) ------------------ | Branch (7354:33): [True: 823, False: 7.20k] | Branch (7354:57): [True: 508, False: 315] ------------------ 7355| 508| { 7356| | // expect next \uxxxx entry 7357| 508| if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u')) ------------------ | | 1690| 1.00k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 477, False: 31] | | | Branch (1690:94): [True: 492, False: 16] | | | Branch (1690:94): [True: 477, False: 15] | | ------------------ ------------------ 7358| 477| { 7359| 477| const int codepoint2 = get_codepoint(); 7360| | 7361| 477| if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1)) ------------------ | | 1691| 477|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 37, False: 440] | | ------------------ ------------------ 7362| 37| { 7363| 37| error_message = "invalid string: '\\u' must be followed by 4 hex digits"; 7364| 37| return token_type::parse_error; 7365| 37| } 7366| | 7367| | // check if codepoint2 is a low surrogate 7368| 440| if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF)) ------------------ | | 1690| 864|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 420, False: 20] | | | Branch (1690:94): [True: 424, False: 16] | | | Branch (1690:94): [True: 420, False: 4] | | ------------------ ------------------ 7369| 420| { 7370| | // overwrite codepoint 7371| 420| codepoint = static_cast( 7372| | // high surrogate occupies the most significant 22 bits 7373| 420| (static_cast(codepoint1) << 10u) 7374| | // low surrogate occupies the least significant 15 bits 7375| 420| + static_cast(codepoint2) 7376| | // there is still the 0xD800, 0xDC00 and 0x10000 noise 7377| | // in the result, so we have to subtract with: 7378| | // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00 7379| 420| - 0x35FDC00u); 7380| 420| } 7381| 20| else 7382| 20| { 7383| 20| error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"; 7384| 20| return token_type::parse_error; 7385| 20| } 7386| 440| } 7387| 31| else 7388| 31| { 7389| 31| error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF"; 7390| 31| return token_type::parse_error; 7391| 31| } 7392| 508| } 7393| 7.52k| else 7394| 7.52k| { 7395| 7.52k| if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF)) ------------------ | | 1691| 7.83k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 13, False: 7.50k] | | | Branch (1691:94): [True: 315, False: 7.20k] | | | Branch (1691:94): [True: 13, False: 302] | | ------------------ ------------------ 7396| 13| { 7397| 13| error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF"; 7398| 13| return token_type::parse_error; 7399| 13| } 7400| 7.52k| } 7401| | 7402| | // result of the above calculation yields a proper codepoint 7403| 7.92k| JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF); ------------------ | | 2571| 7.92k| #define JSON_ASSERT(x) assert(x) ------------------ 7404| | 7405| | // translate codepoint into bytes 7406| 7.92k| if (codepoint < 0x80) ------------------ | Branch (7406:33): [True: 6.00k, False: 1.92k] ------------------ 7407| 6.00k| { 7408| | // 1-byte characters: 0xxxxxxx (ASCII) 7409| 6.00k| add(static_cast(codepoint)); 7410| 6.00k| } 7411| 1.92k| else if (codepoint <= 0x7FF) ------------------ | Branch (7411:38): [True: 222, False: 1.70k] ------------------ 7412| 222| { 7413| | // 2-byte characters: 110xxxxx 10xxxxxx 7414| 222| add(static_cast(0xC0u | (static_cast(codepoint) >> 6u))); 7415| 222| add(static_cast(0x80u | (static_cast(codepoint) & 0x3Fu))); 7416| 222| } 7417| 1.70k| else if (codepoint <= 0xFFFF) ------------------ | Branch (7417:38): [True: 1.28k, False: 420] ------------------ 7418| 1.28k| { 7419| | // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx 7420| 1.28k| add(static_cast(0xE0u | (static_cast(codepoint) >> 12u))); 7421| 1.28k| add(static_cast(0x80u | ((static_cast(codepoint) >> 6u) & 0x3Fu))); 7422| 1.28k| add(static_cast(0x80u | (static_cast(codepoint) & 0x3Fu))); 7423| 1.28k| } 7424| 420| else 7425| 420| { 7426| | // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 7427| 420| add(static_cast(0xF0u | (static_cast(codepoint) >> 18u))); 7428| 420| add(static_cast(0x80u | ((static_cast(codepoint) >> 12u) & 0x3Fu))); 7429| 420| add(static_cast(0x80u | ((static_cast(codepoint) >> 6u) & 0x3Fu))); 7430| 420| add(static_cast(0x80u | (static_cast(codepoint) & 0x3Fu))); 7431| 420| } 7432| | 7433| 7.92k| break; 7434| 8.03k| } 7435| | 7436| | // other characters after escape 7437| 13| default: ------------------ | Branch (7437:25): [True: 13, False: 212k] ------------------ 7438| 13| error_message = "invalid string: forbidden character after backslash"; 7439| 13| return token_type::parse_error; 7440| 212k| } 7441| | 7442| 211k| break; 7443| 212k| } 7444| | 7445| | // invalid control characters 7446| 211k| case 0x00: ------------------ | Branch (7446:17): [True: 6, False: 102M] ------------------ 7447| 6| { 7448| 6| error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000"; 7449| 6| return token_type::parse_error; 7450| 212k| } 7451| | 7452| 1| case 0x01: ------------------ | Branch (7452:17): [True: 1, False: 102M] ------------------ 7453| 1| { 7454| 1| error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001"; 7455| 1| return token_type::parse_error; 7456| 212k| } 7457| | 7458| 2| case 0x02: ------------------ | Branch (7458:17): [True: 2, False: 102M] ------------------ 7459| 2| { 7460| 2| error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002"; 7461| 2| return token_type::parse_error; 7462| 212k| } 7463| | 7464| 1| case 0x03: ------------------ | Branch (7464:17): [True: 1, False: 102M] ------------------ 7465| 1| { 7466| 1| error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003"; 7467| 1| return token_type::parse_error; 7468| 212k| } 7469| | 7470| 1| case 0x04: ------------------ | Branch (7470:17): [True: 1, False: 102M] ------------------ 7471| 1| { 7472| 1| error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004"; 7473| 1| return token_type::parse_error; 7474| 212k| } 7475| | 7476| 1| case 0x05: ------------------ | Branch (7476:17): [True: 1, False: 102M] ------------------ 7477| 1| { 7478| 1| error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005"; 7479| 1| return token_type::parse_error; 7480| 212k| } 7481| | 7482| 1| case 0x06: ------------------ | Branch (7482:17): [True: 1, False: 102M] ------------------ 7483| 1| { 7484| 1| error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006"; 7485| 1| return token_type::parse_error; 7486| 212k| } 7487| | 7488| 2| case 0x07: ------------------ | Branch (7488:17): [True: 2, False: 102M] ------------------ 7489| 2| { 7490| 2| error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007"; 7491| 2| return token_type::parse_error; 7492| 212k| } 7493| | 7494| 3| case 0x08: ------------------ | Branch (7494:17): [True: 3, False: 102M] ------------------ 7495| 3| { 7496| 3| error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b"; 7497| 3| return token_type::parse_error; 7498| 212k| } 7499| | 7500| 1| case 0x09: ------------------ | Branch (7500:17): [True: 1, False: 102M] ------------------ 7501| 1| { 7502| 1| error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t"; 7503| 1| return token_type::parse_error; 7504| 212k| } 7505| | 7506| 2| case 0x0A: ------------------ | Branch (7506:17): [True: 2, False: 102M] ------------------ 7507| 2| { 7508| 2| error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n"; 7509| 2| return token_type::parse_error; 7510| 212k| } 7511| | 7512| 2| case 0x0B: ------------------ | Branch (7512:17): [True: 2, False: 102M] ------------------ 7513| 2| { 7514| 2| error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B"; 7515| 2| return token_type::parse_error; 7516| 212k| } 7517| | 7518| 1| case 0x0C: ------------------ | Branch (7518:17): [True: 1, False: 102M] ------------------ 7519| 1| { 7520| 1| error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f"; 7521| 1| return token_type::parse_error; 7522| 212k| } 7523| | 7524| 2| case 0x0D: ------------------ | Branch (7524:17): [True: 2, False: 102M] ------------------ 7525| 2| { 7526| 2| error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r"; 7527| 2| return token_type::parse_error; 7528| 212k| } 7529| | 7530| 1| case 0x0E: ------------------ | Branch (7530:17): [True: 1, False: 102M] ------------------ 7531| 1| { 7532| 1| error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E"; 7533| 1| return token_type::parse_error; 7534| 212k| } 7535| | 7536| 2| case 0x0F: ------------------ | Branch (7536:17): [True: 2, False: 102M] ------------------ 7537| 2| { 7538| 2| error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F"; 7539| 2| return token_type::parse_error; 7540| 212k| } 7541| | 7542| 2| case 0x10: ------------------ | Branch (7542:17): [True: 2, False: 102M] ------------------ 7543| 2| { 7544| 2| error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010"; 7545| 2| return token_type::parse_error; 7546| 212k| } 7547| | 7548| 1| case 0x11: ------------------ | Branch (7548:17): [True: 1, False: 102M] ------------------ 7549| 1| { 7550| 1| error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011"; 7551| 1| return token_type::parse_error; 7552| 212k| } 7553| | 7554| 2| case 0x12: ------------------ | Branch (7554:17): [True: 2, False: 102M] ------------------ 7555| 2| { 7556| 2| error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012"; 7557| 2| return token_type::parse_error; 7558| 212k| } 7559| | 7560| 2| case 0x13: ------------------ | Branch (7560:17): [True: 2, False: 102M] ------------------ 7561| 2| { 7562| 2| error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013"; 7563| 2| return token_type::parse_error; 7564| 212k| } 7565| | 7566| 1| case 0x14: ------------------ | Branch (7566:17): [True: 1, False: 102M] ------------------ 7567| 1| { 7568| 1| error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014"; 7569| 1| return token_type::parse_error; 7570| 212k| } 7571| | 7572| 2| case 0x15: ------------------ | Branch (7572:17): [True: 2, False: 102M] ------------------ 7573| 2| { 7574| 2| error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015"; 7575| 2| return token_type::parse_error; 7576| 212k| } 7577| | 7578| 2| case 0x16: ------------------ | Branch (7578:17): [True: 2, False: 102M] ------------------ 7579| 2| { 7580| 2| error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016"; 7581| 2| return token_type::parse_error; 7582| 212k| } 7583| | 7584| 2| case 0x17: ------------------ | Branch (7584:17): [True: 2, False: 102M] ------------------ 7585| 2| { 7586| 2| error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017"; 7587| 2| return token_type::parse_error; 7588| 212k| } 7589| | 7590| 1| case 0x18: ------------------ | Branch (7590:17): [True: 1, False: 102M] ------------------ 7591| 1| { 7592| 1| error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018"; 7593| 1| return token_type::parse_error; 7594| 212k| } 7595| | 7596| 3| case 0x19: ------------------ | Branch (7596:17): [True: 3, False: 102M] ------------------ 7597| 3| { 7598| 3| error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019"; 7599| 3| return token_type::parse_error; 7600| 212k| } 7601| | 7602| 3| case 0x1A: ------------------ | Branch (7602:17): [True: 3, False: 102M] ------------------ 7603| 3| { 7604| 3| error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A"; 7605| 3| return token_type::parse_error; 7606| 212k| } 7607| | 7608| 1| case 0x1B: ------------------ | Branch (7608:17): [True: 1, False: 102M] ------------------ 7609| 1| { 7610| 1| error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B"; 7611| 1| return token_type::parse_error; 7612| 212k| } 7613| | 7614| 1| case 0x1C: ------------------ | Branch (7614:17): [True: 1, False: 102M] ------------------ 7615| 1| { 7616| 1| error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C"; 7617| 1| return token_type::parse_error; 7618| 212k| } 7619| | 7620| 1| case 0x1D: ------------------ | Branch (7620:17): [True: 1, False: 102M] ------------------ 7621| 1| { 7622| 1| error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D"; 7623| 1| return token_type::parse_error; 7624| 212k| } 7625| | 7626| 3| case 0x1E: ------------------ | Branch (7626:17): [True: 3, False: 102M] ------------------ 7627| 3| { 7628| 3| error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E"; 7629| 3| return token_type::parse_error; 7630| 212k| } 7631| | 7632| 1| case 0x1F: ------------------ | Branch (7632:17): [True: 1, False: 102M] ------------------ 7633| 1| { 7634| 1| error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F"; 7635| 1| return token_type::parse_error; 7636| 212k| } 7637| | 7638| | // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace)) 7639| 21.8k| case 0x20: ------------------ | Branch (7639:17): [True: 21.8k, False: 102M] ------------------ 7640| 53.2k| case 0x21: ------------------ | Branch (7640:17): [True: 31.4k, False: 102M] ------------------ 7641| 93.7k| case 0x23: ------------------ | Branch (7641:17): [True: 40.4k, False: 102M] ------------------ 7642| 164k| case 0x24: ------------------ | Branch (7642:17): [True: 70.9k, False: 102M] ------------------ 7643| 181k| case 0x25: ------------------ | Branch (7643:17): [True: 16.6k, False: 102M] ------------------ 7644| 224k| case 0x26: ------------------ | Branch (7644:17): [True: 43.0k, False: 102M] ------------------ 7645| 18.3M| case 0x27: ------------------ | Branch (7645:17): [True: 18.1M, False: 84.8M] ------------------ 7646| 18.4M| case 0x28: ------------------ | Branch (7646:17): [True: 128k, False: 102M] ------------------ 7647| 18.5M| case 0x29: ------------------ | Branch (7647:17): [True: 66.7k, False: 102M] ------------------ 7648| 18.5M| case 0x2A: ------------------ | Branch (7648:17): [True: 11.5k, False: 102M] ------------------ 7649| 18.5M| case 0x2B: ------------------ | Branch (7649:17): [True: 33.6k, False: 102M] ------------------ 7650| 26.8M| case 0x2C: ------------------ | Branch (7650:17): [True: 8.25M, False: 94.6M] ------------------ 7651| 27.1M| case 0x2D: ------------------ | Branch (7651:17): [True: 292k, False: 102M] ------------------ 7652| 29.0M| case 0x2E: ------------------ | Branch (7652:17): [True: 1.94M, False: 100M] ------------------ 7653| 29.3M| case 0x2F: ------------------ | Branch (7653:17): [True: 287k, False: 102M] ------------------ 7654| 36.3M| case 0x30: ------------------ | Branch (7654:17): [True: 7.02M, False: 95.8M] ------------------ 7655| 37.2M| case 0x31: ------------------ | Branch (7655:17): [True: 828k, False: 102M] ------------------ 7656| 37.6M| case 0x32: ------------------ | Branch (7656:17): [True: 465k, False: 102M] ------------------ 7657| 37.9M| case 0x33: ------------------ | Branch (7657:17): [True: 330k, False: 102M] ------------------ 7658| 38.2M| case 0x34: ------------------ | Branch (7658:17): [True: 299k, False: 102M] ------------------ 7659| 38.7M| case 0x35: ------------------ | Branch (7659:17): [True: 406k, False: 102M] ------------------ 7660| 45.6M| case 0x36: ------------------ | Branch (7660:17): [True: 6.95M, False: 95.9M] ------------------ 7661| 45.8M| case 0x37: ------------------ | Branch (7661:17): [True: 147k, False: 102M] ------------------ 7662| 47.0M| case 0x38: ------------------ | Branch (7662:17): [True: 1.23M, False: 101M] ------------------ 7663| 54.5M| case 0x39: ------------------ | Branch (7663:17): [True: 7.54M, False: 95.3M] ------------------ 7664| 54.6M| case 0x3A: ------------------ | Branch (7664:17): [True: 45.6k, False: 102M] ------------------ 7665| 54.8M| case 0x3B: ------------------ | Branch (7665:17): [True: 186k, False: 102M] ------------------ 7666| 54.8M| case 0x3C: ------------------ | Branch (7666:17): [True: 5.73k, False: 102M] ------------------ 7667| 54.8M| case 0x3D: ------------------ | Branch (7667:17): [True: 17.4k, False: 102M] ------------------ 7668| 54.8M| case 0x3E: ------------------ | Branch (7668:17): [True: 4.49k, False: 102M] ------------------ 7669| 55.0M| case 0x3F: ------------------ | Branch (7669:17): [True: 206k, False: 102M] ------------------ 7670| 55.3M| case 0x40: ------------------ | Branch (7670:17): [True: 276k, False: 102M] ------------------ 7671| 55.3M| case 0x41: ------------------ | Branch (7671:17): [True: 14.4k, False: 102M] ------------------ 7672| 55.3M| case 0x42: ------------------ | Branch (7672:17): [True: 4.10k, False: 102M] ------------------ 7673| 59.3M| case 0x43: ------------------ | Branch (7673:17): [True: 4.03M, False: 98.8M] ------------------ 7674| 59.3M| case 0x44: ------------------ | Branch (7674:17): [True: 6.38k, False: 102M] ------------------ 7675| 59.4M| case 0x45: ------------------ | Branch (7675:17): [True: 40.0k, False: 102M] ------------------ 7676| 59.4M| case 0x46: ------------------ | Branch (7676:17): [True: 12.3k, False: 102M] ------------------ 7677| 73.2M| case 0x47: ------------------ | Branch (7677:17): [True: 13.8M, False: 89.0M] ------------------ 7678| 74.2M| case 0x48: ------------------ | Branch (7678:17): [True: 943k, False: 101M] ------------------ 7679| 74.2M| case 0x49: ------------------ | Branch (7679:17): [True: 17.1k, False: 102M] ------------------ 7680| 74.2M| case 0x4A: ------------------ | Branch (7680:17): [True: 13.4k, False: 102M] ------------------ 7681| 75.5M| case 0x4B: ------------------ | Branch (7681:17): [True: 1.30M, False: 101M] ------------------ 7682| 75.5M| case 0x4C: ------------------ | Branch (7682:17): [True: 21.8k, False: 102M] ------------------ 7683| 75.5M| case 0x4D: ------------------ | Branch (7683:17): [True: 4.77k, False: 102M] ------------------ 7684| 75.5M| case 0x4E: ------------------ | Branch (7684:17): [True: 5.64k, False: 102M] ------------------ 7685| 75.6M| case 0x4F: ------------------ | Branch (7685:17): [True: 16.7k, False: 102M] ------------------ 7686| 75.6M| case 0x50: ------------------ | Branch (7686:17): [True: 7.62k, False: 102M] ------------------ 7687| 75.6M| case 0x51: ------------------ | Branch (7687:17): [True: 6.58k, False: 102M] ------------------ 7688| 75.6M| case 0x52: ------------------ | Branch (7688:17): [True: 3.52k, False: 102M] ------------------ 7689| 75.6M| case 0x53: ------------------ | Branch (7689:17): [True: 17.1k, False: 102M] ------------------ 7690| 75.6M| case 0x54: ------------------ | Branch (7690:17): [True: 36.6k, False: 102M] ------------------ 7691| 75.6M| case 0x55: ------------------ | Branch (7691:17): [True: 4.54k, False: 102M] ------------------ 7692| 75.7M| case 0x56: ------------------ | Branch (7692:17): [True: 55.3k, False: 102M] ------------------ 7693| 76.2M| case 0x57: ------------------ | Branch (7693:17): [True: 481k, False: 102M] ------------------ 7694| 76.2M| case 0x58: ------------------ | Branch (7694:17): [True: 8.72k, False: 102M] ------------------ 7695| 76.2M| case 0x59: ------------------ | Branch (7695:17): [True: 4.35k, False: 102M] ------------------ 7696| 76.2M| case 0x5A: ------------------ | Branch (7696:17): [True: 13.2k, False: 102M] ------------------ 7697| 82.8M| case 0x5B: ------------------ | Branch (7697:17): [True: 6.62M, False: 96.2M] ------------------ 7698| 82.9M| case 0x5D: ------------------ | Branch (7698:17): [True: 32.0k, False: 102M] ------------------ 7699| 83.0M| case 0x5E: ------------------ | Branch (7699:17): [True: 192k, False: 102M] ------------------ 7700| 83.2M| case 0x5F: ------------------ | Branch (7700:17): [True: 127k, False: 102M] ------------------ 7701| 83.2M| case 0x60: ------------------ | Branch (7701:17): [True: 12.7k, False: 102M] ------------------ 7702| 91.1M| case 0x61: ------------------ | Branch (7702:17): [True: 7.93M, False: 94.9M] ------------------ 7703| 91.2M| case 0x62: ------------------ | Branch (7703:17): [True: 114k, False: 102M] ------------------ 7704| 91.3M| case 0x63: ------------------ | Branch (7704:17): [True: 50.0k, False: 102M] ------------------ 7705| 91.4M| case 0x64: ------------------ | Branch (7705:17): [True: 80.6k, False: 102M] ------------------ 7706| 96.2M| case 0x65: ------------------ | Branch (7706:17): [True: 4.84M, False: 98.0M] ------------------ 7707| 96.3M| case 0x66: ------------------ | Branch (7707:17): [True: 60.1k, False: 102M] ------------------ 7708| 96.4M| case 0x67: ------------------ | Branch (7708:17): [True: 94.7k, False: 102M] ------------------ 7709| 96.4M| case 0x68: ------------------ | Branch (7709:17): [True: 74.6k, False: 102M] ------------------ 7710| 96.9M| case 0x69: ------------------ | Branch (7710:17): [True: 462k, False: 102M] ------------------ 7711| 96.9M| case 0x6A: ------------------ | Branch (7711:17): [True: 11.0k, False: 102M] ------------------ 7712| 97.0M| case 0x6B: ------------------ | Branch (7712:17): [True: 60.6k, False: 102M] ------------------ 7713| 97.2M| case 0x6C: ------------------ | Branch (7713:17): [True: 253k, False: 102M] ------------------ 7714| 97.6M| case 0x6D: ------------------ | Branch (7714:17): [True: 341k, False: 102M] ------------------ 7715| 97.9M| case 0x6E: ------------------ | Branch (7715:17): [True: 326k, False: 102M] ------------------ 7716| 98.0M| case 0x6F: ------------------ | Branch (7716:17): [True: 125k, False: 102M] ------------------ 7717| 98.1M| case 0x70: ------------------ | Branch (7717:17): [True: 114k, False: 102M] ------------------ 7718| 98.1M| case 0x71: ------------------ | Branch (7718:17): [True: 13.8k, False: 102M] ------------------ 7719| 98.4M| case 0x72: ------------------ | Branch (7719:17): [True: 268k, False: 102M] ------------------ 7720| 98.9M| case 0x73: ------------------ | Branch (7720:17): [True: 445k, False: 102M] ------------------ 7721| 99.4M| case 0x74: ------------------ | Branch (7721:17): [True: 517k, False: 102M] ------------------ 7722| 99.5M| case 0x75: ------------------ | Branch (7722:17): [True: 117k, False: 102M] ------------------ 7723| 99.5M| case 0x76: ------------------ | Branch (7723:17): [True: 25.7k, False: 102M] ------------------ 7724| 99.5M| case 0x77: ------------------ | Branch (7724:17): [True: 22.8k, False: 102M] ------------------ 7725| 99.6M| case 0x78: ------------------ | Branch (7725:17): [True: 55.8k, False: 102M] ------------------ 7726| 100M| case 0x79: ------------------ | Branch (7726:17): [True: 562k, False: 102M] ------------------ 7727| 100M| case 0x7A: ------------------ | Branch (7727:17): [True: 33.9k, False: 102M] ------------------ 7728| 101M| case 0x7B: ------------------ | Branch (7728:17): [True: 1.07M, False: 101M] ------------------ 7729| 101M| case 0x7C: ------------------ | Branch (7729:17): [True: 185k, False: 102M] ------------------ 7730| 102M| case 0x7D: ------------------ | Branch (7730:17): [True: 885k, False: 102M] ------------------ 7731| 102M| case 0x7E: ------------------ | Branch (7731:17): [True: 12.9k, False: 102M] ------------------ 7732| 102M| case 0x7F: ------------------ | Branch (7732:17): [True: 4.95k, False: 102M] ------------------ 7733| 102M| { 7734| 102M| add(current); 7735| 102M| break; 7736| 102M| } 7737| | 7738| | // U+0080..U+07FF: bytes C2..DF 80..BF 7739| 1.73k| case 0xC2: ------------------ | Branch (7739:17): [True: 1.73k, False: 102M] ------------------ 7740| 2.60k| case 0xC3: ------------------ | Branch (7740:17): [True: 873, False: 102M] ------------------ 7741| 2.69k| case 0xC4: ------------------ | Branch (7741:17): [True: 91, False: 102M] ------------------ 7742| 2.80k| case 0xC5: ------------------ | Branch (7742:17): [True: 104, False: 102M] ------------------ 7743| 3.08k| case 0xC6: ------------------ | Branch (7743:17): [True: 286, False: 102M] ------------------ 7744| 3.38k| case 0xC7: ------------------ | Branch (7744:17): [True: 300, False: 102M] ------------------ 7745| 3.67k| case 0xC8: ------------------ | Branch (7745:17): [True: 284, False: 102M] ------------------ 7746| 3.89k| case 0xC9: ------------------ | Branch (7746:17): [True: 224, False: 102M] ------------------ 7747| 4.74k| case 0xCA: ------------------ | Branch (7747:17): [True: 853, False: 102M] ------------------ 7748| 5.10k| case 0xCB: ------------------ | Branch (7748:17): [True: 353, False: 102M] ------------------ 7749| 5.84k| case 0xCC: ------------------ | Branch (7749:17): [True: 742, False: 102M] ------------------ 7750| 6.58k| case 0xCD: ------------------ | Branch (7750:17): [True: 738, False: 102M] ------------------ 7751| 7.72k| case 0xCE: ------------------ | Branch (7751:17): [True: 1.14k, False: 102M] ------------------ 7752| 8.07k| case 0xCF: ------------------ | Branch (7752:17): [True: 349, False: 102M] ------------------ 7753| 8.71k| case 0xD0: ------------------ | Branch (7753:17): [True: 635, False: 102M] ------------------ 7754| 9.11k| case 0xD1: ------------------ | Branch (7754:17): [True: 402, False: 102M] ------------------ 7755| 9.52k| case 0xD2: ------------------ | Branch (7755:17): [True: 408, False: 102M] ------------------ 7756| 9.73k| case 0xD3: ------------------ | Branch (7756:17): [True: 217, False: 102M] ------------------ 7757| 10.0k| case 0xD4: ------------------ | Branch (7757:17): [True: 305, False: 102M] ------------------ 7758| 11.1k| case 0xD5: ------------------ | Branch (7758:17): [True: 1.15k, False: 102M] ------------------ 7759| 11.4k| case 0xD6: ------------------ | Branch (7759:17): [True: 246, False: 102M] ------------------ 7760| 11.6k| case 0xD7: ------------------ | Branch (7760:17): [True: 222, False: 102M] ------------------ 7761| 11.9k| case 0xD8: ------------------ | Branch (7761:17): [True: 264, False: 102M] ------------------ 7762| 12.1k| case 0xD9: ------------------ | Branch (7762:17): [True: 197, False: 102M] ------------------ 7763| 12.4k| case 0xDA: ------------------ | Branch (7763:17): [True: 344, False: 102M] ------------------ 7764| 12.8k| case 0xDB: ------------------ | Branch (7764:17): [True: 339, False: 102M] ------------------ 7765| 13.0k| case 0xDC: ------------------ | Branch (7765:17): [True: 214, False: 102M] ------------------ 7766| 13.3k| case 0xDD: ------------------ | Branch (7766:17): [True: 357, False: 102M] ------------------ 7767| 13.6k| case 0xDE: ------------------ | Branch (7767:17): [True: 262, False: 102M] ------------------ 7768| 13.9k| case 0xDF: ------------------ | Branch (7768:17): [True: 286, False: 102M] ------------------ 7769| 13.9k| { 7770| 13.9k| if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF}))) ------------------ | | 1691| 13.9k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 245, False: 13.6k] | | ------------------ ------------------ 7771| 245| { 7772| 245| return token_type::parse_error; 7773| 245| } 7774| 13.6k| break; 7775| 13.9k| } 7776| | 7777| | // U+0800..U+0FFF: bytes E0 A0..BF 80..BF 7778| 13.6k| case 0xE0: ------------------ | Branch (7778:17): [True: 2.26k, False: 102M] ------------------ 7779| 2.26k| { 7780| 2.26k| if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF})))) ------------------ | | 1691| 2.26k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 22, False: 2.24k] | | ------------------ ------------------ 7781| 22| { 7782| 22| return token_type::parse_error; 7783| 22| } 7784| 2.24k| break; 7785| 2.26k| } 7786| | 7787| | // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF 7788| | // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF 7789| 2.24k| case 0xE1: ------------------ | Branch (7789:17): [True: 355, False: 102M] ------------------ 7790| 10.2k| case 0xE2: ------------------ | Branch (7790:17): [True: 9.94k, False: 102M] ------------------ 7791| 12.0k| case 0xE3: ------------------ | Branch (7791:17): [True: 1.75k, False: 102M] ------------------ 7792| 12.3k| case 0xE4: ------------------ | Branch (7792:17): [True: 279, False: 102M] ------------------ 7793| 12.5k| case 0xE5: ------------------ | Branch (7793:17): [True: 266, False: 102M] ------------------ 7794| 12.6k| case 0xE6: ------------------ | Branch (7794:17): [True: 73, False: 102M] ------------------ 7795| 13.0k| case 0xE7: ------------------ | Branch (7795:17): [True: 345, False: 102M] ------------------ 7796| 13.1k| case 0xE8: ------------------ | Branch (7796:17): [True: 150, False: 102M] ------------------ 7797| 13.4k| case 0xE9: ------------------ | Branch (7797:17): [True: 300, False: 102M] ------------------ 7798| 13.6k| case 0xEA: ------------------ | Branch (7798:17): [True: 215, False: 102M] ------------------ 7799| 13.9k| case 0xEB: ------------------ | Branch (7799:17): [True: 310, False: 102M] ------------------ 7800| 16.0k| case 0xEC: ------------------ | Branch (7800:17): [True: 2.01k, False: 102M] ------------------ 7801| 17.4k| case 0xEE: ------------------ | Branch (7801:17): [True: 1.44k, False: 102M] ------------------ 7802| 18.7k| case 0xEF: ------------------ | Branch (7802:17): [True: 1.33k, False: 102M] ------------------ 7803| 18.7k| { 7804| 18.7k| if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF})))) ------------------ | | 1691| 18.7k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 113, False: 18.6k] | | ------------------ ------------------ 7805| 113| { 7806| 113| return token_type::parse_error; 7807| 113| } 7808| 18.6k| break; 7809| 18.7k| } 7810| | 7811| | // U+D000..U+D7FF: bytes ED 80..9F 80..BF 7812| 18.6k| case 0xED: ------------------ | Branch (7812:17): [True: 1.01k, False: 102M] ------------------ 7813| 1.01k| { 7814| 1.01k| if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF})))) ------------------ | | 1691| 1.01k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 24, False: 988] | | ------------------ ------------------ 7815| 24| { 7816| 24| return token_type::parse_error; 7817| 24| } 7818| 988| break; 7819| 1.01k| } 7820| | 7821| | // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF 7822| 988| case 0xF0: ------------------ | Branch (7822:17): [True: 732, False: 102M] ------------------ 7823| 732| { 7824| 732| if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) ------------------ | | 1691| 732|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 33, False: 699] | | ------------------ ------------------ 7825| 33| { 7826| 33| return token_type::parse_error; 7827| 33| } 7828| 699| break; 7829| 732| } 7830| | 7831| | // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF 7832| 699| case 0xF1: ------------------ | Branch (7832:17): [True: 224, False: 102M] ------------------ 7833| 576| case 0xF2: ------------------ | Branch (7833:17): [True: 352, False: 102M] ------------------ 7834| 11.5k| case 0xF3: ------------------ | Branch (7834:17): [True: 10.9k, False: 102M] ------------------ 7835| 11.5k| { 7836| 11.5k| if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) ------------------ | | 1691| 11.5k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 53, False: 11.4k] | | ------------------ ------------------ 7837| 53| { 7838| 53| return token_type::parse_error; 7839| 53| } 7840| 11.4k| break; 7841| 11.5k| } 7842| | 7843| | // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF 7844| 11.4k| case 0xF4: ------------------ | Branch (7844:17): [True: 401, False: 102M] ------------------ 7845| 401| { 7846| 401| if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF})))) ------------------ | | 1691| 401|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 28, False: 373] | | ------------------ ------------------ 7847| 28| { 7848| 28| return token_type::parse_error; 7849| 28| } 7850| 373| break; 7851| 401| } 7852| | 7853| | // remaining bytes (80..C1 and F5..FF) are ill-formed 7854| 373| default: ------------------ | Branch (7854:17): [True: 28, False: 102M] ------------------ 7855| 28| { 7856| 28| error_message = "invalid string: ill-formed UTF-8 byte"; 7857| 28| return token_type::parse_error; 7858| 401| } 7859| 102M| } 7860| 102M| } 7861| 251k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE5resetEv: 8346| 7.69M| { 8347| 7.69M| token_buffer.clear(); 8348| 7.69M| token_string.clear(); 8349| 7.69M| decimal_point_position = std::string::npos; 8350| 7.69M| token_string.push_back(char_traits::to_char_type(current)); 8351| 7.69M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE3addEm: 8428| 112M| { 8429| 112M| token_buffer.push_back(static_cast(c)); 8430| 112M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE13get_codepointEv: 7193| 8.56k| { 7194| | // this function only makes sense after reading `\u` 7195| 8.56k| JSON_ASSERT(current == 'u'); ------------------ | | 2571| 8.56k| #define JSON_ASSERT(x) assert(x) ------------------ 7196| 8.56k| int codepoint = 0; 7197| | 7198| 8.56k| const auto factors = { 12u, 8u, 4u, 0u }; 7199| 8.56k| for (const auto factor : factors) ------------------ | Branch (7199:32): [True: 34.0k, False: 8.47k] ------------------ 7200| 34.0k| { 7201| 34.0k| get(); 7202| | 7203| 34.0k| if (current >= '0' && current <= '9') ------------------ | Branch (7203:17): [True: 34.0k, False: 11] | Branch (7203:35): [True: 25.2k, False: 8.82k] ------------------ 7204| 25.2k| { 7205| 25.2k| codepoint += static_cast((static_cast(current) - 0x30u) << factor); 7206| 25.2k| } 7207| 8.83k| else if (current >= 'A' && current <= 'F') ------------------ | Branch (7207:22): [True: 8.81k, False: 18] | Branch (7207:40): [True: 1.91k, False: 6.90k] ------------------ 7208| 1.91k| { 7209| 1.91k| codepoint += static_cast((static_cast(current) - 0x37u) << factor); 7210| 1.91k| } 7211| 6.92k| else if (current >= 'a' && current <= 'f') ------------------ | Branch (7211:22): [True: 6.89k, False: 32] | Branch (7211:40): [True: 6.82k, False: 61] ------------------ 7212| 6.82k| { 7213| 6.82k| codepoint += static_cast((static_cast(current) - 0x57u) << factor); 7214| 6.82k| } 7215| 93| else 7216| 93| { 7217| 93| return -1; 7218| 93| } 7219| 34.0k| } 7220| | 7221| 8.47k| JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF); ------------------ | | 2571| 8.47k| #define JSON_ASSERT(x) assert(x) ------------------ 7222| 8.47k| return codepoint; 7223| 8.56k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE18next_byte_in_rangeESt16initializer_listImE: 7241| 48.6k| { 7242| 48.6k| JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6); ------------------ | | 2571| 48.6k| #define JSON_ASSERT(x) assert(x) ------------------ 7243| 48.6k| add(current); 7244| | 7245| 143k| for (auto range = ranges.begin(); range != ranges.end(); ++range) ------------------ | Branch (7245:43): [True: 95.8k, False: 48.1k] ------------------ 7246| 95.8k| { 7247| 95.8k| get(); 7248| 95.8k| if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions) ------------------ | | 1690| 191k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 95.2k, False: 518] | | | Branch (1690:94): [True: 95.7k, False: 71] | | | Branch (1690:94): [True: 95.2k, False: 447] | | ------------------ ------------------ 7249| 95.2k| { 7250| 95.2k| add(current); 7251| 95.2k| } 7252| 518| else 7253| 518| { 7254| 518| error_message = "invalid string: ill-formed UTF-8 byte"; 7255| 518| return false; 7256| 518| } 7257| 95.8k| } 7258| | 7259| 48.1k| return true; 7260| 48.6k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE11scan_numberEv: 7993| 7.43M| { 7994| | // reset token_buffer to store the number's bytes 7995| 7.43M| reset(); 7996| | 7997| | // the type of the parsed number; initially set to unsigned; will be 7998| | // changed if minus sign, decimal point or exponent is read 7999| 7.43M| token_type number_type = token_type::value_unsigned; 8000| | 8001| | // state (init): we just found out we need to scan a number 8002| 7.43M| switch (current) 8003| 7.43M| { 8004| 47.9k| case '-': ------------------ | Branch (8004:13): [True: 47.9k, False: 7.39M] ------------------ 8005| 47.9k| { 8006| 47.9k| add(current); 8007| 47.9k| goto scan_number_minus; 8008| 0| } 8009| | 8010| 2.70M| case '0': ------------------ | Branch (8010:13): [True: 2.70M, False: 4.73M] ------------------ 8011| 2.70M| { 8012| 2.70M| add(current); 8013| 2.70M| goto scan_number_zero; 8014| 0| } 8015| | 8016| 247k| case '1': ------------------ | Branch (8016:13): [True: 247k, False: 7.19M] ------------------ 8017| 282k| case '2': ------------------ | Branch (8017:13): [True: 35.2k, False: 7.40M] ------------------ 8018| 550k| case '3': ------------------ | Branch (8018:13): [True: 268k, False: 7.17M] ------------------ 8019| 945k| case '4': ------------------ | Branch (8019:13): [True: 395k, False: 7.04M] ------------------ 8020| 1.17M| case '5': ------------------ | Branch (8020:13): [True: 229k, False: 7.21M] ------------------ 8021| 1.95M| case '6': ------------------ | Branch (8021:13): [True: 778k, False: 6.66M] ------------------ 8022| 1.98M| case '7': ------------------ | Branch (8022:13): [True: 33.4k, False: 7.40M] ------------------ 8023| 2.16M| case '8': ------------------ | Branch (8023:13): [True: 175k, False: 7.26M] ------------------ 8024| 4.68M| case '9': ------------------ | Branch (8024:13): [True: 2.51M, False: 4.91M] ------------------ 8025| 4.68M| { 8026| 4.68M| add(current); 8027| 4.68M| goto scan_number_any1; 8028| 2.16M| } 8029| | 8030| | // all other characters are rejected outside scan_number() 8031| 0| default: // LCOV_EXCL_LINE ------------------ | Branch (8031:13): [True: 0, False: 7.43M] ------------------ 8032| 0| JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 8033| 7.43M| } 8034| | 8035| 47.9k|scan_number_minus: 8036| | // state: we just parsed a leading minus sign 8037| 47.9k| number_type = token_type::value_integer; 8038| 47.9k| switch (get()) 8039| 47.9k| { 8040| 4.56k| case '0': ------------------ | Branch (8040:13): [True: 4.56k, False: 43.3k] ------------------ 8041| 4.56k| { 8042| 4.56k| add(current); 8043| 4.56k| goto scan_number_zero; 8044| 0| } 8045| | 8046| 4.23k| case '1': ------------------ | Branch (8046:13): [True: 4.23k, False: 43.7k] ------------------ 8047| 8.92k| case '2': ------------------ | Branch (8047:13): [True: 4.69k, False: 43.2k] ------------------ 8048| 10.9k| case '3': ------------------ | Branch (8048:13): [True: 1.99k, False: 45.9k] ------------------ 8049| 14.6k| case '4': ------------------ | Branch (8049:13): [True: 3.67k, False: 44.2k] ------------------ 8050| 15.2k| case '5': ------------------ | Branch (8050:13): [True: 665, False: 47.2k] ------------------ 8051| 16.7k| case '6': ------------------ | Branch (8051:13): [True: 1.50k, False: 46.4k] ------------------ 8052| 17.4k| case '7': ------------------ | Branch (8052:13): [True: 672, False: 47.2k] ------------------ 8053| 20.2k| case '8': ------------------ | Branch (8053:13): [True: 2.77k, False: 45.1k] ------------------ 8054| 43.3k| case '9': ------------------ | Branch (8054:13): [True: 23.1k, False: 24.7k] ------------------ 8055| 43.3k| { 8056| 43.3k| add(current); 8057| 43.3k| goto scan_number_any1; 8058| 20.2k| } 8059| | 8060| 18| default: ------------------ | Branch (8060:13): [True: 18, False: 47.9k] ------------------ 8061| 18| { 8062| 18| error_message = "invalid number; expected digit after '-'"; 8063| 18| return token_type::parse_error; 8064| 20.2k| } 8065| 47.9k| } 8066| | 8067| 2.71M|scan_number_zero: 8068| | // state: we just parse a zero (maybe with a leading minus sign) 8069| 2.71M| switch (get()) 8070| 2.71M| { 8071| 4.01k| case '.': ------------------ | Branch (8071:13): [True: 4.01k, False: 2.70M] ------------------ 8072| 4.01k| { 8073| 4.01k| add(decimal_point_char); 8074| 4.01k| decimal_point_position = token_buffer.size() - 1; 8075| 4.01k| goto scan_number_decimal1; 8076| 0| } 8077| | 8078| 595| case 'e': ------------------ | Branch (8078:13): [True: 595, False: 2.71M] ------------------ 8079| 1.68k| case 'E': ------------------ | Branch (8079:13): [True: 1.08k, False: 2.71M] ------------------ 8080| 1.68k| { 8081| 1.68k| add(current); 8082| 1.68k| goto scan_number_exponent; 8083| 595| } 8084| | 8085| 2.70M| default: ------------------ | Branch (8085:13): [True: 2.70M, False: 5.69k] ------------------ 8086| 2.70M| goto scan_number_done; 8087| 2.71M| } 8088| | 8089| 5.50M|scan_number_any1: 8090| | // state: we just parsed a number 0-9 (maybe with a leading minus sign) 8091| 5.50M| switch (get()) 8092| 5.50M| { 8093| 29.8k| case '0': ------------------ | Branch (8093:13): [True: 29.8k, False: 5.47M] ------------------ 8094| 75.9k| case '1': ------------------ | Branch (8094:13): [True: 46.1k, False: 5.45M] ------------------ 8095| 160k| case '2': ------------------ | Branch (8095:13): [True: 84.6k, False: 5.41M] ------------------ 8096| 240k| case '3': ------------------ | Branch (8096:13): [True: 79.7k, False: 5.42M] ------------------ 8097| 305k| case '4': ------------------ | Branch (8097:13): [True: 65.2k, False: 5.43M] ------------------ 8098| 364k| case '5': ------------------ | Branch (8098:13): [True: 58.7k, False: 5.44M] ------------------ 8099| 597k| case '6': ------------------ | Branch (8099:13): [True: 233k, False: 5.26M] ------------------ 8100| 665k| case '7': ------------------ | Branch (8100:13): [True: 67.3k, False: 5.43M] ------------------ 8101| 692k| case '8': ------------------ | Branch (8101:13): [True: 26.9k, False: 5.47M] ------------------ 8102| 775k| case '9': ------------------ | Branch (8102:13): [True: 83.4k, False: 5.41M] ------------------ 8103| 775k| { 8104| 775k| add(current); 8105| 775k| goto scan_number_any1; 8106| 692k| } 8107| | 8108| 17.0k| case '.': ------------------ | Branch (8108:13): [True: 17.0k, False: 5.48M] ------------------ 8109| 17.0k| { 8110| 17.0k| add(decimal_point_char); 8111| 17.0k| decimal_point_position = token_buffer.size() - 1; 8112| 17.0k| goto scan_number_decimal1; 8113| 692k| } 8114| | 8115| 2.46k| case 'e': ------------------ | Branch (8115:13): [True: 2.46k, False: 5.49M] ------------------ 8116| 314k| case 'E': ------------------ | Branch (8116:13): [True: 312k, False: 5.18M] ------------------ 8117| 314k| { 8118| 314k| add(current); 8119| 314k| goto scan_number_exponent; 8120| 2.46k| } 8121| | 8122| 4.39M| default: ------------------ | Branch (8122:13): [True: 4.39M, False: 1.10M] ------------------ 8123| 4.39M| goto scan_number_done; 8124| 5.50M| } 8125| | 8126| 21.0k|scan_number_decimal1: 8127| | // state: we just parsed a decimal point 8128| 21.0k| number_type = token_type::value_float; 8129| 21.0k| switch (get()) 8130| 21.0k| { 8131| 2.92k| case '0': ------------------ | Branch (8131:13): [True: 2.92k, False: 18.1k] ------------------ 8132| 4.16k| case '1': ------------------ | Branch (8132:13): [True: 1.24k, False: 19.8k] ------------------ 8133| 5.13k| case '2': ------------------ | Branch (8133:13): [True: 968, False: 20.0k] ------------------ 8134| 5.36k| case '3': ------------------ | Branch (8134:13): [True: 224, False: 20.8k] ------------------ 8135| 16.0k| case '4': ------------------ | Branch (8135:13): [True: 10.6k, False: 10.3k] ------------------ 8136| 16.1k| case '5': ------------------ | Branch (8136:13): [True: 63, False: 20.9k] ------------------ 8137| 16.3k| case '6': ------------------ | Branch (8137:13): [True: 277, False: 20.7k] ------------------ 8138| 16.4k| case '7': ------------------ | Branch (8138:13): [True: 95, False: 20.9k] ------------------ 8139| 18.1k| case '8': ------------------ | Branch (8139:13): [True: 1.66k, False: 19.3k] ------------------ 8140| 21.0k| case '9': ------------------ | Branch (8140:13): [True: 2.88k, False: 18.1k] ------------------ 8141| 21.0k| { 8142| 21.0k| add(current); 8143| 21.0k| goto scan_number_decimal2; 8144| 18.1k| } 8145| | 8146| 23| default: ------------------ | Branch (8146:13): [True: 23, False: 21.0k] ------------------ 8147| 23| { 8148| 23| error_message = "invalid number; expected digit after '.'"; 8149| 23| return token_type::parse_error; 8150| 18.1k| } 8151| 21.0k| } 8152| | 8153| 96.9k|scan_number_decimal2: 8154| | // we just parsed at least one number after a decimal point 8155| 96.9k| switch (get()) 8156| 96.9k| { 8157| 8.03k| case '0': ------------------ | Branch (8157:13): [True: 8.03k, False: 88.9k] ------------------ 8158| 16.3k| case '1': ------------------ | Branch (8158:13): [True: 8.30k, False: 88.6k] ------------------ 8159| 23.2k| case '2': ------------------ | Branch (8159:13): [True: 6.95k, False: 90.0k] ------------------ 8160| 28.0k| case '3': ------------------ | Branch (8160:13): [True: 4.78k, False: 92.1k] ------------------ 8161| 39.6k| case '4': ------------------ | Branch (8161:13): [True: 11.6k, False: 85.3k] ------------------ 8162| 42.2k| case '5': ------------------ | Branch (8162:13): [True: 2.59k, False: 94.3k] ------------------ 8163| 54.2k| case '6': ------------------ | Branch (8163:13): [True: 11.9k, False: 85.0k] ------------------ 8164| 61.3k| case '7': ------------------ | Branch (8164:13): [True: 7.12k, False: 89.8k] ------------------ 8165| 63.4k| case '8': ------------------ | Branch (8165:13): [True: 2.08k, False: 94.8k] ------------------ 8166| 75.9k| case '9': ------------------ | Branch (8166:13): [True: 12.5k, False: 84.4k] ------------------ 8167| 75.9k| { 8168| 75.9k| add(current); 8169| 75.9k| goto scan_number_decimal2; 8170| 63.4k| } 8171| | 8172| 568| case 'e': ------------------ | Branch (8172:13): [True: 568, False: 96.3k] ------------------ 8173| 899| case 'E': ------------------ | Branch (8173:13): [True: 331, False: 96.6k] ------------------ 8174| 899| { 8175| 899| add(current); 8176| 899| goto scan_number_exponent; 8177| 568| } 8178| | 8179| 20.1k| default: ------------------ | Branch (8179:13): [True: 20.1k, False: 76.8k] ------------------ 8180| 20.1k| goto scan_number_done; 8181| 96.9k| } 8182| | 8183| 317k|scan_number_exponent: 8184| | // we just parsed an exponent 8185| 317k| number_type = token_type::value_float; 8186| 317k| switch (get()) 8187| 317k| { 8188| 430| case '+': ------------------ | Branch (8188:13): [True: 430, False: 316k] ------------------ 8189| 2.36k| case '-': ------------------ | Branch (8189:13): [True: 1.93k, False: 315k] ------------------ 8190| 2.36k| { 8191| 2.36k| add(current); 8192| 2.36k| goto scan_number_sign; 8193| 430| } 8194| | 8195| 1.60k| case '0': ------------------ | Branch (8195:13): [True: 1.60k, False: 315k] ------------------ 8196| 2.62k| case '1': ------------------ | Branch (8196:13): [True: 1.02k, False: 316k] ------------------ 8197| 308k| case '2': ------------------ | Branch (8197:13): [True: 306k, False: 10.9k] ------------------ 8198| 310k| case '3': ------------------ | Branch (8198:13): [True: 1.58k, False: 315k] ------------------ 8199| 311k| case '4': ------------------ | Branch (8199:13): [True: 1.26k, False: 315k] ------------------ 8200| 311k| case '5': ------------------ | Branch (8200:13): [True: 251, False: 316k] ------------------ 8201| 312k| case '6': ------------------ | Branch (8201:13): [True: 694, False: 316k] ------------------ 8202| 312k| case '7': ------------------ | Branch (8202:13): [True: 322, False: 316k] ------------------ 8203| 313k| case '8': ------------------ | Branch (8203:13): [True: 918, False: 316k] ------------------ 8204| 314k| case '9': ------------------ | Branch (8204:13): [True: 892, False: 316k] ------------------ 8205| 314k| { 8206| 314k| add(current); 8207| 314k| goto scan_number_any2; 8208| 313k| } 8209| | 8210| 24| default: ------------------ | Branch (8210:13): [True: 24, False: 317k] ------------------ 8211| 24| { 8212| 24| error_message = 8213| 24| "invalid number; expected '+', '-', or digit after exponent"; 8214| 24| return token_type::parse_error; 8215| 313k| } 8216| 317k| } 8217| | 8218| 2.36k|scan_number_sign: 8219| | // we just parsed an exponent sign 8220| 2.36k| switch (get()) 8221| 2.36k| { 8222| 62| case '0': ------------------ | Branch (8222:13): [True: 62, False: 2.30k] ------------------ 8223| 176| case '1': ------------------ | Branch (8223:13): [True: 114, False: 2.24k] ------------------ 8224| 484| case '2': ------------------ | Branch (8224:13): [True: 308, False: 2.05k] ------------------ 8225| 1.10k| case '3': ------------------ | Branch (8225:13): [True: 618, False: 1.74k] ------------------ 8226| 1.17k| case '4': ------------------ | Branch (8226:13): [True: 73, False: 2.28k] ------------------ 8227| 1.19k| case '5': ------------------ | Branch (8227:13): [True: 19, False: 2.34k] ------------------ 8228| 1.22k| case '6': ------------------ | Branch (8228:13): [True: 30, False: 2.33k] ------------------ 8229| 1.26k| case '7': ------------------ | Branch (8229:13): [True: 45, False: 2.31k] ------------------ 8230| 2.30k| case '8': ------------------ | Branch (8230:13): [True: 1.03k, False: 1.32k] ------------------ 8231| 2.34k| case '9': ------------------ | Branch (8231:13): [True: 40, False: 2.32k] ------------------ 8232| 2.34k| { 8233| 2.34k| add(current); 8234| 2.34k| goto scan_number_any2; 8235| 2.30k| } 8236| | 8237| 17| default: ------------------ | Branch (8237:13): [True: 17, False: 2.34k] ------------------ 8238| 17| { 8239| 17| error_message = "invalid number; expected digit after exponent sign"; 8240| 17| return token_type::parse_error; 8241| 2.30k| } 8242| 2.36k| } 8243| | 8244| 628k|scan_number_any2: 8245| | // we just parsed a number after the exponent or exponent sign 8246| 628k| switch (get()) 8247| 628k| { 8248| 744| case '0': ------------------ | Branch (8248:13): [True: 744, False: 627k] ------------------ 8249| 2.80k| case '1': ------------------ | Branch (8249:13): [True: 2.06k, False: 626k] ------------------ 8250| 3.60k| case '2': ------------------ | Branch (8250:13): [True: 794, False: 627k] ------------------ 8251| 307k| case '3': ------------------ | Branch (8251:13): [True: 304k, False: 324k] ------------------ 8252| 308k| case '4': ------------------ | Branch (8252:13): [True: 1.28k, False: 627k] ------------------ 8253| 309k| case '5': ------------------ | Branch (8253:13): [True: 668, False: 627k] ------------------ 8254| 310k| case '6': ------------------ | Branch (8254:13): [True: 489, False: 627k] ------------------ 8255| 310k| case '7': ------------------ | Branch (8255:13): [True: 530, False: 627k] ------------------ 8256| 311k| case '8': ------------------ | Branch (8256:13): [True: 522, False: 627k] ------------------ 8257| 311k| case '9': ------------------ | Branch (8257:13): [True: 122, False: 628k] ------------------ 8258| 311k| { 8259| 311k| add(current); 8260| 311k| goto scan_number_any2; 8261| 311k| } 8262| | 8263| 317k| default: ------------------ | Branch (8263:13): [True: 317k, False: 311k] ------------------ 8264| 317k| goto scan_number_done; 8265| 628k| } 8266| | 8267| 7.43M|scan_number_done: 8268| | // unget the character after the number (we only read it to know that 8269| | // we are done scanning a number) 8270| 7.43M| unget(); 8271| | 8272| 7.43M| char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg) 8273| 7.43M| errno = 0; 8274| | 8275| | // try to parse integers first and fall back to floats 8276| 7.43M| if (number_type == token_type::value_unsigned) ------------------ | Branch (8276:13): [True: 7.05M, False: 382k] ------------------ 8277| 7.05M| { 8278| 7.05M| const auto x = std::strtoull(token_buffer.data(), &endptr, 10); 8279| | 8280| | // we checked the number format before 8281| 7.05M| JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); ------------------ | | 2571| 7.05M| #define JSON_ASSERT(x) assert(x) ------------------ 8282| | 8283| 7.05M| if (errno != ERANGE) ------------------ | Branch (8283:17): [True: 7.05M, False: 1.72k] ------------------ 8284| 7.05M| { 8285| 7.05M| value_unsigned = static_cast(x); 8286| 7.05M| if (value_unsigned == x) ------------------ | Branch (8286:21): [True: 7.05M, False: 0] ------------------ 8287| 7.05M| { 8288| 7.05M| return token_type::value_unsigned; 8289| 7.05M| } 8290| 7.05M| } 8291| 7.05M| } 8292| 382k| else if (number_type == token_type::value_integer) ------------------ | Branch (8292:18): [True: 45.2k, False: 337k] ------------------ 8293| 45.2k| { 8294| 45.2k| const auto x = std::strtoll(token_buffer.data(), &endptr, 10); 8295| | 8296| | // we checked the number format before 8297| 45.2k| JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); ------------------ | | 2571| 45.2k| #define JSON_ASSERT(x) assert(x) ------------------ 8298| | 8299| 45.2k| if (errno != ERANGE) ------------------ | Branch (8299:17): [True: 44.1k, False: 1.05k] ------------------ 8300| 44.1k| { 8301| 44.1k| value_integer = static_cast(x); 8302| 44.1k| if (value_integer == x) ------------------ | Branch (8302:21): [True: 44.1k, False: 0] ------------------ 8303| 44.1k| { 8304| 44.1k| return token_type::value_integer; 8305| 44.1k| } 8306| 44.1k| } 8307| 45.2k| } 8308| | 8309| | // this code is reached if we parse a floating-point number or if an 8310| | // integer conversion above failed 8311| 339k| strtof(value_float, token_buffer.data(), &endptr); 8312| | 8313| | // we checked the number format before 8314| 339k| JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size()); ------------------ | | 2571| 339k| #define JSON_ASSERT(x) assert(x) ------------------ 8315| | 8316| 339k| return token_type::value_float; 8317| 7.43M| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE6strtofERdPKcPPc: 7942| 339k| { 7943| 339k| f = std::strtod(str, endptr); 7944| 339k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEED2Ev: 7157| 11.2k| ~lexer() = default; _ZN8nlohmann16json_abi_v3_12_06detail13input_adapterIPKhEENS1_30iterator_input_adapter_factoryIT_vE12adapter_typeES6_S6_: 6875| 11.2k|{ 6876| 11.2k| using factory_type = iterator_input_adapter_factory; 6877| 11.2k| return factory_type::create(first, last); 6878| 11.2k|} _ZN8nlohmann16json_abi_v3_12_06detail30iterator_input_adapter_factoryIPKhvE6createES4_S4_: 6843| 11.2k| { 6844| 11.2k| return adapter_type(std::move(first), std::move(last)); 6845| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail22iterator_input_adapterIPKhEC2ES4_S4_: 6612| 11.2k| : current(std::move(first)), end(std::move(last)) 6613| 11.2k| {} _ZN8nlohmann16json_abi_v3_12_06detail6parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE5parseEbRSG_: 12952| 11.2k| { 12953| 11.2k| if (callback) ------------------ | Branch (12953:13): [True: 0, False: 11.2k] ------------------ 12954| 0| { 12955| 0| json_sax_dom_callback_parser sdp(result, callback, allow_exceptions, &m_lexer); 12956| 0| sax_parse_internal(&sdp); 12957| | 12958| | // in strict mode, input must be completely read 12959| 0| if (strict && (get_token() != token_type::end_of_input)) ------------------ | Branch (12959:17): [True: 0, False: 0] | Branch (12959:27): [True: 0, False: 0] ------------------ 12960| 0| { 12961| 0| sdp.parse_error(m_lexer.get_position(), 12962| 0| m_lexer.get_token_string(), 12963| 0| parse_error::create(101, m_lexer.get_position(), 12964| 0| exception_message(token_type::end_of_input, "value"), nullptr)); 12965| 0| } 12966| | 12967| | // in case of an error, return discarded value 12968| 0| if (sdp.is_errored()) ------------------ | Branch (12968:17): [True: 0, False: 0] ------------------ 12969| 0| { 12970| 0| result = value_t::discarded; 12971| 0| return; 12972| 0| } 12973| | 12974| | // set top-level value to null if it was discarded by the callback 12975| | // function 12976| 0| if (result.is_discarded()) ------------------ | Branch (12976:17): [True: 0, False: 0] ------------------ 12977| 0| { 12978| 0| result = nullptr; 12979| 0| } 12980| 0| } 12981| 11.2k| else 12982| 11.2k| { 12983| 11.2k| json_sax_dom_parser sdp(result, allow_exceptions, &m_lexer); 12984| 11.2k| sax_parse_internal(&sdp); 12985| | 12986| | // in strict mode, input must be completely read 12987| 11.2k| if (strict && (get_token() != token_type::end_of_input)) ------------------ | Branch (12987:17): [True: 8.67k, False: 2.59k] | Branch (12987:27): [True: 125, False: 8.54k] ------------------ 12988| 125| { 12989| 125| sdp.parse_error(m_lexer.get_position(), 12990| 125| m_lexer.get_token_string(), 12991| 125| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr)); 12992| 125| } 12993| | 12994| | // in case of an error, return discarded value 12995| 11.2k| if (sdp.is_errored()) ------------------ | Branch (12995:17): [True: 0, False: 11.2k] ------------------ 12996| 0| { 12997| 0| result = value_t::discarded; 12998| 0| return; 12999| 0| } 13000| 11.2k| } 13001| | 13002| 11.2k| result.assert_invariant(); 13003| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail12out_of_rangeC2EiPKc: 4726| 16| out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEmPKcDpRKT_: 4380| 2.70k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 2.70k| return ::strlen(cstr) + concat_length(rest...); 4383| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSB_OSC_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail12unknown_sizeEv: 8799| 1.80M|{ 8800| 1.80M| return (std::numeric_limits::max)(); 8801| 1.80M|} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dataC2Ev: 24250| 7.51M| data() noexcept = default; _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2ERKSA_: 20542| 70.3k| json_value(const string_t& value) : string(create(value)) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createISA_JRKSA_EEEPT_DpOT0_: 20396| 70.3k| { 20397| 70.3k| AllocatorType alloc; 20398| 70.3k| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 70.3k| auto deleter = [&](T * obj) 20401| 70.3k| { 20402| 70.3k| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 70.3k| }; 20404| 70.3k| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 70.3k| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 70.3k| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 70.3k| return obj.release(); 20408| 70.3k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2Eb: 20462| 7.56k| json_value(boolean_t v) noexcept : boolean(v) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2El: 20464| 44.1k| json_value(number_integer_t v) noexcept : number_integer(v) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2Em: 20466| 7.05M| json_value(number_unsigned_t v) noexcept : number_unsigned(v) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2Ed: 20468| 339k| json_value(number_float_t v) noexcept : number_float(v) {} _ZN8nlohmann16json_abi_v3_12_06detail20primitive_iterator_t7set_endEv: 13447| 5.47k| { 13448| 5.47k| m_it = end_value; 13449| 5.47k| } _ZN8nlohmann16json_abi_v3_12_06detail20primitive_iterator_t9set_beginEv: 13441| 5.46k| { 13442| 5.46k| m_it = begin_value; 13443| 5.46k| } _ZN8nlohmann16json_abi_v3_12_06detaileqENS1_20primitive_iterator_tES2_: 13464| 10.9k| { 13465| 10.9k| return lhs.m_it == rhs.m_it; 13466| 10.9k| } _ZNK8nlohmann16json_abi_v3_12_06detail20primitive_iterator_t8is_beginEv: 13453| 5.46k| { 13454| 5.46k| return m_it == begin_value; 13455| 5.46k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE9is_stringEv: 21413| 64.7k| { 21414| 64.7k| return m_data.m_type == value_t::string; 21415| 64.7k| } _ZN8nlohmann16json_abi_v3_12_06detail10type_errorC2EiPKc: 4709| 73| type_error(int id_, const char* what_arg) : exception(id_, what_arg) {} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJPKcEEEmS4_DpRKT_: 4380| 1.84k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 1.84k| return ::strlen(cstr) + concat_length(rest...); 4383| 1.84k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPKcJETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_: 4440| 1.84k|{ 4441| 1.84k| out.append(std::forward(arg)); 4442| 1.84k| concat_into(out, std::forward(rest)...); 4443| 1.84k|} _ZN8nlohmann16json_abi_v3_12_06detail20primitive_iterator_tppEv: 13486| 5.46k| { 13487| 5.46k| ++m_it; 13488| 5.46k| return *this; 13489| 5.46k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRSA_SA_TnNS2_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SI_EE5valueEiE4typeELi0EEEOT_: 20855| 70.3k| { 20856| 70.3k| JSONSerializer::to_json(*this, std::forward(val)); 20857| 70.3k| set_parents(); 20858| 70.3k| assert_invariant(); 20859| 70.3k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE7to_jsonINS0_10basic_jsonINS2_3mapENS2_6vectorES8_blmdS6_S1_NSD_IhNS6_IhEEEEvEERS8_EEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6163| 70.3k| { 6164| 70.3k| ::nlohmann::to_json(j, std::forward(val)); 6165| 70.3k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERSD_EEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6107| 70.3k| { 6108| 70.3k| return to_json(j, std::forward(val)); 6109| 70.3k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEESC_TnNS4_9enable_ifIXsr3std16is_constructibleINT_8string_tET0_EE5valueEiE4typeELi0EEEvRSI_RKSK_: 5953| 70.3k|{ 5954| 70.3k| external_constructor::construct(j, s); 5955| 70.3k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE3EE9constructINS0_10basic_jsonINSt3__13mapENS7_6vectorENS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_RKNSK_8string_tE: 5713| 70.3k| { 5714| 70.3k| j.m_data.m_value.destroy(j.m_data.m_type); 5715| 70.3k| j.m_data.m_type = value_t::string; 5716| 70.3k| j.m_data.m_value = s; 5717| 70.3k| j.assert_invariant(); 5718| 70.3k| } _ZN8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE10get_stringEv: 8457| 589k| { 8458| | // translate decimal points from locale back to '.' (#4084) 8459| 589k| if (decimal_point_char != '.' && decimal_point_position != std::string::npos) ------------------ | Branch (8459:13): [True: 0, False: 589k] | Branch (8459:42): [True: 0, False: 0] ------------------ 8460| 0| { 8461| 0| token_buffer[decimal_point_position] = '.'; 8462| 0| } 8463| 589k| return token_buffer; 8464| 589k| } _ZNK8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE16get_number_floatEv: 8451| 339k| { 8452| 339k| return value_float; 8453| 339k| } _ZN8nlohmann16json_abi_v3_12_06detail12out_of_range6createIDnTnNSt3__19enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEES6_: 4719| 16| { 4720| 16| const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg); 4721| 16| return {id_, w.c_str()}; 4722| 16| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA26_KcS9_cEEET_DpOT0_: 4477| 16|{ 4478| 16| OutStringType str; 4479| 16| str.reserve(concat_length(args...)); 4480| 16| concat_into(str, std::forward(args)...); 4481| 16| return str; 4482| 16|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEcEEEmPKcDpRKT_: 4380| 4.68k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 4.68k| return ::strlen(cstr) + concat_length(rest...); 4383| 4.68k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJcEEEmRKT_DpRKT0_: 4387| 4.68k|{ 4388| 4.68k| return str.size() + concat_length(rest...); 4389| 4.68k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJEEEmcDpRKT_: 4374| 4.68k|{ 4375| 4.68k| return 1 + concat_length(rest...); 4376| 4.68k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA26_KcJS9_cETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 16|{ 4441| 16| out.append(std::forward(arg)); 4442| 16| concat_into(out, std::forward(rest)...); 4443| 16|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JcETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSB_OSC_DpOT1_: 4440| 1.98k|{ 4441| 1.98k| out.append(std::forward(arg)); 4442| 1.98k| concat_into(out, std::forward(rest)...); 4443| 1.98k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEcJETnNS3_9enable_ifIXaantsr24detect_string_can_appendIT_T0_EE5valuesr27detect_string_can_append_opISB_SC_EE5valueEiE4typeELi0EEEvRSB_OSC_DpOT1_: 4449| 4.68k|{ 4450| 4.68k| out += std::forward(arg); 4451| 4.68k| concat_into(out, std::forward(rest)...); 4452| 4.68k|} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRddTnNS2_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SI_EE5valueEiE4typeELi0EEEOT_: 20855| 339k| { 20856| 339k| JSONSerializer::to_json(*this, std::forward(val)); 20857| 339k| set_parents(); 20858| 339k| assert_invariant(); 20859| 339k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIdvE7to_jsonINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEERdEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6163| 339k| { 6164| 339k| ::nlohmann::to_json(j, std::forward(val)); 6165| 339k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERdEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6107| 339k| { 6108| 339k| return to_json(j, std::forward(val)); 6109| 339k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEdTnNS4_9enable_ifIXsr3std17is_floating_pointIT0_EE5valueEiE4typeELi0EEEvRT_SI_: 5966| 339k|{ 5967| 339k| external_constructor::construct(j, static_cast(val)); 5968| 339k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINSt3__13mapENS7_6vectorENS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_14number_float_tE: 5768| 339k| { 5769| 339k| j.m_data.m_value.destroy(j.m_data.m_type); 5770| 339k| j.m_data.m_type = value_t::number_float; 5771| 339k| j.m_data.m_value = val; 5772| 339k| j.assert_invariant(); 5773| 339k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRbbTnNS2_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SI_EE5valueEiE4typeELi0EEEOT_: 20855| 7.56k| { 20856| 7.56k| JSONSerializer::to_json(*this, std::forward(val)); 20857| 7.56k| set_parents(); 20858| 7.56k| assert_invariant(); 20859| 7.56k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIbvE7to_jsonINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEERbEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6163| 7.56k| { 6164| 7.56k| ::nlohmann::to_json(j, std::forward(val)); 6165| 7.56k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERbEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6107| 7.56k| { 6108| 7.56k| return to_json(j, std::forward(val)); 6109| 7.56k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEbTnNS4_9enable_ifIXsr3std7is_sameIT0_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRSJ_SI_: 5933| 7.56k|{ 5934| 7.56k| external_constructor::construct(j, b); 5935| 7.56k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINSt3__13mapENS7_6vectorENS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_9boolean_tE: 5700| 7.56k| { 5701| 7.56k| j.m_data.m_value.destroy(j.m_data.m_type); 5702| 7.56k| j.m_data.m_type = value_t::boolean; 5703| 7.56k| j.m_data.m_value = b; 5704| 7.56k| j.assert_invariant(); 5705| 7.56k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRllTnNS2_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SI_EE5valueEiE4typeELi0EEEOT_: 20855| 44.1k| { 20856| 44.1k| JSONSerializer::to_json(*this, std::forward(val)); 20857| 44.1k| set_parents(); 20858| 44.1k| assert_invariant(); 20859| 44.1k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIlvE7to_jsonINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEERlEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6163| 44.1k| { 6164| 44.1k| ::nlohmann::to_json(j, std::forward(val)); 6165| 44.1k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERlEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6107| 44.1k| { 6108| 44.1k| return to_json(j, std::forward(val)); 6109| 44.1k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEElTnNS4_9enable_ifIXsr26is_compatible_integer_typeINT_16number_integer_tET0_EE5valueEiE4typeELi0EEEvRSI_SK_: 5980| 44.1k|{ 5981| 44.1k| external_constructor::construct(j, static_cast(val)); 5982| 44.1k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINSt3__13mapENS7_6vectorENS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_16number_integer_tE: 5794| 44.1k| { 5795| 44.1k| j.m_data.m_value.destroy(j.m_data.m_type); 5796| 44.1k| j.m_data.m_type = value_t::number_integer; 5797| 44.1k| j.m_data.m_value = val; 5798| 44.1k| j.assert_invariant(); 5799| 44.1k| } _ZNK8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE18get_number_integerEv: 8439| 44.1k| { 8440| 44.1k| return value_integer; 8441| 44.1k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRmmTnNS2_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SI_EE5valueEiE4typeELi0EEEOT_: 20855| 7.05M| { 20856| 7.05M| JSONSerializer::to_json(*this, std::forward(val)); 20857| 7.05M| set_parents(); 20858| 7.05M| assert_invariant(); 20859| 7.05M| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerImvE7to_jsonINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEERmEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6163| 7.05M| { 6164| 7.05M| ::nlohmann::to_json(j, std::forward(val)); 6165| 7.05M| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERmEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6107| 7.05M| { 6108| 7.05M| return to_json(j, std::forward(val)); 6109| 7.05M| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEmTnNS4_9enable_ifIXsr26is_compatible_integer_typeINT_17number_unsigned_tET0_EE5valueEiE4typeELi0EEEvRSI_SK_: 5973| 7.05M|{ 5974| 7.05M| external_constructor::construct(j, static_cast(val)); 5975| 7.05M|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonINSt3__13mapENS7_6vectorENS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_17number_unsigned_tE: 5781| 7.05M| { 5782| 7.05M| j.m_data.m_value.destroy(j.m_data.m_type); 5783| 7.05M| j.m_data.m_type = value_t::number_unsigned; 5784| 7.05M| j.m_data.m_value = val; 5785| 7.05M| j.assert_invariant(); 5786| 7.05M| } _ZNK8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE19get_number_unsignedEv: 8445| 7.05M| { 8446| 7.05M| return value_unsigned; 8447| 7.05M| } _ZNK8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12get_positionEv: 8472| 5.64k| { 8473| 5.64k| return position; 8474| 5.64k| } _ZNK8nlohmann16json_abi_v3_12_06detail10position_tcvmEv: 3173| 2.71k| { 3174| 2.71k| return chars_read_total; 3175| 2.71k| } _ZNK8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE16get_token_stringEv: 8480| 4.70k| { 8481| | // escape control characters 8482| 4.70k| std::string result; 8483| 4.70k| for (const auto c : token_string) ------------------ | Branch (8483:27): [True: 6.77M, False: 4.70k] ------------------ 8484| 6.77M| { 8485| 6.77M| if (static_cast(c) <= '\x1F') ------------------ | Branch (8485:17): [True: 558k, False: 6.21M] ------------------ 8486| 558k| { 8487| | // escape control characters 8488| 558k| std::array cs{{}}; 8489| 558k| static_cast((std::snprintf)(cs.data(), cs.size(), "", static_cast(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg) 8490| 558k| result += cs.data(); 8491| 558k| } 8492| 6.21M| else 8493| 6.21M| { 8494| | // add character as is 8495| 6.21M| result.push_back(static_cast(c)); 8496| 6.21M| } 8497| 6.77M| } 8498| | 8499| 4.70k| return result; 8500| 4.70k| } _ZN8nlohmann16json_abi_v3_12_06detail11parse_error6createIDnTnNSt3__19enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEES6_: 4640| 2.70k| { 4641| 2.70k| const std::string w = concat(exception::name("parse_error", id_), "parse error", 4642| 2.70k| position_string(pos), ": ", exception::diagnostics(context), what_arg); 4643| 2.70k| return {id_, pos.chars_read_total, w.c_str()}; 4644| 2.70k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJS9_RA12_KcS9_RA3_SA_S9_RKS9_EEET_DpOT0_: 4477| 2.70k|{ 4478| 2.70k| OutStringType str; 4479| 2.70k| str.reserve(concat_length(args...)); 4480| 2.70k| concat_into(str, std::forward(args)...); 4481| 2.70k| return str; 4482| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJA12_cS9_A3_cS9_S9_EEEmRKT_DpRKT0_: 4387| 2.70k|{ 4388| 2.70k| return str.size() + concat_length(rest...); 4389| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEA3_cS9_S9_EEEmPKcDpRKT_: 4380| 2.70k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 2.70k| return ::strlen(cstr) + concat_length(rest...); 4383| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJA3_cS9_S9_EEEmRKT_DpRKT0_: 4387| 2.70k|{ 4388| 2.70k| return str.size() + concat_length(rest...); 4389| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EEEmPKcDpRKT_: 4380| 2.70k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 2.70k| return ::strlen(cstr) + concat_length(rest...); 4383| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JRA12_KcS9_RA3_SA_S9_RKS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSI_OSJ_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA12_KcJS9_RA3_SA_S9_RKS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSI_OSJ_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JRA3_KcS9_RKS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSG_OSH_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA3_KcJS9_RKS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSG_OSH_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11parse_error15position_stringERKNS1_10position_tE: 4671| 2.70k| { 4672| 2.70k| return concat(" at line ", std::to_string(pos.lines_read + 1), 4673| 2.70k| ", column ", std::to_string(pos.chars_read_current_line)); 4674| 2.70k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA10_KcS9_SC_S9_EEET_DpOT0_: 4477| 2.70k|{ 4478| 2.70k| OutStringType str; 4479| 2.70k| str.reserve(concat_length(args...)); 4480| 2.70k| concat_into(str, std::forward(args)...); 4481| 2.70k| return str; 4482| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEA10_cS9_EEEmPKcDpRKT_: 4380| 2.70k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 2.70k| return ::strlen(cstr) + concat_length(rest...); 4383| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJA10_cS9_EEEmRKT_DpRKT0_: 4387| 2.70k|{ 4388| 2.70k| return str.size() + concat_length(rest...); 4389| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA10_KcJS9_SC_S9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_JRA10_KcS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA10_KcJS9_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11parse_errorC2EimPKc: 4668| 2.70k| : exception(id_, what_arg), byte(byte_) {} _ZN8nlohmann16json_abi_v3_12_06detail6parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE17exception_messageENS1_10lexer_baseISG_E10token_typeERKSC_: 13337| 2.70k| { 13338| 2.70k| std::string error_msg = "syntax error "; 13339| | 13340| 2.70k| if (!context.empty()) ------------------ | Branch (13340:13): [True: 2.70k, False: 0] ------------------ 13341| 2.70k| { 13342| 2.70k| error_msg += concat("while parsing ", context, ' '); 13343| 2.70k| } 13344| | 13345| 2.70k| error_msg += "- "; 13346| | 13347| 2.70k| if (last_token == token_type::parse_error) ------------------ | Branch (13347:13): [True: 1.96k, False: 732] ------------------ 13348| 1.96k| { 13349| 1.96k| error_msg += concat(m_lexer.get_error_message(), "; last read: '", 13350| 1.96k| m_lexer.get_token_string(), '\''); 13351| 1.96k| } 13352| 732| else 13353| 732| { 13354| 732| error_msg += concat("unexpected ", lexer_t::token_type_name(last_token)); 13355| 732| } 13356| | 13357| 2.70k| if (expected != token_type::uninitialized) ------------------ | Branch (13357:13): [True: 1.03k, False: 1.66k] ------------------ 13358| 1.03k| { 13359| 1.03k| error_msg += concat("; expected ", lexer_t::token_type_name(expected)); 13360| 1.03k| } 13361| | 13362| 2.70k| return error_msg; 13363| 2.70k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA15_KcRKS9_cEEET_DpOT0_: 4477| 2.70k|{ 4478| 2.70k| OutStringType str; 4479| 2.70k| str.reserve(concat_length(args...)); 4480| 2.70k| concat_into(str, std::forward(args)...); 4481| 2.70k| return str; 4482| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA15_KcJRKS9_cETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSG_OSH_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKS9_JcETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_: 4440| 2.70k|{ 4441| 2.70k| out.append(std::forward(arg)); 4442| 2.70k| concat_into(out, std::forward(rest)...); 4443| 2.70k|} _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJPKcRA15_SA_S9_cEEET_DpOT0_: 4477| 1.96k|{ 4478| 1.96k| OutStringType str; 4479| 1.96k| str.reserve(concat_length(args...)); 4480| 1.96k| concat_into(str, std::forward(args)...); 4481| 1.96k| return str; 4482| 1.96k|} _ZN8nlohmann16json_abi_v3_12_06detail13concat_lengthIJA15_cNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEcEEEmPKcDpRKT_: 4380| 1.96k|{ 4381| | // cppcheck-suppress ignoredReturnValue 4382| 1.96k| return ::strlen(cstr) + concat_length(rest...); 4383| 1.96k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPKcJRA15_SA_S9_cETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_: 4440| 1.96k|{ 4441| 1.96k| out.append(std::forward(arg)); 4442| 1.96k| concat_into(out, std::forward(rest)...); 4443| 1.96k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA15_KcJS9_cETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_: 4440| 1.96k|{ 4441| 1.96k| out.append(std::forward(arg)); 4442| 1.96k| concat_into(out, std::forward(rest)...); 4443| 1.96k|} _ZNK8nlohmann16json_abi_v3_12_06detail5lexerINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE17get_error_messageEv: 8505| 1.96k| { 8506| 1.96k| return error_message; 8507| 1.96k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA12_KcPSA_EEET_DpOT0_: 4477| 1.76k|{ 4478| 1.76k| OutStringType str; 4479| 1.76k| str.reserve(concat_length(args...)); 4480| 1.76k| concat_into(str, std::forward(args)...); 4481| 1.76k| return str; 4482| 1.76k|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA12_KcJPSA_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_: 4440| 1.76k|{ 4441| 1.76k| out.append(std::forward(arg)); 4442| 1.76k| concat_into(out, std::forward(rest)...); 4443| 1.76k|} _ZN8nlohmann16json_abi_v3_12_06detail10lexer_baseINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE15token_type_nameENSH_10token_typeE: 7086| 1.76k| { 7087| 1.76k| switch (t) 7088| 1.76k| { 7089| 0| case token_type::uninitialized: ------------------ | Branch (7089:13): [True: 0, False: 1.76k] ------------------ 7090| 0| return ""; 7091| 5| case token_type::literal_true: ------------------ | Branch (7091:13): [True: 5, False: 1.76k] ------------------ 7092| 5| return "true literal"; 7093| 2| case token_type::literal_false: ------------------ | Branch (7093:13): [True: 2, False: 1.76k] ------------------ 7094| 2| return "false literal"; 7095| 4| case token_type::literal_null: ------------------ | Branch (7095:13): [True: 4, False: 1.76k] ------------------ 7096| 4| return "null literal"; 7097| 199| case token_type::value_string: ------------------ | Branch (7097:13): [True: 199, False: 1.56k] ------------------ 7098| 199| return "string literal"; 7099| 37| case token_type::value_unsigned: ------------------ | Branch (7099:13): [True: 37, False: 1.73k] ------------------ 7100| 72| case token_type::value_integer: ------------------ | Branch (7100:13): [True: 35, False: 1.73k] ------------------ 7101| 90| case token_type::value_float: ------------------ | Branch (7101:13): [True: 18, False: 1.75k] ------------------ 7102| 90| return "number literal"; 7103| 5| case token_type::begin_array: ------------------ | Branch (7103:13): [True: 5, False: 1.76k] ------------------ 7104| 5| return "'['"; 7105| 4| case token_type::begin_object: ------------------ | Branch (7105:13): [True: 4, False: 1.76k] ------------------ 7106| 4| return "'{'"; 7107| 294| case token_type::end_array: ------------------ | Branch (7107:13): [True: 294, False: 1.47k] ------------------ 7108| 294| return "']'"; 7109| 78| case token_type::end_object: ------------------ | Branch (7109:13): [True: 78, False: 1.69k] ------------------ 7110| 78| return "'}'"; 7111| 151| case token_type::name_separator: ------------------ | Branch (7111:13): [True: 151, False: 1.61k] ------------------ 7112| 151| return "':'"; 7113| 18| case token_type::value_separator: ------------------ | Branch (7113:13): [True: 18, False: 1.75k] ------------------ 7114| 18| return "','"; 7115| 0| case token_type::parse_error: ------------------ | Branch (7115:13): [True: 0, False: 1.76k] ------------------ 7116| 0| return ""; 7117| 674| case token_type::end_of_input: ------------------ | Branch (7117:13): [True: 674, False: 1.09k] ------------------ 7118| 674| return "end of input"; 7119| 244| case token_type::literal_or_value: ------------------ | Branch (7119:13): [True: 244, False: 1.52k] ------------------ 7120| 244| return "'[', '{', or a literal"; 7121| | // LCOV_EXCL_START 7122| 0| default: // catch non-enum values ------------------ | Branch (7122:13): [True: 0, False: 1.76k] ------------------ 7123| 0| return "unknown token"; 7124| | // LCOV_EXCL_STOP 7125| 1.76k| } 7126| 1.76k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEaSESE_: 21273| 188k| { 21274| | // check that passed value is valid 21275| 188k| other.assert_invariant(); 21276| | 21277| 188k| using std::swap; 21278| 188k| swap(m_data.m_type, other.m_data.m_type); 21279| 188k| swap(m_data.m_value, other.m_data.m_value); 21280| | 21281| |#if JSON_DIAGNOSTIC_POSITIONS 21282| | swap(start_position, other.start_position); 21283| | swap(end_position, other.end_position); 21284| |#endif 21285| | 21286| 188k| json_base_class_t::operator=(std::move(other)); 21287| | 21288| 188k| set_parents(); 21289| 188k| assert_invariant(); 21290| 188k| return *this; 21291| 188k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEEC2ERSG_bPNS1_5lexerISG_SK_EE: 8833| 11.2k| : root(r), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_) 8834| 11.2k| {} _ZN8nlohmann16json_abi_v3_12_06detail6parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE18sax_parse_internalINS1_19json_sax_dom_parserISG_SK_EEEEbPT_: 13039| 11.2k| { 13040| | // stack to remember the hierarchy of structured values we are parsing 13041| | // true = array; false = object 13042| 11.2k| std::vector states; 13043| | // value to avoid a goto (see comment where set to true) 13044| 11.2k| bool skip_to_state_evaluation = false; 13045| | 13046| 8.45M| while (true) ------------------ | Branch (13046:16): [True: 8.45M, Folded] ------------------ 13047| 8.45M| { 13048| 8.45M| if (!skip_to_state_evaluation) ------------------ | Branch (13048:17): [True: 8.37M, False: 82.8k] ------------------ 13049| 8.37M| { 13050| | // invariant: get_token() was called before each iteration 13051| 8.37M| switch (last_token) 13052| 8.37M| { 13053| 219k| case token_type::begin_object: ------------------ | Branch (13053:21): [True: 219k, False: 8.15M] ------------------ 13054| 219k| { 13055| 219k| if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size()))) ------------------ | | 1691| 219k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 219k] | | ------------------ ------------------ 13056| 0| { 13057| 0| return false; 13058| 0| } 13059| | 13060| | // closing } -> we are done 13061| 219k| if (get_token() == token_type::end_object) ------------------ | Branch (13061:29): [True: 75.3k, False: 143k] ------------------ 13062| 75.3k| { 13063| 75.3k| if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) ------------------ | | 1691| 75.3k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 75.3k] | | ------------------ ------------------ 13064| 0| { 13065| 0| return false; 13066| 0| } 13067| 75.3k| break; 13068| 75.3k| } 13069| | 13070| | // parse key 13071| 143k| if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string)) ------------------ | | 1691| 143k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 116, False: 143k] | | ------------------ ------------------ 13072| 116| { 13073| 116| return sax->parse_error(m_lexer.get_position(), 13074| 116| m_lexer.get_token_string(), 13075| 116| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr)); 13076| 116| } 13077| 143k| if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) ------------------ | | 1691| 143k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 143k] | | ------------------ ------------------ 13078| 0| { 13079| 0| return false; 13080| 0| } 13081| | 13082| | // parse separator (:) 13083| 143k| if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) ------------------ | | 1691| 143k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 33, False: 143k] | | ------------------ ------------------ 13084| 33| { 13085| 33| return sax->parse_error(m_lexer.get_position(), 13086| 33| m_lexer.get_token_string(), 13087| 33| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr)); 13088| 33| } 13089| | 13090| | // remember we are now inside an object 13091| 143k| states.push_back(false); 13092| | 13093| | // parse values 13094| 143k| get_token(); 13095| 143k| continue; 13096| 143k| } 13097| | 13098| 624k| case token_type::begin_array: ------------------ | Branch (13098:21): [True: 624k, False: 7.74M] ------------------ 13099| 624k| { 13100| 624k| if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size()))) ------------------ | | 1691| 624k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 624k] | | ------------------ ------------------ 13101| 0| { 13102| 0| return false; 13103| 0| } 13104| | 13105| | // closing ] -> we are done 13106| 624k| if (get_token() == token_type::end_array) ------------------ | Branch (13106:29): [True: 1.89k, False: 622k] ------------------ 13107| 1.89k| { 13108| 1.89k| if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) ------------------ | | 1691| 1.89k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 1.89k] | | ------------------ ------------------ 13109| 0| { 13110| 0| return false; 13111| 0| } 13112| 1.89k| break; 13113| 1.89k| } 13114| | 13115| | // remember we are now inside an array 13116| 622k| states.push_back(true); 13117| | 13118| | // parse values (no need to call get_token) 13119| 622k| continue; 13120| 624k| } 13121| | 13122| 339k| case token_type::value_float: ------------------ | Branch (13122:21): [True: 339k, False: 8.03M] ------------------ 13123| 339k| { 13124| 339k| const auto res = m_lexer.get_number_float(); 13125| | 13126| 339k| if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res))) ------------------ | | 1691| 339k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 16, False: 339k] | | ------------------ ------------------ 13127| 16| { 13128| 16| return sax->parse_error(m_lexer.get_position(), 13129| 16| m_lexer.get_token_string(), 13130| 16| out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr)); 13131| 16| } 13132| | 13133| 339k| if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string()))) ------------------ | | 1691| 339k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 339k] | | ------------------ ------------------ 13134| 0| { 13135| 0| return false; 13136| 0| } 13137| | 13138| 339k| break; 13139| 339k| } 13140| | 13141| 339k| case token_type::literal_false: ------------------ | Branch (13141:21): [True: 272, False: 8.37M] ------------------ 13142| 272| { 13143| 272| if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false))) ------------------ | | 1691| 272|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 272] | | ------------------ ------------------ 13144| 0| { 13145| 0| return false; 13146| 0| } 13147| 272| break; 13148| 272| } 13149| | 13150| 9.01k| case token_type::literal_null: ------------------ | Branch (13150:21): [True: 9.01k, False: 8.36M] ------------------ 13151| 9.01k| { 13152| 9.01k| if (JSON_HEDLEY_UNLIKELY(!sax->null())) ------------------ | | 1691| 9.01k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 9.01k] | | ------------------ ------------------ 13153| 0| { 13154| 0| return false; 13155| 0| } 13156| 9.01k| break; 13157| 9.01k| } 13158| | 13159| 9.01k| case token_type::literal_true: ------------------ | Branch (13159:21): [True: 7.29k, False: 8.36M] ------------------ 13160| 7.29k| { 13161| 7.29k| if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true))) ------------------ | | 1691| 7.29k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 7.29k] | | ------------------ ------------------ 13162| 0| { 13163| 0| return false; 13164| 0| } 13165| 7.29k| break; 13166| 7.29k| } 13167| | 13168| 44.1k| case token_type::value_integer: ------------------ | Branch (13168:21): [True: 44.1k, False: 8.32M] ------------------ 13169| 44.1k| { 13170| 44.1k| if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer()))) ------------------ | | 1691| 44.1k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 44.1k] | | ------------------ ------------------ 13171| 0| { 13172| 0| return false; 13173| 0| } 13174| 44.1k| break; 13175| 44.1k| } 13176| | 13177| 70.3k| case token_type::value_string: ------------------ | Branch (13177:21): [True: 70.3k, False: 8.30M] ------------------ 13178| 70.3k| { 13179| 70.3k| if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string()))) ------------------ | | 1691| 70.3k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 70.3k] | | ------------------ ------------------ 13180| 0| { 13181| 0| return false; 13182| 0| } 13183| 70.3k| break; 13184| 70.3k| } 13185| | 13186| 7.05M| case token_type::value_unsigned: ------------------ | Branch (13186:21): [True: 7.05M, False: 1.31M] ------------------ 13187| 7.05M| { 13188| 7.05M| if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned()))) ------------------ | | 1691| 7.05M|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 7.05M] | | ------------------ ------------------ 13189| 0| { 13190| 0| return false; 13191| 0| } 13192| 7.05M| break; 13193| 7.05M| } 13194| | 13195| 7.05M| case token_type::parse_error: ------------------ | Branch (13195:21): [True: 1.66k, False: 8.37M] ------------------ 13196| 1.66k| { 13197| | // using "uninitialized" to avoid "expected" message 13198| 1.66k| return sax->parse_error(m_lexer.get_position(), 13199| 1.66k| m_lexer.get_token_string(), 13200| 1.66k| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr)); 13201| 7.05M| } 13202| 225| case token_type::end_of_input: ------------------ | Branch (13202:21): [True: 225, False: 8.37M] ------------------ 13203| 225| { 13204| 225| if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1)) ------------------ | | 1691| 225|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 1, False: 224] | | ------------------ ------------------ 13205| 1| { 13206| 1| return sax->parse_error(m_lexer.get_position(), 13207| 1| m_lexer.get_token_string(), 13208| 1| parse_error::create(101, m_lexer.get_position(), 13209| 1| "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr)); 13210| 1| } 13211| | 13212| 224| return sax->parse_error(m_lexer.get_position(), 13213| 224| m_lexer.get_token_string(), 13214| 224| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr)); 13215| 225| } 13216| 0| case token_type::uninitialized: ------------------ | Branch (13216:21): [True: 0, False: 8.37M] ------------------ 13217| 3| case token_type::end_array: ------------------ | Branch (13217:21): [True: 3, False: 8.37M] ------------------ 13218| 6| case token_type::end_object: ------------------ | Branch (13218:21): [True: 3, False: 8.37M] ------------------ 13219| 9| case token_type::name_separator: ------------------ | Branch (13219:21): [True: 3, False: 8.37M] ------------------ 13220| 20| case token_type::value_separator: ------------------ | Branch (13220:21): [True: 11, False: 8.37M] ------------------ 13221| 20| case token_type::literal_or_value: ------------------ | Branch (13221:21): [True: 0, False: 8.37M] ------------------ 13222| 20| default: // the last token was unexpected ------------------ | Branch (13222:21): [True: 0, False: 8.37M] ------------------ 13223| 20| { 13224| 20| return sax->parse_error(m_lexer.get_position(), 13225| 20| m_lexer.get_token_string(), 13226| 20| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr)); 13227| 20| } 13228| 8.37M| } 13229| 8.37M| } 13230| 82.8k| else 13231| 82.8k| { 13232| 82.8k| skip_to_state_evaluation = false; 13233| 82.8k| } 13234| | 13235| | // we reached this line after we successfully parsed a value 13236| 7.68M| if (states.empty()) ------------------ | Branch (13236:17): [True: 8.67k, False: 7.67M] ------------------ 13237| 8.67k| { 13238| | // empty stack: we reached the end of the hierarchy: done 13239| 8.67k| return true; 13240| 8.67k| } 13241| | 13242| 7.67M| if (states.back()) // array ------------------ | Branch (13242:17): [True: 7.57M, False: 102k] ------------------ 13243| 7.57M| { 13244| | // comma -> next value 13245| 7.57M| if (get_token() == token_type::value_separator) ------------------ | Branch (13245:21): [True: 7.55M, False: 16.8k] ------------------ 13246| 7.55M| { 13247| | // parse a new value 13248| 7.55M| get_token(); 13249| 7.55M| continue; 13250| 7.55M| } 13251| | 13252| | // closing ] 13253| 16.8k| if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array)) ------------------ | | 1690| 16.8k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 16.5k, False: 281] | | ------------------ ------------------ 13254| 16.5k| { 13255| 16.5k| if (JSON_HEDLEY_UNLIKELY(!sax->end_array())) ------------------ | | 1691| 16.5k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 16.5k] | | ------------------ ------------------ 13256| 0| { 13257| 0| return false; 13258| 0| } 13259| | 13260| | // We are done with this array. Before we can parse a 13261| | // new value, we need to evaluate the new state first. 13262| | // By setting skip_to_state_evaluation to false, we 13263| | // are effectively jumping to the beginning of this if. 13264| 16.5k| JSON_ASSERT(!states.empty()); ------------------ | | 2571| 16.5k| #define JSON_ASSERT(x) assert(x) ------------------ 13265| 16.5k| states.pop_back(); 13266| 16.5k| skip_to_state_evaluation = true; 13267| 16.5k| continue; 13268| 16.5k| } 13269| | 13270| 281| return sax->parse_error(m_lexer.get_position(), 13271| 281| m_lexer.get_token_string(), 13272| 281| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr)); 13273| 16.8k| } 13274| | 13275| | // states.back() is false -> object 13276| | 13277| | // comma -> next value 13278| 102k| if (get_token() == token_type::value_separator) ------------------ | Branch (13278:17): [True: 35.7k, False: 66.3k] ------------------ 13279| 35.7k| { 13280| | // parse key 13281| 35.7k| if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string)) ------------------ | | 1691| 35.7k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 72, False: 35.6k] | | ------------------ ------------------ 13282| 72| { 13283| 72| return sax->parse_error(m_lexer.get_position(), 13284| 72| m_lexer.get_token_string(), 13285| 72| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr)); 13286| 72| } 13287| | 13288| 35.6k| if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string()))) ------------------ | | 1691| 35.6k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 35.6k] | | ------------------ ------------------ 13289| 0| { 13290| 0| return false; 13291| 0| } 13292| | 13293| | // parse separator (:) 13294| 35.6k| if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator)) ------------------ | | 1691| 35.6k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 112, False: 35.5k] | | ------------------ ------------------ 13295| 112| { 13296| 112| return sax->parse_error(m_lexer.get_position(), 13297| 112| m_lexer.get_token_string(), 13298| 112| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr)); 13299| 112| } 13300| | 13301| | // parse values 13302| 35.5k| get_token(); 13303| 35.5k| continue; 13304| 35.6k| } 13305| | 13306| | // closing } 13307| 66.3k| if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object)) ------------------ | | 1690| 66.3k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 66.2k, False: 53] | | ------------------ ------------------ 13308| 66.2k| { 13309| 66.2k| if (JSON_HEDLEY_UNLIKELY(!sax->end_object())) ------------------ | | 1691| 66.2k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 66.2k] | | ------------------ ------------------ 13310| 0| { 13311| 0| return false; 13312| 0| } 13313| | 13314| | // We are done with this object. Before we can parse a 13315| | // new value, we need to evaluate the new state first. 13316| | // By setting skip_to_state_evaluation to false, we 13317| | // are effectively jumping to the beginning of this if. 13318| 66.2k| JSON_ASSERT(!states.empty()); ------------------ | | 2571| 66.2k| #define JSON_ASSERT(x) assert(x) ------------------ 13319| 66.2k| states.pop_back(); 13320| 66.2k| skip_to_state_evaluation = true; 13321| 66.2k| continue; 13322| 66.2k| } 13323| | 13324| 53| return sax->parse_error(m_lexer.get_position(), 13325| 53| m_lexer.get_token_string(), 13326| 53| parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr)); 13327| 66.3k| } 13328| 11.2k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12start_objectEm: 8886| 219k| { 8887| 219k| ref_stack.push_back(handle_value(BasicJsonType::value_t::object)); 8888| | 8889| |#if JSON_DIAGNOSTIC_POSITIONS 8890| | // Manually set the start position of the object here. 8891| | // Ensure this is after the call to handle_value to ensure correct start position. 8892| | if (m_lexer_ref) 8893| | { 8894| | // Lexer has read the first character of the object, so 8895| | // subtract 1 from the position to get the correct start position. 8896| | ref_stack.back()->start_position = m_lexer_ref->get_position() - 1; 8897| | } 8898| |#endif 8899| | 8900| 219k| if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size())) ------------------ | | 1691| 219k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 219k] | | | Branch (1691:94): [True: 0, False: 219k] | | | Branch (1691:94): [True: 0, False: 0] | | ------------------ ------------------ 8901| 0| { 8902| 0| JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back())); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 8903| 0| } 8904| | 8905| 219k| return true; 8906| 219k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueINS1_7value_tEEEPSG_OT_: 9072| 843k| { 9073| 843k| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 8.28k, False: 835k] ------------------ 9074| 8.28k| { 9075| 8.28k| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 8.28k| return &root; 9082| 8.28k| } 9083| | 9084| 835k| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 835k| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 835k| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 735k, False: 100k] ------------------ 9087| 735k| { 9088| 735k| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 735k| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 735k| } 9096| | 9097| 100k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 100k| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 100k| JSON_ASSERT(object_element); ------------------ | | 2571| 100k| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 100k| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 100k| return object_element; 9106| 835k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE10end_objectEv: 8919| 141k| { 8920| 141k| JSON_ASSERT(!ref_stack.empty()); ------------------ | | 2571| 141k| #define JSON_ASSERT(x) assert(x) ------------------ 8921| 141k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 141k| #define JSON_ASSERT(x) assert(x) ------------------ 8922| | 8923| |#if JSON_DIAGNOSTIC_POSITIONS 8924| | if (m_lexer_ref) 8925| | { 8926| | // Lexer's position is past the closing brace, so set that as the end position. 8927| | ref_stack.back()->end_position = m_lexer_ref->get_position(); 8928| | } 8929| |#endif 8930| | 8931| 141k| ref_stack.back()->set_parents(); 8932| 141k| ref_stack.pop_back(); 8933| 141k| return true; 8934| 141k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE3keyERSC_: 8909| 179k| { 8910| 179k| JSON_ASSERT(!ref_stack.empty()); ------------------ | | 2571| 179k| #define JSON_ASSERT(x) assert(x) ------------------ 8911| 179k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 179k| #define JSON_ASSERT(x) assert(x) ------------------ 8912| | 8913| | // add null at given key and store the reference for later 8914| 179k| object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val)); 8915| 179k| return true; 8916| 179k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE11start_arrayEm: 8937| 624k| { 8938| 624k| ref_stack.push_back(handle_value(BasicJsonType::value_t::array)); 8939| | 8940| |#if JSON_DIAGNOSTIC_POSITIONS 8941| | // Manually set the start position of the array here. 8942| | // Ensure this is after the call to handle_value to ensure correct start position. 8943| | if (m_lexer_ref) 8944| | { 8945| | ref_stack.back()->start_position = m_lexer_ref->get_position() - 1; 8946| | } 8947| |#endif 8948| | 8949| 624k| if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size())) ------------------ | | 1691| 624k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 624k] | | | Branch (1691:94): [True: 0, False: 624k] | | | Branch (1691:94): [True: 0, False: 0] | | ------------------ ------------------ 8950| 0| { 8951| 0| JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back())); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 8952| 0| } 8953| | 8954| 624k| return true; 8955| 624k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE9end_arrayEv: 8958| 18.4k| { 8959| 18.4k| JSON_ASSERT(!ref_stack.empty()); ------------------ | | 2571| 18.4k| #define JSON_ASSERT(x) assert(x) ------------------ 8960| 18.4k| JSON_ASSERT(ref_stack.back()->is_array()); ------------------ | | 2571| 18.4k| #define JSON_ASSERT(x) assert(x) ------------------ 8961| | 8962| |#if JSON_DIAGNOSTIC_POSITIONS 8963| | if (m_lexer_ref) 8964| | { 8965| | // Lexer's position is past the closing bracket, so set that as the end position. 8966| | ref_stack.back()->end_position = m_lexer_ref->get_position(); 8967| | } 8968| |#endif 8969| | 8970| 18.4k| ref_stack.back()->set_parents(); 8971| 18.4k| ref_stack.pop_back(); 8972| 18.4k| return true; 8973| 18.4k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE11parse_errorINS1_12out_of_rangeEEEbmRKSC_RKT_: 8978| 16| { 8979| 16| errored = true; 8980| 16| static_cast(ex); 8981| 16| if (allow_exceptions) ------------------ | Branch (8981:13): [True: 16, False: 0] ------------------ 8982| 16| { 8983| 16| JSON_THROW(ex); ------------------ | | 2536| 16| #define JSON_THROW(exception) throw exception ------------------ 8984| 16| } 8985| 0| return false; 8986| 16| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12number_floatEdRKSC_: 8868| 339k| { 8869| 339k| handle_value(val); 8870| 339k| return true; 8871| 339k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueIRdEEPSG_OT_: 9072| 339k| { 9073| 339k| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 839, False: 339k] ------------------ 9074| 839| { 9075| 839| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 839| return &root; 9082| 839| } 9083| | 9084| 339k| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 339k| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 339k| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 336k, False: 2.15k] ------------------ 9087| 336k| { 9088| 336k| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 336k| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 336k| } 9096| | 9097| 2.15k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 2.15k| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 2.15k| JSON_ASSERT(object_element); ------------------ | | 2571| 2.15k| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 2.15k| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 2.15k| return object_element; 9106| 339k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE7booleanEb: 8850| 7.56k| { 8851| 7.56k| handle_value(val); 8852| 7.56k| return true; 8853| 7.56k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueIRbEEPSG_OT_: 9072| 7.56k| { 9073| 7.56k| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 5, False: 7.55k] ------------------ 9074| 5| { 9075| 5| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 5| return &root; 9082| 5| } 9083| | 9084| 7.55k| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 7.55k| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 7.55k| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 7.35k, False: 201] ------------------ 9087| 7.35k| { 9088| 7.35k| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 7.35k| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 7.35k| } 9096| | 9097| 201| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 201| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 201| JSON_ASSERT(object_element); ------------------ | | 2571| 201| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 201| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 201| return object_element; 9106| 7.55k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE4nullEv: 8844| 9.01k| { 8845| 9.01k| handle_value(nullptr); 8846| 9.01k| return true; 8847| 9.01k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueIDnEEPSG_OT_: 9072| 9.01k| { 9073| 9.01k| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 4, False: 9.00k] ------------------ 9074| 4| { 9075| 4| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 4| return &root; 9082| 4| } 9083| | 9084| 9.00k| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 9.00k| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 9.00k| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 8.78k, False: 221] ------------------ 9087| 8.78k| { 9088| 8.78k| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 8.78k| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 8.78k| } 9096| | 9097| 221| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 221| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 221| JSON_ASSERT(object_element); ------------------ | | 2571| 221| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 221| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 221| return object_element; 9106| 9.00k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE14number_integerEl: 8856| 44.1k| { 8857| 44.1k| handle_value(val); 8858| 44.1k| return true; 8859| 44.1k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueIRlEEPSG_OT_: 9072| 44.1k| { 9073| 44.1k| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 204, False: 43.9k] ------------------ 9074| 204| { 9075| 204| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 204| return &root; 9082| 204| } 9083| | 9084| 43.9k| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 43.9k| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 43.9k| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 41.9k, False: 1.97k] ------------------ 9087| 41.9k| { 9088| 41.9k| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 41.9k| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 41.9k| } 9096| | 9097| 1.97k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 1.97k| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 1.97k| JSON_ASSERT(object_element); ------------------ | | 2571| 1.97k| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 1.97k| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 1.97k| return object_element; 9106| 43.9k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE6stringERSC_: 8874| 70.3k| { 8875| 70.3k| handle_value(val); 8876| 70.3k| return true; 8877| 70.3k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueIRSC_EEPSG_OT_: 9072| 70.3k| { 9073| 70.3k| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 121, False: 70.2k] ------------------ 9074| 121| { 9075| 121| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 121| return &root; 9082| 121| } 9083| | 9084| 70.2k| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 70.2k| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 70.2k| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 28.3k, False: 41.8k] ------------------ 9087| 28.3k| { 9088| 28.3k| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 28.3k| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 28.3k| } 9096| | 9097| 41.8k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 41.8k| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 41.8k| JSON_ASSERT(object_element); ------------------ | | 2571| 41.8k| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 41.8k| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 41.8k| return object_element; 9106| 70.2k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE15number_unsignedEm: 8862| 7.05M| { 8863| 7.05M| handle_value(val); 8864| 7.05M| return true; 8865| 7.05M| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE12handle_valueIRmEEPSG_OT_: 9072| 7.05M| { 9073| 7.05M| if (ref_stack.empty()) ------------------ | Branch (9073:13): [True: 242, False: 7.05M] ------------------ 9074| 242| { 9075| 242| root = BasicJsonType(std::forward(v)); 9076| | 9077| |#if JSON_DIAGNOSTIC_POSITIONS 9078| | handle_diagnostic_positions_for_json_value(root); 9079| |#endif 9080| | 9081| 242| return &root; 9082| 242| } 9083| | 9084| 7.05M| JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object()); ------------------ | | 2571| 7.05M| #define JSON_ASSERT(x) assert(x) ------------------ 9085| | 9086| 7.05M| if (ref_stack.back()->is_array()) ------------------ | Branch (9086:13): [True: 7.02M, False: 32.5k] ------------------ 9087| 7.02M| { 9088| 7.02M| ref_stack.back()->m_data.m_value.array->emplace_back(std::forward(v)); 9089| | 9090| |#if JSON_DIAGNOSTIC_POSITIONS 9091| | handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back()); 9092| |#endif 9093| | 9094| 7.02M| return &(ref_stack.back()->m_data.m_value.array->back()); 9095| 7.02M| } 9096| | 9097| 32.5k| JSON_ASSERT(ref_stack.back()->is_object()); ------------------ | | 2571| 32.5k| #define JSON_ASSERT(x) assert(x) ------------------ 9098| 32.5k| JSON_ASSERT(object_element); ------------------ | | 2571| 32.5k| #define JSON_ASSERT(x) assert(x) ------------------ 9099| 32.5k| *object_element = BasicJsonType(std::forward(v)); 9100| | 9101| |#if JSON_DIAGNOSTIC_POSITIONS 9102| | handle_diagnostic_positions_for_json_value(*object_element); 9103| |#endif 9104| | 9105| 32.5k| return object_element; 9106| 7.05M| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE11parse_errorINS1_11parse_errorEEEbmRKSC_RKT_: 8978| 2.70k| { 8979| 2.70k| errored = true; 8980| 2.70k| static_cast(ex); 8981| 2.70k| if (allow_exceptions) ------------------ | Branch (8981:13): [True: 2.70k, False: 0] ------------------ 8982| 2.70k| { 8983| 2.70k| JSON_THROW(ex); ------------------ | | 2536| 2.70k| #define JSON_THROW(exception) throw exception ------------------ 8984| 2.70k| } 8985| 0| return false; 8986| 2.70k| } _ZNK8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEE10is_erroredEv: 8989| 8.54k| { 8990| 8.54k| return errored; 8991| 8.54k| } _ZN8nlohmann16json_abi_v3_12_06detail19json_sax_dom_parserINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS1_22iterator_input_adapterIPKhEEED2Ev: 8841| 11.2k| ~json_sax_dom_parser() = default; _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2INS1_INS3_3mapES4_SA_blmdS8_SB_SD_vEETnNS3_9enable_ifIXaasr6detail13is_basic_jsonIT_EE5valuentsr3std7is_sameISE_SJ_EE5valueEiE4typeELi0EEERKSJ_: 20871| 4.64M| { 20872| 4.64M| using other_boolean_t = typename BasicJsonType::boolean_t; 20873| 4.64M| using other_number_float_t = typename BasicJsonType::number_float_t; 20874| 4.64M| using other_number_integer_t = typename BasicJsonType::number_integer_t; 20875| 4.64M| using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t; 20876| 4.64M| using other_string_t = typename BasicJsonType::string_t; 20877| 4.64M| using other_object_t = typename BasicJsonType::object_t; 20878| 4.64M| using other_array_t = typename BasicJsonType::array_t; 20879| 4.64M| using other_binary_t = typename BasicJsonType::binary_t; 20880| | 20881| 4.64M| switch (val.type()) 20882| 4.64M| { 20883| 2.21k| case value_t::boolean: ------------------ | Branch (20883:13): [True: 2.21k, False: 4.64M] ------------------ 20884| 2.21k| JSONSerializer::to_json(*this, val.template get()); 20885| 2.21k| break; 20886| 208k| case value_t::number_float: ------------------ | Branch (20886:13): [True: 208k, False: 4.43M] ------------------ 20887| 208k| JSONSerializer::to_json(*this, val.template get()); 20888| 208k| break; 20889| 37.4k| case value_t::number_integer: ------------------ | Branch (20889:13): [True: 37.4k, False: 4.60M] ------------------ 20890| 37.4k| JSONSerializer::to_json(*this, val.template get()); 20891| 37.4k| break; 20892| 4.23M| case value_t::number_unsigned: ------------------ | Branch (20892:13): [True: 4.23M, False: 405k] ------------------ 20893| 4.23M| JSONSerializer::to_json(*this, val.template get()); 20894| 4.23M| break; 20895| 64.7k| case value_t::string: ------------------ | Branch (20895:13): [True: 64.7k, False: 4.57M] ------------------ 20896| 64.7k| JSONSerializer::to_json(*this, val.template get_ref()); 20897| 64.7k| break; 20898| 68.6k| case value_t::object: ------------------ | Branch (20898:13): [True: 68.6k, False: 4.57M] ------------------ 20899| 68.6k| JSONSerializer::to_json(*this, val.template get_ref()); 20900| 68.6k| break; 20901| 17.1k| case value_t::array: ------------------ | Branch (20901:13): [True: 17.1k, False: 4.62M] ------------------ 20902| 17.1k| JSONSerializer::to_json(*this, val.template get_ref()); 20903| 17.1k| break; 20904| 0| case value_t::binary: ------------------ | Branch (20904:13): [True: 0, False: 4.64M] ------------------ 20905| 0| JSONSerializer::to_json(*this, val.template get_ref()); 20906| 0| break; 20907| 6.49k| case value_t::null: ------------------ | Branch (20907:13): [True: 6.49k, False: 4.63M] ------------------ 20908| 6.49k| *this = nullptr; 20909| 6.49k| break; 20910| 0| case value_t::discarded: ------------------ | Branch (20910:13): [True: 0, False: 4.64M] ------------------ 20911| 0| m_data.m_type = value_t::discarded; 20912| 0| break; 20913| 0| default: // LCOV_EXCL_LINE ------------------ | Branch (20913:13): [True: 0, False: 4.64M] ------------------ 20914| 0| JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 20915| 4.64M| } 20916| 4.64M| JSON_ASSERT(m_data.m_type == val.type()); ------------------ | | 2571| 4.64M| #define JSON_ASSERT(x) assert(x) ------------------ 20917| | 20918| 4.64M| set_parents(); 20919| 4.64M| assert_invariant(); 20920| 4.64M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dataC2Ev: 24250| 78.9M| data() noexcept = default; _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4typeEv: 21336| 4.64M| { 21337| 4.64M| return m_data.m_type; 21338| 4.64M| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIbvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEbEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_: 6163| 2.21k| { 6164| 2.21k| ::nlohmann::to_json(j, std::forward(val)); 6165| 2.21k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEbEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6107| 2.21k| { 6108| 2.21k| return to_json(j, std::forward(val)); 6109| 2.21k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEbTnNS5_9enable_ifIXsr3std7is_sameIT0_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRSJ_SI_: 5933| 2.87k|{ 5934| 2.87k| external_constructor::construct(j, b); 5935| 2.87k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_9boolean_tE: 5700| 2.87k| { 5701| 2.87k| j.m_data.m_value.destroy(j.m_data.m_type); 5702| 2.87k| j.m_data.m_type = value_t::boolean; 5703| 2.87k| j.m_data.m_value = b; 5704| 2.87k| j.assert_invariant(); 5705| 2.87k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_value7destroyENS0_6detail7value_tE: 20572| 287M| { 20573| 287M| if ( 20574| 287M| (t == value_t::object && object == nullptr) || ------------------ | Branch (20574:18): [True: 2.94M, False: 284M] | Branch (20574:42): [True: 0, False: 2.94M] ------------------ 20575| 287M| (t == value_t::array && array == nullptr) || ------------------ | Branch (20575:18): [True: 3.61M, False: 284M] | Branch (20575:41): [True: 0, False: 3.61M] ------------------ 20576| 287M| (t == value_t::string && string == nullptr) || ------------------ | Branch (20576:18): [True: 16.2M, False: 271M] | Branch (20576:42): [True: 0, False: 16.2M] ------------------ 20577| 287M| (t == value_t::binary && binary == nullptr) ------------------ | Branch (20577:18): [True: 0, False: 287M] | Branch (20577:42): [True: 0, False: 0] ------------------ 20578| 287M| ) 20579| 0| { 20580| | //not initialized (e.g. due to exception in the ctor) 20581| 0| return; 20582| 0| } 20583| 287M| if (t == value_t::array || t == value_t::object) ------------------ | Branch (20583:17): [True: 3.61M, False: 284M] | Branch (20583:40): [True: 2.94M, False: 281M] ------------------ 20584| 6.55M| { 20585| | // flatten the current json_value to a heap-allocated stack 20586| 6.55M| std::vector stack; 20587| | 20588| | // move the top-level items to stack 20589| 6.55M| if (t == value_t::array) ------------------ | Branch (20589:21): [True: 3.61M, False: 2.94M] ------------------ 20590| 3.61M| { 20591| 3.61M| stack.reserve(array->size()); 20592| 3.61M| std::move(array->begin(), array->end(), std::back_inserter(stack)); 20593| 3.61M| } 20594| 2.94M| else 20595| 2.94M| { 20596| 2.94M| stack.reserve(object->size()); 20597| 2.94M| for (auto&& it : *object) ------------------ | Branch (20597:36): [True: 459k, False: 2.94M] ------------------ 20598| 459k| { 20599| 459k| stack.push_back(std::move(it.second)); 20600| 459k| } 20601| 2.94M| } 20602| | 20603| 82.6M| while (!stack.empty()) ------------------ | Branch (20603:24): [True: 76.1M, False: 6.55M] ------------------ 20604| 76.1M| { 20605| | // move the last item to local variable to be processed 20606| 76.1M| basic_json current_item(std::move(stack.back())); 20607| 76.1M| stack.pop_back(); 20608| | 20609| | // if current_item is array/object, move 20610| | // its children to the stack to be processed later 20611| 76.1M| if (current_item.is_array()) ------------------ | Branch (20611:25): [True: 3.51M, False: 72.6M] ------------------ 20612| 3.51M| { 20613| 3.51M| std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack)); 20614| | 20615| 3.51M| current_item.m_data.m_value.array->clear(); 20616| 3.51M| } 20617| 72.6M| else if (current_item.is_object()) ------------------ | Branch (20617:30): [True: 2.74M, False: 69.8M] ------------------ 20618| 2.74M| { 20619| 2.74M| for (auto&& it : *current_item.m_data.m_value.object) ------------------ | Branch (20619:40): [True: 2.61M, False: 2.74M] ------------------ 20620| 2.61M| { 20621| 2.61M| stack.push_back(std::move(it.second)); 20622| 2.61M| } 20623| | 20624| 2.74M| current_item.m_data.m_value.object->clear(); 20625| 2.74M| } 20626| | 20627| | // it's now safe that current_item get destructed 20628| | // since it doesn't have any children 20629| 76.1M| } 20630| 6.55M| } 20631| | 20632| 287M| switch (t) 20633| 287M| { 20634| 2.94M| case value_t::object: ------------------ | Branch (20634:17): [True: 2.94M, False: 284M] ------------------ 20635| 2.94M| { 20636| 2.94M| AllocatorType alloc; 20637| 2.94M| std::allocator_traits::destroy(alloc, object); 20638| 2.94M| std::allocator_traits::deallocate(alloc, object, 1); 20639| 2.94M| break; 20640| 0| } 20641| | 20642| 3.61M| case value_t::array: ------------------ | Branch (20642:17): [True: 3.61M, False: 284M] ------------------ 20643| 3.61M| { 20644| 3.61M| AllocatorType alloc; 20645| 3.61M| std::allocator_traits::destroy(alloc, array); 20646| 3.61M| std::allocator_traits::deallocate(alloc, array, 1); 20647| 3.61M| break; 20648| 0| } 20649| | 20650| 16.2M| case value_t::string: ------------------ | Branch (20650:17): [True: 16.2M, False: 271M] ------------------ 20651| 16.2M| { 20652| 16.2M| AllocatorType alloc; 20653| 16.2M| std::allocator_traits::destroy(alloc, string); 20654| 16.2M| std::allocator_traits::deallocate(alloc, string, 1); 20655| 16.2M| break; 20656| 0| } 20657| | 20658| 0| case value_t::binary: ------------------ | Branch (20658:17): [True: 0, False: 287M] ------------------ 20659| 0| { 20660| 0| AllocatorType alloc; 20661| 0| std::allocator_traits::destroy(alloc, binary); 20662| 0| std::allocator_traits::deallocate(alloc, binary, 1); 20663| 0| break; 20664| 0| } 20665| | 20666| 210M| case value_t::null: ------------------ | Branch (20666:17): [True: 210M, False: 77.2M] ------------------ 20667| 210M| case value_t::boolean: ------------------ | Branch (20667:17): [True: 8.96k, False: 287M] ------------------ 20668| 211M| case value_t::number_integer: ------------------ | Branch (20668:17): [True: 1.41M, False: 286M] ------------------ 20669| 263M| case value_t::number_unsigned: ------------------ | Branch (20669:17): [True: 51.4M, False: 236M] ------------------ 20670| 264M| case value_t::number_float: ------------------ | Branch (20670:17): [True: 1.53M, False: 286M] ------------------ 20671| 264M| case value_t::discarded: ------------------ | Branch (20671:17): [True: 0, False: 287M] ------------------ 20672| 264M| default: ------------------ | Branch (20672:17): [True: 0, False: 287M] ------------------ 20673| 264M| { 20674| 264M| break; 20675| 264M| } 20676| 287M| } 20677| 287M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2EOSE_: 21241| 201M| : json_base_class_t(std::forward(other)), 21242| 201M| m_data(std::move(other.m_data)) // cppcheck-suppress[accessForwarded] TODO check 21243| |#if JSON_DIAGNOSTIC_POSITIONS 21244| | , start_position(other.start_position) // cppcheck-suppress[accessForwarded] TODO check 21245| | , end_position(other.end_position) // cppcheck-suppress[accessForwarded] TODO check 21246| |#endif 21247| 201M| { 21248| | // check that passed value is valid 21249| 201M| other.assert_invariant(false); // cppcheck-suppress[accessForwarded] 21250| | 21251| | // invalidate payload 21252| 201M| other.m_data.m_type = value_t::null; 21253| 201M| other.m_data.m_value = {}; 21254| | 21255| |#if JSON_DIAGNOSTIC_POSITIONS 21256| | other.start_position = std::string::npos; 21257| | other.end_position = std::string::npos; 21258| |#endif 21259| | 21260| 201M| set_parents(); 21261| 201M| assert_invariant(); 21262| 201M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8is_arrayEv: 21406| 81.5M| { 21407| 81.5M| return m_data.m_type == value_t::array; 21408| 81.5M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE9is_objectEv: 21399| 85.1M| { 21400| 85.1M| return m_data.m_type == value_t::object; 21401| 85.1M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2Eb: 20462| 8.96k| json_value(boolean_t v) noexcept : boolean(v) {} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getIbbEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 2.21k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 2.21k| static_assert(!std::is_reference::value, 21793| 2.21k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 2.21k| return get_impl(detail::priority_tag<4> {}); 21795| 2.21k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implIbTnNS2_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 2.21k| { 21650| 2.21k| auto ret = ValueType(); 21651| 2.21k| JSONSerializer::from_json(*this, ret); 21652| 2.21k| return ret; 21653| 2.21k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIbvE9from_jsonIRKNS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEbEEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 2.21k| { 6144| 2.21k| ::nlohmann::from_json(std::forward(j), val); 6145| 2.21k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERbEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 2.21k| { 5343| 2.21k| return from_json(j, std::forward(val)); 5344| 2.21k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_9boolean_tE: 4891| 2.21k|{ 4892| 2.21k| if (JSON_HEDLEY_UNLIKELY(!j.is_boolean())) ------------------ | | 1691| 2.21k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 2.21k] | | ------------------ ------------------ 4893| 0| { 4894| 0| JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 4895| 0| } 4896| 2.21k| b = *j.template get_ptr(); 4897| 2.21k|} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10is_booleanEv: 21364| 4.43k| { 21365| 4.43k| return m_data.m_type == value_t::boolean; 21366| 4.43k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKbTnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 2.21k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 2.21k| return get_impl_ptr(static_cast(nullptr)); 21601| 2.21k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKb: 21500| 2.21k| { 21501| 2.21k| return is_boolean() ? &m_data.m_value.boolean : nullptr; ------------------ | Branch (21501:16): [True: 2.21k, False: 0] ------------------ 21502| 2.21k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIdvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEdEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_: 6163| 208k| { 6164| 208k| ::nlohmann::to_json(j, std::forward(val)); 6165| 208k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEdEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6107| 208k| { 6108| 208k| return to_json(j, std::forward(val)); 6109| 208k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEdTnNS5_9enable_ifIXsr3std17is_floating_pointIT0_EE5valueEiE4typeELi0EEEvRT_SI_: 5966| 208k|{ 5967| 208k| external_constructor::construct(j, static_cast(val)); 5968| 208k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_14number_float_tE: 5768| 208k| { 5769| 208k| j.m_data.m_value.destroy(j.m_data.m_type); 5770| 208k| j.m_data.m_type = value_t::number_float; 5771| 208k| j.m_data.m_value = val; 5772| 208k| j.assert_invariant(); 5773| 208k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2Ed: 20468| 1.53M| json_value(number_float_t v) noexcept : number_float(v) {} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getIddEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 208k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 208k| static_assert(!std::is_reference::value, 21793| 208k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 208k| return get_impl(detail::priority_tag<4> {}); 21795| 208k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implIdTnNS2_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 208k| { 21650| 208k| auto ret = ValueType(); 21651| 208k| JSONSerializer::from_json(*this, ret); 21652| 208k| return ret; 21653| 208k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIdvE9from_jsonIRKNS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEdEEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 208k| { 6144| 208k| ::nlohmann::from_json(std::forward(j), val); 6145| 208k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERdEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 208k| { 5343| 208k| return from_json(j, std::forward(val)); 5344| 208k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_14number_float_tE: 4928| 208k|{ 4929| 208k| get_arithmetic_value(j, val); 4930| 208k|} _ZN8nlohmann16json_abi_v3_12_06detail20get_arithmetic_valueINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEdTnNS4_9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISI_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSJ_RSI_: 4858| 208k|{ 4859| 208k| switch (static_cast(j)) 4860| 208k| { 4861| 0| case value_t::number_unsigned: ------------------ | Branch (4861:9): [True: 0, False: 208k] ------------------ 4862| 0| { 4863| 0| val = static_cast(*j.template get_ptr()); 4864| 0| break; 4865| 0| } 4866| 0| case value_t::number_integer: ------------------ | Branch (4866:9): [True: 0, False: 208k] ------------------ 4867| 0| { 4868| 0| val = static_cast(*j.template get_ptr()); 4869| 0| break; 4870| 0| } 4871| 208k| case value_t::number_float: ------------------ | Branch (4871:9): [True: 208k, False: 0] ------------------ 4872| 208k| { 4873| 208k| val = static_cast(*j.template get_ptr()); 4874| 208k| break; 4875| 0| } 4876| | 4877| 0| case value_t::null: ------------------ | Branch (4877:9): [True: 0, False: 208k] ------------------ 4878| 0| case value_t::object: ------------------ | Branch (4878:9): [True: 0, False: 208k] ------------------ 4879| 0| case value_t::array: ------------------ | Branch (4879:9): [True: 0, False: 208k] ------------------ 4880| 0| case value_t::string: ------------------ | Branch (4880:9): [True: 0, False: 208k] ------------------ 4881| 0| case value_t::boolean: ------------------ | Branch (4881:9): [True: 0, False: 208k] ------------------ 4882| 0| case value_t::binary: ------------------ | Branch (4882:9): [True: 0, False: 208k] ------------------ 4883| 0| case value_t::discarded: ------------------ | Branch (4883:9): [True: 0, False: 208k] ------------------ 4884| 0| default: ------------------ | Branch (4884:9): [True: 0, False: 208k] ------------------ 4885| 0| JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 4886| 208k| } 4887| 208k|} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEcvNS0_6detail7value_tEEv: 21434| 4.48M| { 21435| 4.48M| return m_data.m_type; 21436| 4.48M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKmTnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 4.23M| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 4.23M| return get_impl_ptr(static_cast(nullptr)); 21601| 4.23M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKm: 21524| 4.23M| { 21525| 4.23M| return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr; ------------------ | Branch (21525:16): [True: 4.23M, False: 0] ------------------ 21526| 4.23M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE18is_number_unsignedEv: 21385| 4.23M| { 21386| 4.23M| return m_data.m_type == value_t::number_unsigned; 21387| 4.23M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKlTnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 37.4k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 37.4k| return get_impl_ptr(static_cast(nullptr)); 21601| 37.4k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKl: 21512| 37.4k| { 21513| 37.4k| return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr; ------------------ | Branch (21513:16): [True: 37.4k, False: 0] ------------------ 21514| 37.4k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKdTnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 208k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 208k| return get_impl_ptr(static_cast(nullptr)); 21601| 208k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKd: 21536| 208k| { 21537| 208k| return is_number_float() ? &m_data.m_value.number_float : nullptr; ------------------ | Branch (21537:16): [True: 208k, False: 0] ------------------ 21538| 208k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE15is_number_floatEv: 21392| 208k| { 21393| 208k| return m_data.m_type == value_t::number_float; 21394| 208k| } _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA29_KcPSA_EEET_DpOT0_: 4477| 34|{ 4478| 34| OutStringType str; 4479| 34| str.reserve(concat_length(args...)); 4480| 34| concat_into(str, std::forward(args)...); 4481| 34| return str; 4482| 34|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA29_KcJPSA_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_: 4440| 34|{ 4441| 34| out.append(std::forward(arg)); 4442| 34| concat_into(out, std::forward(rest)...); 4443| 34|} _ZN8nlohmann16json_abi_v3_12_014adl_serializerIlvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEElEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_: 6163| 37.4k| { 6164| 37.4k| ::nlohmann::to_json(j, std::forward(val)); 6165| 37.4k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEElEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6107| 37.4k| { 6108| 37.4k| return to_json(j, std::forward(val)); 6109| 37.4k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEElTnNS5_9enable_ifIXsr26is_compatible_integer_typeINT_16number_integer_tET0_EE5valueEiE4typeELi0EEEvRSI_SK_: 5980| 37.4k|{ 5981| 37.4k| external_constructor::construct(j, static_cast(val)); 5982| 37.4k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_16number_integer_tE: 5794| 37.4k| { 5795| 37.4k| j.m_data.m_value.destroy(j.m_data.m_type); 5796| 37.4k| j.m_data.m_type = value_t::number_integer; 5797| 37.4k| j.m_data.m_value = val; 5798| 37.4k| j.assert_invariant(); 5799| 37.4k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2El: 20464| 1.41M| json_value(number_integer_t v) noexcept : number_integer(v) {} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getIllEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 37.4k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 37.4k| static_assert(!std::is_reference::value, 21793| 37.4k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 37.4k| return get_impl(detail::priority_tag<4> {}); 21795| 37.4k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implIlTnNS2_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 37.4k| { 21650| 37.4k| auto ret = ValueType(); 21651| 37.4k| JSONSerializer::from_json(*this, ret); 21652| 37.4k| return ret; 21653| 37.4k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIlvE9from_jsonIRKNS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEElEEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 37.4k| { 6144| 37.4k| ::nlohmann::from_json(std::forward(j), val); 6145| 37.4k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERlEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 37.4k| { 5343| 37.4k| return from_json(j, std::forward(val)); 5344| 37.4k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_16number_integer_tE: 4940| 37.4k|{ 4941| 37.4k| get_arithmetic_value(j, val); 4942| 37.4k|} _ZN8nlohmann16json_abi_v3_12_06detail20get_arithmetic_valueINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEElTnNS4_9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISI_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSJ_RSI_: 4858| 37.4k|{ 4859| 37.4k| switch (static_cast(j)) 4860| 37.4k| { 4861| 0| case value_t::number_unsigned: ------------------ | Branch (4861:9): [True: 0, False: 37.4k] ------------------ 4862| 0| { 4863| 0| val = static_cast(*j.template get_ptr()); 4864| 0| break; 4865| 0| } 4866| 37.4k| case value_t::number_integer: ------------------ | Branch (4866:9): [True: 37.4k, False: 0] ------------------ 4867| 37.4k| { 4868| 37.4k| val = static_cast(*j.template get_ptr()); 4869| 37.4k| break; 4870| 0| } 4871| 0| case value_t::number_float: ------------------ | Branch (4871:9): [True: 0, False: 37.4k] ------------------ 4872| 0| { 4873| 0| val = static_cast(*j.template get_ptr()); 4874| 0| break; 4875| 0| } 4876| | 4877| 0| case value_t::null: ------------------ | Branch (4877:9): [True: 0, False: 37.4k] ------------------ 4878| 0| case value_t::object: ------------------ | Branch (4878:9): [True: 0, False: 37.4k] ------------------ 4879| 0| case value_t::array: ------------------ | Branch (4879:9): [True: 0, False: 37.4k] ------------------ 4880| 0| case value_t::string: ------------------ | Branch (4880:9): [True: 0, False: 37.4k] ------------------ 4881| 0| case value_t::boolean: ------------------ | Branch (4881:9): [True: 0, False: 37.4k] ------------------ 4882| 0| case value_t::binary: ------------------ | Branch (4882:9): [True: 0, False: 37.4k] ------------------ 4883| 0| case value_t::discarded: ------------------ | Branch (4883:9): [True: 0, False: 37.4k] ------------------ 4884| 0| default: ------------------ | Branch (4884:9): [True: 0, False: 37.4k] ------------------ 4885| 0| JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 4886| 37.4k| } 4887| 37.4k|} _ZN8nlohmann16json_abi_v3_12_014adl_serializerImvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEmEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_: 6163| 4.23M| { 6164| 4.23M| ::nlohmann::to_json(j, std::forward(val)); 6165| 4.23M| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEmEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6107| 4.23M| { 6108| 4.23M| return to_json(j, std::forward(val)); 6109| 4.23M| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEmTnNS5_9enable_ifIXsr26is_compatible_integer_typeINT_17number_unsigned_tET0_EE5valueEiE4typeELi0EEEvRSI_SK_: 5973| 4.23M|{ 5974| 4.23M| external_constructor::construct(j, static_cast(val)); 5975| 4.23M|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_NSK_17number_unsigned_tE: 5781| 4.23M| { 5782| 4.23M| j.m_data.m_value.destroy(j.m_data.m_type); 5783| 4.23M| j.m_data.m_type = value_t::number_unsigned; 5784| 4.23M| j.m_data.m_value = val; 5785| 4.23M| j.assert_invariant(); 5786| 4.23M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2Em: 20466| 51.4M| json_value(number_unsigned_t v) noexcept : number_unsigned(v) {} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getImmEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 4.23M| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 4.23M| static_assert(!std::is_reference::value, 21793| 4.23M| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 4.23M| return get_impl(detail::priority_tag<4> {}); 21795| 4.23M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implImTnNS2_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 4.23M| { 21650| 4.23M| auto ret = ValueType(); 21651| 4.23M| JSONSerializer::from_json(*this, ret); 21652| 4.23M| return ret; 21653| 4.23M| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerImvE9from_jsonIRKNS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEmEEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 4.23M| { 6144| 4.23M| ::nlohmann::from_json(std::forward(j), val); 6145| 4.23M| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINSt3__13mapENS5_6vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERmEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 4.23M| { 5343| 4.23M| return from_json(j, std::forward(val)); 5344| 4.23M| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_17number_unsigned_tE: 4934| 4.23M|{ 4935| 4.23M| get_arithmetic_value(j, val); 4936| 4.23M|} _ZN8nlohmann16json_abi_v3_12_06detail20get_arithmetic_valueINS0_10basic_jsonINSt3__13mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEmTnNS4_9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISI_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSJ_RSI_: 4858| 4.23M|{ 4859| 4.23M| switch (static_cast(j)) 4860| 4.23M| { 4861| 4.23M| case value_t::number_unsigned: ------------------ | Branch (4861:9): [True: 4.23M, False: 0] ------------------ 4862| 4.23M| { 4863| 4.23M| val = static_cast(*j.template get_ptr()); 4864| 4.23M| break; 4865| 0| } 4866| 0| case value_t::number_integer: ------------------ | Branch (4866:9): [True: 0, False: 4.23M] ------------------ 4867| 0| { 4868| 0| val = static_cast(*j.template get_ptr()); 4869| 0| break; 4870| 0| } 4871| 0| case value_t::number_float: ------------------ | Branch (4871:9): [True: 0, False: 4.23M] ------------------ 4872| 0| { 4873| 0| val = static_cast(*j.template get_ptr()); 4874| 0| break; 4875| 0| } 4876| | 4877| 0| case value_t::null: ------------------ | Branch (4877:9): [True: 0, False: 4.23M] ------------------ 4878| 0| case value_t::object: ------------------ | Branch (4878:9): [True: 0, False: 4.23M] ------------------ 4879| 0| case value_t::array: ------------------ | Branch (4879:9): [True: 0, False: 4.23M] ------------------ 4880| 0| case value_t::string: ------------------ | Branch (4880:9): [True: 0, False: 4.23M] ------------------ 4881| 0| case value_t::boolean: ------------------ | Branch (4881:9): [True: 0, False: 4.23M] ------------------ 4882| 0| case value_t::binary: ------------------ | Branch (4882:9): [True: 0, False: 4.23M] ------------------ 4883| 0| case value_t::discarded: ------------------ | Branch (4883:9): [True: 0, False: 4.23M] ------------------ 4884| 0| default: ------------------ | Branch (4884:9): [True: 0, False: 4.23M] ------------------ 4885| 0| JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 4886| 4.23M| } 4887| 4.23M|} _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENS2_6vectorES8_blmdS6_S1_NSD_IhNS6_IhEEEEvEERKS8_EEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6163| 281k| { 6164| 281k| ::nlohmann::to_json(j, std::forward(val)); 6165| 281k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERKSD_EEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSK_: 6107| 281k| { 6108| 281k| return to_json(j, std::forward(val)); 6109| 281k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEESC_TnNS5_9enable_ifIXsr3std16is_constructibleINT_8string_tET0_EE5valueEiE4typeELi0EEEvRSI_RKSK_: 5953| 281k|{ 5954| 281k| external_constructor::construct(j, s); 5955| 281k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE3EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_RKNSK_8string_tE: 5713| 281k| { 5714| 281k| j.m_data.m_value.destroy(j.m_data.m_type); 5715| 281k| j.m_data.m_type = value_t::string; 5716| 281k| j.m_data.m_value = s; 5717| 281k| j.assert_invariant(); 5718| 281k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2ERKSA_: 20542| 14.3M| json_value(const string_t& value) : string(create(value)) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createISA_JRKSA_EEEPT_DpOT0_: 20396| 14.3M| { 20397| 14.3M| AllocatorType alloc; 20398| 14.3M| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 14.3M| auto deleter = [&](T * obj) 20401| 14.3M| { 20402| 14.3M| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 14.3M| }; 20404| 14.3M| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 14.3M| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 14.3M| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 14.3M| return obj.release(); 20408| 14.3M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_refIRKSA_TnNS2_9enable_ifIXaasr3std12is_referenceIT_EE5valuesr3std8is_constINS2_16remove_referenceISJ_E4typeEEE5valueEiE4typeELi0EEESJ_v: 21887| 64.7k| { 21888| | // delegate call to get_ref_impl 21889| 64.7k| return get_ref_impl(*this); 21890| 64.7k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_ref_implIRKSA_KSE_EET_RT0_: 21565| 64.7k| { 21566| | // delegate the call to get_ptr<>() 21567| 64.7k| auto* ptr = obj.template get_ptr::type>(); 21568| | 21569| 64.7k| if (JSON_HEDLEY_LIKELY(ptr != nullptr)) ------------------ | | 1690| 64.7k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 64.7k, False: 0] | | ------------------ ------------------ 21570| 64.7k| { 21571| 64.7k| return *ptr; 21572| 64.7k| } 21573| | 21574| 0| JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 21575| 64.7k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKSA_TnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 64.7k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 64.7k| return get_impl_ptr(static_cast(nullptr)); 21601| 64.7k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKSA_: 21488| 64.7k| { 21489| 64.7k| return is_string() ? m_data.m_value.string : nullptr; ------------------ | Branch (21489:16): [True: 64.7k, False: 0] ------------------ 21490| 64.7k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS3_NS2_6vectorES9_blmdS7_S1_NSB_IhNS7_IhEEEEvEENS2_4lessIvEENS7_INS2_4pairIKS9_SE_EEEEEEvE7to_jsonINSA_INS0_11ordered_mapESB_S9_blmdS7_S1_SD_vEERKSL_EEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSS_: 6163| 68.6k| { 6164| 68.6k| ::nlohmann::to_json(j, std::forward(val)); 6165| 68.6k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERKNS6_3mapISD_NS4_ISI_S7_SD_blmdSB_SE_SG_vEENS6_4lessIvEENSB_INS6_4pairIKSD_SJ_EEEEEEEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OST_: 6107| 68.6k| { 6108| 68.6k| return to_json(j, std::forward(val)); 6109| 68.6k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS5_3mapISC_NS3_ISH_S6_SC_blmdSA_SD_SF_vEENS5_4lessIvEENSA_INS5_4pairIKSC_SI_EEEEEETnNS5_9enable_ifIXaasr25is_compatible_object_typeIT_T0_EE5valuentsr13is_basic_jsonISS_EE5valueEiE4typeELi0EEEvRSR_RKSS_: 6036| 68.6k|{ 6037| 68.6k| external_constructor::construct(j, obj); 6038| 68.6k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE1EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEENS8_3mapISF_NS6_ISK_S9_SF_blmdSD_SG_SI_vEENS8_4lessIvEENSD_INS8_4pairIKSF_SL_EEEEEETnNS8_9enable_ifIXntsr3std7is_sameIT0_NT_8object_tEEE5valueEiE4typeELi0EEEvRSV_RKSU_: 5898| 68.6k| { 5899| 68.6k| using std::begin; 5900| 68.6k| using std::end; 5901| | 5902| 68.6k| j.m_data.m_value.destroy(j.m_data.m_type); 5903| 68.6k| j.m_data.m_type = value_t::object; 5904| 68.6k| j.m_data.m_value.object = j.template create(begin(obj), end(obj)); 5905| 68.6k| j.set_parents(); 5906| 68.6k| j.assert_invariant(); 5907| 68.6k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createINS2_ISA_SE_NS3_4lessIvEENS8_INS3_4pairIKSA_SE_EEEEEEJNS3_20__map_const_iteratorINS3_21__tree_const_iteratorINS3_12__value_typeISA_NS1_INS3_3mapES4_SA_blmdS8_SB_SD_vEEEEPNS3_11__tree_nodeISS_PvEElEEEESY_EEEPT_DpOT0_: 20396| 68.6k| { 20397| 68.6k| AllocatorType alloc; 20398| 68.6k| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 68.6k| auto deleter = [&](T * obj) 20401| 68.6k| { 20402| 68.6k| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 68.6k| }; 20404| 68.6k| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 68.6k| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 68.6k| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 68.6k| return obj.release(); 20408| 68.6k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEEC2INS2_20__map_const_iteratorINS2_21__tree_const_iteratorINS2_12__value_typeIS8_NS9_INS2_3mapESA_S8_blmdS6_SB_SD_vEEEEPNS2_11__tree_nodeISS_PvEElEEEEEET_SZ_RKSK_: 19767| 68.6k| : Container{first, last, alloc} {} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_refIRKNS3_ISA_SE_NS2_4lessIvEENS8_INS2_4pairIKSA_SE_EEEEEETnNS2_9enable_ifIXaasr3std12is_referenceIT_EE5valuesr3std8is_constINS2_16remove_referenceISQ_E4typeEEE5valueEiE4typeELi0EEESQ_v: 21887| 68.6k| { 21888| | // delegate call to get_ref_impl 21889| 68.6k| return get_ref_impl(*this); 21890| 68.6k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_ref_implIRKNS3_ISA_SE_NS2_4lessIvEENS8_INS2_4pairIKSA_SE_EEEEEEKSE_EET_RT0_: 21565| 68.6k| { 21566| | // delegate the call to get_ptr<>() 21567| 68.6k| auto* ptr = obj.template get_ptr::type>(); 21568| | 21569| 68.6k| if (JSON_HEDLEY_LIKELY(ptr != nullptr)) ------------------ | | 1690| 68.6k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 68.6k, False: 0] | | ------------------ ------------------ 21570| 68.6k| { 21571| 68.6k| return *ptr; 21572| 68.6k| } 21573| | 21574| 0| JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 21575| 68.6k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKNS3_ISA_SE_NS2_4lessIvEENS8_INS2_4pairIKSA_SE_EEEEEETnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISQ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISQ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISQ_EEEEv: 21598| 68.6k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 68.6k| return get_impl_ptr(static_cast(nullptr)); 21601| 68.6k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKNS3_ISA_SE_NS2_4lessIvEENS8_INS2_4pairIKSA_SE_EEEEEE: 21464| 68.6k| { 21465| 68.6k| return is_object() ? m_data.m_value.object : nullptr; ------------------ | Branch (21465:16): [True: 68.6k, False: 0] ------------------ 21466| 68.6k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__16vectorINS0_10basic_jsonINS2_3mapES3_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS9_S1_NS3_IhNS9_IhEEEEvEENS9_ISE_EEEEvE7to_jsonINS4_INS0_11ordered_mapES3_SB_blmdS9_S1_SD_vEERKSG_EEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSN_: 6163| 17.1k| { 6164| 17.1k| ::nlohmann::to_json(j, std::forward(val)); 6165| 17.1k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERKNS7_INS4_INS6_3mapES7_SD_blmdSB_SE_SG_vEENSB_ISJ_EEEEEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSO_: 6107| 17.1k| { 6108| 17.1k| return to_json(j, std::forward(val)); 6109| 17.1k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS6_INS3_INS5_3mapES6_SC_blmdSA_SD_SF_vEENSA_ISI_EEEETnNS5_9enable_ifIXaaaaaaaasr24is_compatible_array_typeIT_T0_EE5valuentsr25is_compatible_object_typeISM_SN_EE5valuentsr25is_compatible_string_typeISM_SN_EE5valuentsr3std7is_sameINSM_8binary_tESN_EE5valuentsr13is_basic_jsonISN_EE5valueEiE4typeELi0EEEvRSM_RKSN_: 6010| 17.1k|{ 6011| 17.1k| external_constructor::construct(j, arr); 6012| 17.1k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEENS9_INS6_INS8_3mapES9_SF_blmdSD_SG_SI_vEENSD_ISL_EEEETnNS8_9enable_ifIXntsr3std7is_sameIT0_NT_7array_tEEE5valueEiE4typeELi0EEEvRSQ_RKSP_: 5829| 17.1k| { 5830| 17.1k| using std::begin; 5831| 17.1k| using std::end; 5832| | 5833| 17.1k| j.m_data.m_value.destroy(j.m_data.m_type); 5834| 17.1k| j.m_data.m_type = value_t::array; 5835| 17.1k| j.m_data.m_value.array = j.template create(begin(arr), end(arr)); 5836| 17.1k| j.set_parents(); 5837| 17.1k| j.assert_invariant(); 5838| 17.1k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createINS4_ISE_NS8_ISE_EEEEJNS3_11__wrap_iterIPKNS1_INS3_3mapES4_SA_blmdS8_SB_SD_vEEEESN_EEEPT_DpOT0_: 20396| 17.1k| { 20397| 17.1k| AllocatorType alloc; 20398| 17.1k| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 17.1k| auto deleter = [&](T * obj) 20401| 17.1k| { 20402| 17.1k| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 17.1k| }; 20404| 17.1k| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 17.1k| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 17.1k| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 17.1k| return obj.release(); 20408| 17.1k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_refIRKNS4_ISE_NS8_ISE_EEEETnNS2_9enable_ifIXaasr3std12is_referenceIT_EE5valuesr3std8is_constINS2_16remove_referenceISL_E4typeEEE5valueEiE4typeELi0EEESL_v: 21887| 17.1k| { 21888| | // delegate call to get_ref_impl 21889| 17.1k| return get_ref_impl(*this); 21890| 17.1k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_ref_implIRKNS4_ISE_NS8_ISE_EEEEKSE_EET_RT0_: 21565| 17.1k| { 21566| | // delegate the call to get_ptr<>() 21567| 17.1k| auto* ptr = obj.template get_ptr::type>(); 21568| | 21569| 17.1k| if (JSON_HEDLEY_LIKELY(ptr != nullptr)) ------------------ | | 1690| 17.1k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 17.1k, False: 0] | | ------------------ ------------------ 21570| 17.1k| { 21571| 17.1k| return *ptr; 21572| 17.1k| } 21573| | 21574| 0| JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 21575| 17.1k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKNS4_ISE_NS8_ISE_EEEETnNS2_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS2_14remove_pointerISL_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS2_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISL_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISL_EEEEv: 21598| 17.1k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 17.1k| return get_impl_ptr(static_cast(nullptr)); 21601| 17.1k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINSt3__13mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKNS4_ISE_NS8_ISE_EEEE: 21476| 17.1k| { 21477| 17.1k| return is_array() ? m_data.m_value.array : nullptr; ------------------ | Branch (21477:16): [True: 17.1k, False: 0] ------------------ 21478| 17.1k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2EDn: 20841| 695k| : basic_json(value_t::null) 20842| 695k| { 20843| 695k| assert_invariant(); 20844| 695k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2ENS0_6detail7value_tE: 20833| 695k| : m_data(v) 20834| 695k| { 20835| 695k| assert_invariant(); 20836| 695k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dataC2ENS0_6detail7value_tE: 24240| 695k| : m_type(v), m_value(v) 24241| 695k| { 24242| 695k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2ENS0_6detail7value_tE: 20471| 695k| { 20472| 695k| switch (t) 20473| 695k| { 20474| 0| case value_t::object: ------------------ | Branch (20474:17): [True: 0, False: 695k] ------------------ 20475| 0| { 20476| 0| object = create(); 20477| 0| break; 20478| 0| } 20479| | 20480| 0| case value_t::array: ------------------ | Branch (20480:17): [True: 0, False: 695k] ------------------ 20481| 0| { 20482| 0| array = create(); 20483| 0| break; 20484| 0| } 20485| | 20486| 0| case value_t::string: ------------------ | Branch (20486:17): [True: 0, False: 695k] ------------------ 20487| 0| { 20488| 0| string = create(""); 20489| 0| break; 20490| 0| } 20491| | 20492| 0| case value_t::binary: ------------------ | Branch (20492:17): [True: 0, False: 695k] ------------------ 20493| 0| { 20494| 0| binary = create(); 20495| 0| break; 20496| 0| } 20497| | 20498| 0| case value_t::boolean: ------------------ | Branch (20498:17): [True: 0, False: 695k] ------------------ 20499| 0| { 20500| 0| boolean = static_cast(false); 20501| 0| break; 20502| 0| } 20503| | 20504| 0| case value_t::number_integer: ------------------ | Branch (20504:17): [True: 0, False: 695k] ------------------ 20505| 0| { 20506| 0| number_integer = static_cast(0); 20507| 0| break; 20508| 0| } 20509| | 20510| 0| case value_t::number_unsigned: ------------------ | Branch (20510:17): [True: 0, False: 695k] ------------------ 20511| 0| { 20512| 0| number_unsigned = static_cast(0); 20513| 0| break; 20514| 0| } 20515| | 20516| 0| case value_t::number_float: ------------------ | Branch (20516:17): [True: 0, False: 695k] ------------------ 20517| 0| { 20518| 0| number_float = static_cast(0.0); 20519| 0| break; 20520| 0| } 20521| | 20522| 695k| case value_t::null: ------------------ | Branch (20522:17): [True: 695k, False: 0] ------------------ 20523| 695k| { 20524| 695k| object = nullptr; // silence warning, see #821 20525| 695k| break; 20526| 0| } 20527| | 20528| 0| case value_t::discarded: ------------------ | Branch (20528:17): [True: 0, False: 695k] ------------------ 20529| 0| default: ------------------ | Branch (20529:17): [True: 0, False: 695k] ------------------ 20530| 0| { 20531| 0| object = nullptr; // silence warning, see #821 20532| 0| if (JSON_HEDLEY_UNLIKELY(t == value_t::null)) ------------------ | | 1691| 0|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 0] | | ------------------ ------------------ 20533| 0| { 20534| 0| JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 20535| 0| } 20536| 0| break; 20537| 0| } 20538| 695k| } 20539| 695k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEaSESE_: 21273| 113k| { 21274| | // check that passed value is valid 21275| 113k| other.assert_invariant(); 21276| | 21277| 113k| using std::swap; 21278| 113k| swap(m_data.m_type, other.m_data.m_type); 21279| 113k| swap(m_data.m_value, other.m_data.m_value); 21280| | 21281| |#if JSON_DIAGNOSTIC_POSITIONS 21282| | swap(start_position, other.start_position); 21283| | swap(end_position, other.end_position); 21284| |#endif 21285| | 21286| 113k| json_base_class_t::operator=(std::move(other)); 21287| | 21288| 113k| set_parents(); 21289| 113k| assert_invariant(); 21290| 113k| return *this; 21291| 113k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE11set_parentsEv: 20721| 280M| { 20722| |#if JSON_DIAGNOSTICS 20723| | switch (m_data.m_type) 20724| | { 20725| | case value_t::array: 20726| | { 20727| | for (auto& element : *m_data.m_value.array) 20728| | { 20729| | element.m_parent = this; 20730| | } 20731| | break; 20732| | } 20733| | 20734| | case value_t::object: 20735| | { 20736| | for (auto& element : *m_data.m_value.object) 20737| | { 20738| | element.second.m_parent = this; 20739| | } 20740| | break; 20741| | } 20742| | 20743| | case value_t::null: 20744| | case value_t::string: 20745| | case value_t::boolean: 20746| | case value_t::number_integer: 20747| | case value_t::number_unsigned: 20748| | case value_t::number_float: 20749| | case value_t::binary: 20750| | case value_t::discarded: 20751| | default: 20752| | break; 20753| | } 20754| |#endif 20755| 280M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE16assert_invariantEb: 20700| 843M| { 20701| 843M| JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr); ------------------ | | 2571| 843M| #define JSON_ASSERT(x) assert(x) ------------------ 20702| 843M| JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr); ------------------ | | 2571| 843M| #define JSON_ASSERT(x) assert(x) ------------------ 20703| 843M| JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr); ------------------ | | 2571| 843M| #define JSON_ASSERT(x) assert(x) ------------------ 20704| 843M| JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr); ------------------ | | 2571| 843M| #define JSON_ASSERT(x) assert(x) ------------------ 20705| | 20706| |#if JSON_DIAGNOSTICS 20707| | JSON_TRY 20708| | { 20709| | // cppcheck-suppress assertWithSideEffect 20710| | JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j) 20711| | { 20712| | return j.m_parent == this; 20713| | })); 20714| | } 20715| | JSON_CATCH(...) {} // LCOV_EXCL_LINE 20716| |#endif 20717| 843M| static_cast(check_parents); 20718| 843M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dataD2Ev: 24257| 280M| { 24258| 280M| m_value.destroy(m_type); 24259| 280M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvED2Ev: 21296| 280M| { 21297| 280M| assert_invariant(false); 21298| 280M| } _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl5diyfpC2Emi: 17684| 3.13M| constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl5diyfp3subERKS3_S5_: 17691| 481k| { 17692| 481k| JSON_ASSERT(x.e == y.e); ------------------ | | 2571| 481k| #define JSON_ASSERT(x) assert(x) ------------------ 17693| 481k| JSON_ASSERT(x.f >= y.f); ------------------ | | 2571| 481k| #define JSON_ASSERT(x) assert(x) ------------------ 17694| | 17695| 481k| return {x.f - y.f, x.e}; 17696| 481k| } _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl5diyfp3mulERKS3_S5_: 17703| 722k| { 17704| 722k| static_assert(kPrecision == 64, "internal error"); 17705| | 17706| | // Computes: 17707| | // f = round((x.f * y.f) / 2^q) 17708| | // e = x.e + y.e + q 17709| | 17710| | // Emulate the 64-bit * 64-bit multiplication: 17711| | // 17712| | // p = u * v 17713| | // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi) 17714| | // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi ) 17715| | // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 ) 17716| | // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 ) 17717| | // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3) 17718| | // = (p0_lo ) + 2^32 (Q ) + 2^64 (H ) 17719| | // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H ) 17720| | // 17721| | // (Since Q might be larger than 2^32 - 1) 17722| | // 17723| | // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H) 17724| | // 17725| | // (Q_hi + H does not overflow a 64-bit int) 17726| | // 17727| | // = p_lo + 2^64 p_hi 17728| | 17729| 722k| const std::uint64_t u_lo = x.f & 0xFFFFFFFFu; 17730| 722k| const std::uint64_t u_hi = x.f >> 32u; 17731| 722k| const std::uint64_t v_lo = y.f & 0xFFFFFFFFu; 17732| 722k| const std::uint64_t v_hi = y.f >> 32u; 17733| | 17734| 722k| const std::uint64_t p0 = u_lo * v_lo; 17735| 722k| const std::uint64_t p1 = u_lo * v_hi; 17736| 722k| const std::uint64_t p2 = u_hi * v_lo; 17737| 722k| const std::uint64_t p3 = u_hi * v_hi; 17738| | 17739| 722k| const std::uint64_t p0_hi = p0 >> 32u; 17740| 722k| const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu; 17741| 722k| const std::uint64_t p1_hi = p1 >> 32u; 17742| 722k| const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu; 17743| 722k| const std::uint64_t p2_hi = p2 >> 32u; 17744| | 17745| 722k| std::uint64_t Q = p0_hi + p1_lo + p2_lo; 17746| | 17747| | // The full product might now be computed as 17748| | // 17749| | // p_hi = p3 + p2_hi + p1_hi + (Q >> 32) 17750| | // p_lo = p0_lo + (Q << 32) 17751| | // 17752| | // But in this particular case here, the full p_lo is not required. 17753| | // Effectively we only need to add the highest bit in p_lo to p_hi (and 17754| | // Q_hi + 1 does not overflow). 17755| | 17756| 722k| Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up 17757| | 17758| 722k| const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u); 17759| | 17760| 722k| return {h, x.e + y.e + 64}; 17761| 722k| } _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl5diyfp9normalizeES3_: 17768| 481k| { 17769| 481k| JSON_ASSERT(x.f != 0); ------------------ | | 2571| 481k| #define JSON_ASSERT(x) assert(x) ------------------ 17770| | 17771| 5.59M| while ((x.f >> 63u) == 0) ------------------ | Branch (17771:16): [True: 5.11M, False: 481k] ------------------ 17772| 5.11M| { 17773| 5.11M| x.f <<= 1u; 17774| 5.11M| x.e--; 17775| 5.11M| } 17776| | 17777| 481k| return x; 17778| 481k| } _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl5diyfp12normalize_toERKS3_i: 17785| 240k| { 17786| 240k| const int delta = x.e - target_exponent; 17787| | 17788| 240k| JSON_ASSERT(delta >= 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 17789| 240k| JSON_ASSERT(((x.f << delta) >> delta) == x.f); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 17790| | 17791| 240k| return {x.f << delta, target_exponent}; 17792| 240k| } _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl36get_cached_power_for_binary_exponentEi: 17949| 240k|{ 17950| | // Now 17951| | // 17952| | // alpha <= e_c + e + q <= gamma (1) 17953| | // ==> f_c * 2^alpha <= c * 2^e * 2^q 17954| | // 17955| | // and since the c's are normalized, 2^(q-1) <= f_c, 17956| | // 17957| | // ==> 2^(q - 1 + alpha) <= c * 2^(e + q) 17958| | // ==> 2^(alpha - e - 1) <= c 17959| | // 17960| | // If c were an exact power of ten, i.e. c = 10^k, one may determine k as 17961| | // 17962| | // k = ceil( log_10( 2^(alpha - e - 1) ) ) 17963| | // = ceil( (alpha - e - 1) * log_10(2) ) 17964| | // 17965| | // From the paper: 17966| | // "In theory the result of the procedure could be wrong since c is rounded, 17967| | // and the computation itself is approximated [...]. In practice, however, 17968| | // this simple function is sufficient." 17969| | // 17970| | // For IEEE double precision floating-point numbers converted into 17971| | // normalized diyfp's w = f * 2^e, with q = 64, 17972| | // 17973| | // e >= -1022 (min IEEE exponent) 17974| | // -52 (p - 1) 17975| | // -52 (p - 1, possibly normalize denormal IEEE numbers) 17976| | // -11 (normalize the diyfp) 17977| | // = -1137 17978| | // 17979| | // and 17980| | // 17981| | // e <= +1023 (max IEEE exponent) 17982| | // -52 (p - 1) 17983| | // -11 (normalize the diyfp) 17984| | // = 960 17985| | // 17986| | // This binary exponent range [-1137,960] results in a decimal exponent 17987| | // range [-307,324]. One does not need to store a cached power for each 17988| | // k in this range. For each such k it suffices to find a cached power 17989| | // such that the exponent of the product lies in [alpha,gamma]. 17990| | // This implies that the difference of the decimal exponents of adjacent 17991| | // table entries must be less than or equal to 17992| | // 17993| | // floor( (gamma - alpha) * log_10(2) ) = 8. 17994| | // 17995| | // (A smaller distance gamma-alpha would require a larger table.) 17996| | 17997| | // NB: 17998| | // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34. 17999| | 18000| 240k| constexpr int kCachedPowersMinDecExp = -300; 18001| 240k| constexpr int kCachedPowersDecStep = 8; 18002| | 18003| 240k| static constexpr std::array kCachedPowers = 18004| 240k| { 18005| 240k| { 18006| 240k| { 0xAB70FE17C79AC6CA, -1060, -300 }, 18007| 240k| { 0xFF77B1FCBEBCDC4F, -1034, -292 }, 18008| 240k| { 0xBE5691EF416BD60C, -1007, -284 }, 18009| 240k| { 0x8DD01FAD907FFC3C, -980, -276 }, 18010| 240k| { 0xD3515C2831559A83, -954, -268 }, 18011| 240k| { 0x9D71AC8FADA6C9B5, -927, -260 }, 18012| 240k| { 0xEA9C227723EE8BCB, -901, -252 }, 18013| 240k| { 0xAECC49914078536D, -874, -244 }, 18014| 240k| { 0x823C12795DB6CE57, -847, -236 }, 18015| 240k| { 0xC21094364DFB5637, -821, -228 }, 18016| 240k| { 0x9096EA6F3848984F, -794, -220 }, 18017| 240k| { 0xD77485CB25823AC7, -768, -212 }, 18018| 240k| { 0xA086CFCD97BF97F4, -741, -204 }, 18019| 240k| { 0xEF340A98172AACE5, -715, -196 }, 18020| 240k| { 0xB23867FB2A35B28E, -688, -188 }, 18021| 240k| { 0x84C8D4DFD2C63F3B, -661, -180 }, 18022| 240k| { 0xC5DD44271AD3CDBA, -635, -172 }, 18023| 240k| { 0x936B9FCEBB25C996, -608, -164 }, 18024| 240k| { 0xDBAC6C247D62A584, -582, -156 }, 18025| 240k| { 0xA3AB66580D5FDAF6, -555, -148 }, 18026| 240k| { 0xF3E2F893DEC3F126, -529, -140 }, 18027| 240k| { 0xB5B5ADA8AAFF80B8, -502, -132 }, 18028| 240k| { 0x87625F056C7C4A8B, -475, -124 }, 18029| 240k| { 0xC9BCFF6034C13053, -449, -116 }, 18030| 240k| { 0x964E858C91BA2655, -422, -108 }, 18031| 240k| { 0xDFF9772470297EBD, -396, -100 }, 18032| 240k| { 0xA6DFBD9FB8E5B88F, -369, -92 }, 18033| 240k| { 0xF8A95FCF88747D94, -343, -84 }, 18034| 240k| { 0xB94470938FA89BCF, -316, -76 }, 18035| 240k| { 0x8A08F0F8BF0F156B, -289, -68 }, 18036| 240k| { 0xCDB02555653131B6, -263, -60 }, 18037| 240k| { 0x993FE2C6D07B7FAC, -236, -52 }, 18038| 240k| { 0xE45C10C42A2B3B06, -210, -44 }, 18039| 240k| { 0xAA242499697392D3, -183, -36 }, 18040| 240k| { 0xFD87B5F28300CA0E, -157, -28 }, 18041| 240k| { 0xBCE5086492111AEB, -130, -20 }, 18042| 240k| { 0x8CBCCC096F5088CC, -103, -12 }, 18043| 240k| { 0xD1B71758E219652C, -77, -4 }, 18044| 240k| { 0x9C40000000000000, -50, 4 }, 18045| 240k| { 0xE8D4A51000000000, -24, 12 }, 18046| 240k| { 0xAD78EBC5AC620000, 3, 20 }, 18047| 240k| { 0x813F3978F8940984, 30, 28 }, 18048| 240k| { 0xC097CE7BC90715B3, 56, 36 }, 18049| 240k| { 0x8F7E32CE7BEA5C70, 83, 44 }, 18050| 240k| { 0xD5D238A4ABE98068, 109, 52 }, 18051| 240k| { 0x9F4F2726179A2245, 136, 60 }, 18052| 240k| { 0xED63A231D4C4FB27, 162, 68 }, 18053| 240k| { 0xB0DE65388CC8ADA8, 189, 76 }, 18054| 240k| { 0x83C7088E1AAB65DB, 216, 84 }, 18055| 240k| { 0xC45D1DF942711D9A, 242, 92 }, 18056| 240k| { 0x924D692CA61BE758, 269, 100 }, 18057| 240k| { 0xDA01EE641A708DEA, 295, 108 }, 18058| 240k| { 0xA26DA3999AEF774A, 322, 116 }, 18059| 240k| { 0xF209787BB47D6B85, 348, 124 }, 18060| 240k| { 0xB454E4A179DD1877, 375, 132 }, 18061| 240k| { 0x865B86925B9BC5C2, 402, 140 }, 18062| 240k| { 0xC83553C5C8965D3D, 428, 148 }, 18063| 240k| { 0x952AB45CFA97A0B3, 455, 156 }, 18064| 240k| { 0xDE469FBD99A05FE3, 481, 164 }, 18065| 240k| { 0xA59BC234DB398C25, 508, 172 }, 18066| 240k| { 0xF6C69A72A3989F5C, 534, 180 }, 18067| 240k| { 0xB7DCBF5354E9BECE, 561, 188 }, 18068| 240k| { 0x88FCF317F22241E2, 588, 196 }, 18069| 240k| { 0xCC20CE9BD35C78A5, 614, 204 }, 18070| 240k| { 0x98165AF37B2153DF, 641, 212 }, 18071| 240k| { 0xE2A0B5DC971F303A, 667, 220 }, 18072| 240k| { 0xA8D9D1535CE3B396, 694, 228 }, 18073| 240k| { 0xFB9B7CD9A4A7443C, 720, 236 }, 18074| 240k| { 0xBB764C4CA7A44410, 747, 244 }, 18075| 240k| { 0x8BAB8EEFB6409C1A, 774, 252 }, 18076| 240k| { 0xD01FEF10A657842C, 800, 260 }, 18077| 240k| { 0x9B10A4E5E9913129, 827, 268 }, 18078| 240k| { 0xE7109BFBA19C0C9D, 853, 276 }, 18079| 240k| { 0xAC2820D9623BF429, 880, 284 }, 18080| 240k| { 0x80444B5E7AA7CF85, 907, 292 }, 18081| 240k| { 0xBF21E44003ACDD2D, 933, 300 }, 18082| 240k| { 0x8E679C2F5E44FF8F, 960, 308 }, 18083| 240k| { 0xD433179D9C8CB841, 986, 316 }, 18084| 240k| { 0x9E19DB92B4E31BA9, 1013, 324 }, 18085| 240k| } 18086| 240k| }; 18087| | 18088| | // This computation gives exactly the same results for k as 18089| | // k = ceil((kAlpha - e - 1) * 0.30102999566398114) 18090| | // for |e| <= 1500, but doesn't require floating-point operations. 18091| | // NB: log_10(2) ~= 78913 / 2^18 18092| 240k| JSON_ASSERT(e >= -1500); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18093| 240k| JSON_ASSERT(e <= 1500); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18094| 240k| const int f = kAlpha - e - 1; 18095| 240k| const int k = ((f * 78913) / (1 << 18)) + static_cast(f > 0); 18096| | 18097| 240k| const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep; 18098| 240k| JSON_ASSERT(index >= 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18099| 240k| JSON_ASSERT(static_cast(index) < kCachedPowers.size()); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18100| | 18101| 240k| const cached_power cached = kCachedPowers[static_cast(index)]; 18102| 240k| JSON_ASSERT(kAlpha <= cached.e + e + 64); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18103| 240k| JSON_ASSERT(kGamma >= cached.e + e + 64); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18104| | 18105| 240k| return cached; 18106| 240k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl18find_largest_pow10EjRj: 18113| 240k|{ 18114| | // LCOV_EXCL_START 18115| 240k| if (n >= 1000000000) ------------------ | Branch (18115:9): [True: 0, False: 240k] ------------------ 18116| 0| { 18117| 0| pow10 = 1000000000; 18118| 0| return 10; 18119| 0| } 18120| | // LCOV_EXCL_STOP 18121| 240k| if (n >= 100000000) ------------------ | Branch (18121:9): [True: 3.00k, False: 237k] ------------------ 18122| 3.00k| { 18123| 3.00k| pow10 = 100000000; 18124| 3.00k| return 9; 18125| 3.00k| } 18126| 237k| if (n >= 10000000) ------------------ | Branch (18126:9): [True: 7.49k, False: 230k] ------------------ 18127| 7.49k| { 18128| 7.49k| pow10 = 10000000; 18129| 7.49k| return 8; 18130| 7.49k| } 18131| 230k| if (n >= 1000000) ------------------ | Branch (18131:9): [True: 4.50k, False: 225k] ------------------ 18132| 4.50k| { 18133| 4.50k| pow10 = 1000000; 18134| 4.50k| return 7; 18135| 4.50k| } 18136| 225k| if (n >= 100000) ------------------ | Branch (18136:9): [True: 7.39k, False: 218k] ------------------ 18137| 7.39k| { 18138| 7.39k| pow10 = 100000; 18139| 7.39k| return 6; 18140| 7.39k| } 18141| 218k| if (n >= 10000) ------------------ | Branch (18141:9): [True: 18.6k, False: 199k] ------------------ 18142| 18.6k| { 18143| 18.6k| pow10 = 10000; 18144| 18.6k| return 5; 18145| 18.6k| } 18146| 199k| if (n >= 1000) ------------------ | Branch (18146:9): [True: 186k, False: 13.1k] ------------------ 18147| 186k| { 18148| 186k| pow10 = 1000; 18149| 186k| return 4; 18150| 186k| } 18151| 13.1k| if (n >= 100) ------------------ | Branch (18151:9): [True: 7.94k, False: 5.22k] ------------------ 18152| 7.94k| { 18153| 7.94k| pow10 = 100; 18154| 7.94k| return 3; 18155| 7.94k| } 18156| 5.22k| if (n >= 10) ------------------ | Branch (18156:9): [True: 4.59k, False: 627] ------------------ 18157| 4.59k| { 18158| 4.59k| pow10 = 10; 18159| 4.59k| return 2; 18160| 4.59k| } 18161| | 18162| 627| pow10 = 1; 18163| 627| return 1; 18164| 5.22k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl12grisu2_roundEPcimmmm: 18168| 240k|{ 18169| 240k| JSON_ASSERT(len >= 1); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18170| 240k| JSON_ASSERT(dist <= delta); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18171| 240k| JSON_ASSERT(rest <= delta); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18172| 240k| JSON_ASSERT(ten_k > 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18173| | 18174| | // <--------------------------- delta ----> 18175| | // <---- dist ---------> 18176| | // --------------[------------------+-------------------]-------------- 18177| | // M- w M+ 18178| | // 18179| | // ten_k 18180| | // <------> 18181| | // <---- rest ----> 18182| | // --------------[------------------+----+--------------]-------------- 18183| | // w V 18184| | // = buf * 10^k 18185| | // 18186| | // ten_k represents a unit-in-the-last-place in the decimal representation 18187| | // stored in buf. 18188| | // Decrement buf by ten_k while this takes buf closer to w. 18189| | 18190| | // The tests are written in this order to avoid overflow in unsigned 18191| | // integer arithmetic. 18192| | 18193| 617k| while (rest < dist ------------------ | Branch (18193:12): [True: 572k, False: 45.3k] ------------------ 18194| 572k| && delta - rest >= ten_k ------------------ | Branch (18194:16): [True: 561k, False: 10.5k] ------------------ 18195| 561k| && (rest + ten_k < dist || dist - rest > rest + ten_k - dist)) ------------------ | Branch (18195:17): [True: 370k, False: 191k] | Branch (18195:40): [True: 6.18k, False: 185k] ------------------ 18196| 376k| { 18197| | JSON_ASSERT(buf[len - 1] != '0'); ------------------ | | 2571| 376k| #define JSON_ASSERT(x) assert(x) ------------------ 18198| 376k| buf[len - 1]--; 18199| 376k| rest += ten_k; 18200| 376k| } 18201| 240k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_: 18209| 240k|{ 18210| 240k| static_assert(kAlpha >= -60, "internal error"); 18211| 240k| static_assert(kGamma <= -32, "internal error"); 18212| | 18213| | // Generates the digits (and the exponent) of a decimal floating-point 18214| | // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's 18215| | // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma. 18216| | // 18217| | // <--------------------------- delta ----> 18218| | // <---- dist ---------> 18219| | // --------------[------------------+-------------------]-------------- 18220| | // M- w M+ 18221| | // 18222| | // Grisu2 generates the digits of M+ from left to right and stops as soon as 18223| | // V is in [M-,M+]. 18224| | 18225| 240k| JSON_ASSERT(M_plus.e >= kAlpha); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18226| 240k| JSON_ASSERT(M_plus.e <= kGamma); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18227| | 18228| 240k| std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e) 18229| 240k| std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e) 18230| | 18231| | // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0): 18232| | // 18233| | // M+ = f * 2^e 18234| | // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e 18235| | // = ((p1 ) * 2^-e + (p2 )) * 2^e 18236| | // = p1 + p2 * 2^e 18237| | 18238| 240k| const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e); 18239| | 18240| 240k| auto p1 = static_cast(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.) 18241| 240k| std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e 18242| | 18243| | // 1) 18244| | // 18245| | // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0] 18246| | 18247| 240k| JSON_ASSERT(p1 > 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18248| | 18249| 240k| std::uint32_t pow10{}; 18250| 240k| const int k = find_largest_pow10(p1, pow10); 18251| | 18252| | // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1) 18253| | // 18254| | // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1)) 18255| | // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1)) 18256| | // 18257| | // M+ = p1 + p2 * 2^e 18258| | // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e 18259| | // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e 18260| | // = d[k-1] * 10^(k-1) + ( rest) * 2^e 18261| | // 18262| | // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0) 18263| | // 18264| | // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0] 18265| | // 18266| | // but stop as soon as 18267| | // 18268| | // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e 18269| | 18270| 240k| int n = k; 18271| 1.11M| while (n > 0) ------------------ | Branch (18271:12): [True: 918k, False: 200k] ------------------ 18272| 918k| { 18273| | // Invariants: 18274| | // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k) 18275| | // pow10 = 10^(n-1) <= p1 < 10^n 18276| | // 18277| 918k| const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1) 18278| 918k| const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1) 18279| | // 18280| | // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e 18281| | // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e) 18282| | // 18283| 918k| JSON_ASSERT(d <= 9); ------------------ | | 2571| 918k| #define JSON_ASSERT(x) assert(x) ------------------ 18284| 918k| buffer[length++] = static_cast('0' + d); // buffer := buffer * 10 + d 18285| | // 18286| | // M+ = buffer * 10^(n-1) + (r + p2 * 2^e) 18287| | // 18288| 918k| p1 = r; 18289| 918k| n--; 18290| | // 18291| | // M+ = buffer * 10^n + (p1 + p2 * 2^e) 18292| | // pow10 = 10^n 18293| | // 18294| | 18295| | // Now check if enough digits have been generated. 18296| | // Compute 18297| | // 18298| | // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e 18299| | // 18300| | // Note: 18301| | // Since rest and delta share the same exponent e, it suffices to 18302| | // compare the significands. 18303| 918k| const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2; 18304| 918k| if (rest <= delta) ------------------ | Branch (18304:13): [True: 39.9k, False: 878k] ------------------ 18305| 39.9k| { 18306| | // V = buffer * 10^n, with M- <= V <= M+. 18307| | 18308| 39.9k| decimal_exponent += n; 18309| | 18310| | // We may now just stop. But instead look if the buffer could be 18311| | // decremented to bring V closer to w. 18312| | // 18313| | // pow10 = 10^n is now 1 ulp in the decimal representation V. 18314| | // The rounding procedure works with diyfp's with an implicit 18315| | // exponent of e. 18316| | // 18317| | // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e 18318| | // 18319| 39.9k| const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e; 18320| 39.9k| grisu2_round(buffer, length, dist, delta, rest, ten_n); 18321| | 18322| 39.9k| return; 18323| 39.9k| } 18324| | 18325| 878k| pow10 /= 10; 18326| | // 18327| | // pow10 = 10^(n-1) <= p1 < 10^n 18328| | // Invariants restored. 18329| 878k| } 18330| | 18331| | // 2) 18332| | // 18333| | // The digits of the integral part have been generated: 18334| | // 18335| | // M+ = d[k-1]...d[1]d[0] + p2 * 2^e 18336| | // = buffer + p2 * 2^e 18337| | // 18338| | // Now generate the digits of the fractional part p2 * 2^e. 18339| | // 18340| | // Note: 18341| | // No decimal point is generated: the exponent is adjusted instead. 18342| | // 18343| | // p2 actually represents the fraction 18344| | // 18345| | // p2 * 2^e 18346| | // = p2 / 2^-e 18347| | // = d[-1] / 10^1 + d[-2] / 10^2 + ... 18348| | // 18349| | // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...) 18350| | // 18351| | // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m 18352| | // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...) 18353| | // 18354| | // using 18355| | // 18356| | // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e) 18357| | // = ( d) * 2^-e + ( r) 18358| | // 18359| | // or 18360| | // 10^m * p2 * 2^e = d + r * 2^e 18361| | // 18362| | // i.e. 18363| | // 18364| | // M+ = buffer + p2 * 2^e 18365| | // = buffer + 10^-m * (d + r * 2^e) 18366| | // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e 18367| | // 18368| | // and stop as soon as 10^-m * r * 2^e <= delta * 2^e 18369| | 18370| 200k| JSON_ASSERT(p2 > delta); ------------------ | | 2571| 200k| #define JSON_ASSERT(x) assert(x) ------------------ 18371| | 18372| 200k| int m = 0; 18373| 200k| for (;;) 18374| 2.54M| { 18375| | // Invariant: 18376| | // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e 18377| | // = buffer * 10^-m + 10^-m * (p2 ) * 2^e 18378| | // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e 18379| | // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e 18380| | // 18381| 2.54M| JSON_ASSERT(p2 <= (std::numeric_limits::max)() / 10); ------------------ | | 2571| 2.54M| #define JSON_ASSERT(x) assert(x) ------------------ 18382| 2.54M| p2 *= 10; 18383| 2.54M| const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e 18384| 2.54M| const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e 18385| | // 18386| | // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e 18387| | // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e)) 18388| | // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e 18389| | // 18390| 2.54M| JSON_ASSERT(d <= 9); ------------------ | | 2571| 2.54M| #define JSON_ASSERT(x) assert(x) ------------------ 18391| 2.54M| buffer[length++] = static_cast('0' + d); // buffer := buffer * 10 + d 18392| | // 18393| | // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e 18394| | // 18395| 2.54M| p2 = r; 18396| 2.54M| m++; 18397| | // 18398| | // M+ = buffer * 10^-m + 10^-m * p2 * 2^e 18399| | // Invariant restored. 18400| | 18401| | // Check if enough digits have been generated. 18402| | // 18403| | // 10^-m * p2 * 2^e <= delta * 2^e 18404| | // p2 * 2^e <= 10^m * delta * 2^e 18405| | // p2 <= 10^m * delta 18406| 2.54M| delta *= 10; 18407| 2.54M| dist *= 10; 18408| 2.54M| if (p2 <= delta) ------------------ | Branch (18408:13): [True: 200k, False: 2.34M] ------------------ 18409| 200k| { 18410| 200k| break; 18411| 200k| } 18412| 2.54M| } 18413| | 18414| | // V = buffer * 10^-m, with M- <= V <= M+. 18415| | 18416| 200k| decimal_exponent -= m; 18417| | 18418| | // 1 ulp in the decimal representation is now 10^-m. 18419| | // Since delta and dist are now scaled by 10^m, we need to do the 18420| | // same with ulp in order to keep the units in sync. 18421| | // 18422| | // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e 18423| | // 18424| 200k| const std::uint64_t ten_m = one.f; 18425| 200k| grisu2_round(buffer, length, dist, delta, p2, ten_m); 18426| | 18427| | // By construction this algorithm generates the shortest possible decimal 18428| | // number (Loitsch, Theorem 6.2) which rounds back to w. 18429| | // For an input number of precision p, at least 18430| | // 18431| | // N = 1 + ceil(p * log_10(2)) 18432| | // 18433| | // decimal digits are sufficient to identify all binary floating-point 18434| | // numbers (Matula, "In-and-Out conversions"). 18435| | // This implies that the algorithm does not produce more than N decimal 18436| | // digits. 18437| | // 18438| | // N = 17 for p = 53 (IEEE double precision) 18439| | // N = 9 for p = 24 (IEEE single precision) 18440| 200k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_: 18450| 240k|{ 18451| 240k| JSON_ASSERT(m_plus.e == m_minus.e); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18452| 240k| JSON_ASSERT(m_plus.e == v.e); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18453| | 18454| | // --------(-----------------------+-----------------------)-------- (A) 18455| | // m- v m+ 18456| | // 18457| | // --------------------(-----------+-----------------------)-------- (B) 18458| | // m- v m+ 18459| | // 18460| | // First scale v (and m- and m+) such that the exponent is in the range 18461| | // [alpha, gamma]. 18462| | 18463| 240k| const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e); 18464| | 18465| 240k| const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k 18466| | 18467| | // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma] 18468| 240k| const diyfp w = diyfp::mul(v, c_minus_k); 18469| 240k| const diyfp w_minus = diyfp::mul(m_minus, c_minus_k); 18470| 240k| const diyfp w_plus = diyfp::mul(m_plus, c_minus_k); 18471| | 18472| | // ----(---+---)---------------(---+---)---------------(---+---)---- 18473| | // w- w w+ 18474| | // = c*m- = c*v = c*m+ 18475| | // 18476| | // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and 18477| | // w+ are now off by a small amount. 18478| | // In fact: 18479| | // 18480| | // w - v * 10^k < 1 ulp 18481| | // 18482| | // To account for this inaccuracy, add resp. subtract 1 ulp. 18483| | // 18484| | // --------+---[---------------(---+---)---------------]---+-------- 18485| | // w- M- w M+ w+ 18486| | // 18487| | // Now any number in [M-, M+] (bounds included) will round to w when input, 18488| | // regardless of how the input rounding algorithm breaks ties. 18489| | // 18490| | // And digit_gen generates the shortest possible such number in [M-, M+]. 18491| | // Note that this does not mean that Grisu2 always generates the shortest 18492| | // possible number in the interval (m-, m+). 18493| 240k| const diyfp M_minus(w_minus.f + 1, w_minus.e); 18494| 240k| const diyfp M_plus (w_plus.f - 1, w_plus.e ); 18495| | 18496| 240k| decimal_exponent = -cached.k; // = -(-k) = k 18497| | 18498| 240k| grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus); 18499| 240k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl15append_exponentEPci: 18549| 202k|{ 18550| 202k| JSON_ASSERT(e > -1000); ------------------ | | 2571| 202k| #define JSON_ASSERT(x) assert(x) ------------------ 18551| 202k| JSON_ASSERT(e < 1000); ------------------ | | 2571| 202k| #define JSON_ASSERT(x) assert(x) ------------------ 18552| | 18553| 202k| if (e < 0) ------------------ | Branch (18553:9): [True: 3.00k, False: 199k] ------------------ 18554| 3.00k| { 18555| 3.00k| e = -e; 18556| 3.00k| *buf++ = '-'; 18557| 3.00k| } 18558| 199k| else 18559| 199k| { 18560| 199k| *buf++ = '+'; 18561| 199k| } 18562| | 18563| 202k| auto k = static_cast(e); 18564| 202k| if (k < 10) ------------------ | Branch (18564:9): [True: 669, False: 201k] ------------------ 18565| 669| { 18566| | // Always print at least two digits in the exponent. 18567| | // This is for compatibility with printf("%g"). 18568| 669| *buf++ = '0'; 18569| 669| *buf++ = static_cast('0' + k); 18570| 669| } 18571| 201k| else if (k < 100) ------------------ | Branch (18571:14): [True: 198k, False: 2.69k] ------------------ 18572| 198k| { 18573| 198k| *buf++ = static_cast('0' + (k / 10)); 18574| 198k| k %= 10; 18575| 198k| *buf++ = static_cast('0' + k); 18576| 198k| } 18577| 2.69k| else 18578| 2.69k| { 18579| 2.69k| *buf++ = static_cast('0' + (k / 100)); 18580| 2.69k| k %= 100; 18581| 2.69k| *buf++ = static_cast('0' + (k / 10)); 18582| 2.69k| k %= 10; 18583| 2.69k| *buf++ = static_cast('0' + k); 18584| 2.69k| } 18585| | 18586| 202k| return buf; 18587| 202k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl13format_bufferEPciiii: 18602| 240k|{ 18603| 240k| JSON_ASSERT(min_exp < 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18604| 240k| JSON_ASSERT(max_exp > 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18605| | 18606| 240k| const int k = len; 18607| 240k| const int n = len + decimal_exponent; 18608| | 18609| | // v = buf * 10^(n-k) 18610| | // k is the length of the buffer (number of decimal digits) 18611| | // n is the position of the decimal point relative to the start of the buffer. 18612| | 18613| 240k| if (k <= n && n <= max_exp) ------------------ | Branch (18613:9): [True: 214k, False: 26.3k] | Branch (18613:19): [True: 15.6k, False: 199k] ------------------ 18614| 15.6k| { 18615| | // digits[000] 18616| | // len <= max_exp + 2 18617| | 18618| 15.6k| std::memset(buf + k, '0', static_cast(n) - static_cast(k)); 18619| | // Make it look like a floating-point number (#362, #378) 18620| 15.6k| buf[n + 0] = '.'; 18621| 15.6k| buf[n + 1] = '0'; 18622| 15.6k| return buf + (static_cast(n) + 2); 18623| 15.6k| } 18624| | 18625| 225k| if (0 < n && n <= max_exp) ------------------ | Branch (18625:9): [True: 217k, False: 8.33k] | Branch (18625:18): [True: 17.9k, False: 199k] ------------------ 18626| 17.9k| { 18627| | // dig.its 18628| | // len <= max_digits10 + 1 18629| | 18630| 17.9k| JSON_ASSERT(k > n); ------------------ | | 2571| 17.9k| #define JSON_ASSERT(x) assert(x) ------------------ 18631| | 18632| 17.9k| std::memmove(buf + (static_cast(n) + 1), buf + n, static_cast(k) - static_cast(n)); 18633| 17.9k| buf[n] = '.'; 18634| 17.9k| return buf + (static_cast(k) + 1U); 18635| 17.9k| } 18636| | 18637| 207k| if (min_exp < n && n <= 0) ------------------ | Branch (18637:9): [True: 204k, False: 3.00k] | Branch (18637:24): [True: 5.32k, False: 199k] ------------------ 18638| 5.32k| { 18639| | // 0.[000]digits 18640| | // len <= 2 + (-min_exp - 1) + max_digits10 18641| | 18642| 5.32k| std::memmove(buf + (2 + static_cast(-n)), buf, static_cast(k)); 18643| 5.32k| buf[0] = '0'; 18644| 5.32k| buf[1] = '.'; 18645| 5.32k| std::memset(buf + 2, '0', static_cast(-n)); 18646| 5.32k| return buf + (2U + static_cast(-n) + static_cast(k)); 18647| 5.32k| } 18648| | 18649| 202k| if (k == 1) ------------------ | Branch (18649:9): [True: 7.08k, False: 195k] ------------------ 18650| 7.08k| { 18651| | // dE+123 18652| | // len <= 1 + 5 18653| | 18654| 7.08k| buf += 1; 18655| 7.08k| } 18656| 195k| else 18657| 195k| { 18658| | // d.igitsE+123 18659| | // len <= max_digits10 + 1 + 5 18660| | 18661| 195k| std::memmove(buf + 2, buf + 1, static_cast(k) - 1); 18662| 195k| buf[1] = '.'; 18663| 195k| buf += 1 + static_cast(k); 18664| 195k| } 18665| | 18666| 202k| *buf++ = 'e'; 18667| 202k| return append_exponent(buf, n - 1); 18668| 207k|} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE5beginEv: 22810| 64.9k| { 22811| 64.9k| iterator result(this); 22812| 64.9k| result.set_begin(); 22813| 64.9k| return result; 22814| 64.9k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEC2EPSG_: 13658| 129k| explicit iter_impl(pointer object) noexcept : m_object(object) 13659| 129k| { 13660| 129k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 129k| #define JSON_ASSERT(x) assert(x) ------------------ 13661| | 13662| 129k| switch (m_object->m_data.m_type) 13663| 129k| { 13664| 82.6k| case value_t::object: ------------------ | Branch (13664:13): [True: 82.6k, False: 47.2k] ------------------ 13665| 82.6k| { 13666| 82.6k| m_it.object_iterator = typename object_t::iterator(); 13667| 82.6k| break; 13668| 0| } 13669| | 13670| 47.2k| case value_t::array: ------------------ | Branch (13670:13): [True: 47.2k, False: 82.6k] ------------------ 13671| 47.2k| { 13672| 47.2k| m_it.array_iterator = typename array_t::iterator(); 13673| 47.2k| break; 13674| 0| } 13675| | 13676| 0| case value_t::null: ------------------ | Branch (13676:13): [True: 0, False: 129k] ------------------ 13677| 0| case value_t::string: ------------------ | Branch (13677:13): [True: 0, False: 129k] ------------------ 13678| 0| case value_t::boolean: ------------------ | Branch (13678:13): [True: 0, False: 129k] ------------------ 13679| 0| case value_t::number_integer: ------------------ | Branch (13679:13): [True: 0, False: 129k] ------------------ 13680| 0| case value_t::number_unsigned: ------------------ | Branch (13680:13): [True: 0, False: 129k] ------------------ 13681| 0| case value_t::number_float: ------------------ | Branch (13681:13): [True: 0, False: 129k] ------------------ 13682| 0| case value_t::binary: ------------------ | Branch (13682:13): [True: 0, False: 129k] ------------------ 13683| 0| case value_t::discarded: ------------------ | Branch (13683:13): [True: 0, False: 129k] ------------------ 13684| 0| default: ------------------ | Branch (13684:13): [True: 0, False: 129k] ------------------ 13685| 0| { 13686| 0| m_it.primitive_iterator = primitive_iterator_t(); 13687| 0| break; 13688| 0| } 13689| 129k| } 13690| 129k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE9set_beginEv: 13756| 64.9k| { 13757| 64.9k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 64.9k| #define JSON_ASSERT(x) assert(x) ------------------ 13758| | 13759| 64.9k| switch (m_object->m_data.m_type) 13760| 64.9k| { 13761| 41.3k| case value_t::object: ------------------ | Branch (13761:13): [True: 41.3k, False: 23.6k] ------------------ 13762| 41.3k| { 13763| 41.3k| m_it.object_iterator = m_object->m_data.m_value.object->begin(); 13764| 41.3k| break; 13765| 0| } 13766| | 13767| 23.6k| case value_t::array: ------------------ | Branch (13767:13): [True: 23.6k, False: 41.3k] ------------------ 13768| 23.6k| { 13769| 23.6k| m_it.array_iterator = m_object->m_data.m_value.array->begin(); 13770| 23.6k| break; 13771| 0| } 13772| | 13773| 0| case value_t::null: ------------------ | Branch (13773:13): [True: 0, False: 64.9k] ------------------ 13774| 0| { 13775| | // set to end so begin()==end() is true: null is empty 13776| 0| m_it.primitive_iterator.set_end(); 13777| 0| break; 13778| 0| } 13779| | 13780| 0| case value_t::string: ------------------ | Branch (13780:13): [True: 0, False: 64.9k] ------------------ 13781| 0| case value_t::boolean: ------------------ | Branch (13781:13): [True: 0, False: 64.9k] ------------------ 13782| 0| case value_t::number_integer: ------------------ | Branch (13782:13): [True: 0, False: 64.9k] ------------------ 13783| 0| case value_t::number_unsigned: ------------------ | Branch (13783:13): [True: 0, False: 64.9k] ------------------ 13784| 0| case value_t::number_float: ------------------ | Branch (13784:13): [True: 0, False: 64.9k] ------------------ 13785| 0| case value_t::binary: ------------------ | Branch (13785:13): [True: 0, False: 64.9k] ------------------ 13786| 0| case value_t::discarded: ------------------ | Branch (13786:13): [True: 0, False: 64.9k] ------------------ 13787| 0| default: ------------------ | Branch (13787:13): [True: 0, False: 64.9k] ------------------ 13788| 0| { 13789| 0| m_it.primitive_iterator.set_begin(); 13790| 0| break; 13791| 0| } 13792| 64.9k| } 13793| 64.9k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3endEv: 22835| 64.9k| { 22836| 64.9k| iterator result(this); 22837| 64.9k| result.set_end(); 22838| 64.9k| return result; 22839| 64.9k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE7set_endEv: 13800| 64.9k| { 13801| 64.9k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 64.9k| #define JSON_ASSERT(x) assert(x) ------------------ 13802| | 13803| 64.9k| switch (m_object->m_data.m_type) 13804| 64.9k| { 13805| 41.3k| case value_t::object: ------------------ | Branch (13805:13): [True: 41.3k, False: 23.6k] ------------------ 13806| 41.3k| { 13807| 41.3k| m_it.object_iterator = m_object->m_data.m_value.object->end(); 13808| 41.3k| break; 13809| 0| } 13810| | 13811| 23.6k| case value_t::array: ------------------ | Branch (13811:13): [True: 23.6k, False: 41.3k] ------------------ 13812| 23.6k| { 13813| 23.6k| m_it.array_iterator = m_object->m_data.m_value.array->end(); 13814| 23.6k| break; 13815| 0| } 13816| | 13817| 0| case value_t::null: ------------------ | Branch (13817:13): [True: 0, False: 64.9k] ------------------ 13818| 0| case value_t::string: ------------------ | Branch (13818:13): [True: 0, False: 64.9k] ------------------ 13819| 0| case value_t::boolean: ------------------ | Branch (13819:13): [True: 0, False: 64.9k] ------------------ 13820| 0| case value_t::number_integer: ------------------ | Branch (13820:13): [True: 0, False: 64.9k] ------------------ 13821| 0| case value_t::number_unsigned: ------------------ | Branch (13821:13): [True: 0, False: 64.9k] ------------------ 13822| 0| case value_t::number_float: ------------------ | Branch (13822:13): [True: 0, False: 64.9k] ------------------ 13823| 0| case value_t::binary: ------------------ | Branch (13823:13): [True: 0, False: 64.9k] ------------------ 13824| 0| case value_t::discarded: ------------------ | Branch (13824:13): [True: 0, False: 64.9k] ------------------ 13825| 0| default: ------------------ | Branch (13825:13): [True: 0, False: 64.9k] ------------------ 13826| 0| { 13827| 0| m_it.primitive_iterator.set_end(); 13828| 0| break; 13829| 0| } 13830| 64.9k| } 13831| 64.9k| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEneISH_TnNS5_9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_IKSG_EEEE5valueEDnE4typeELDn0EEEbRKSK_: 14068| 4.74M| { 14069| 4.74M| return !operator==(other); 14070| 4.74M| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEeqISH_TnNS5_9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_IKSG_EEEE5valueEDnE4typeELDn0EEEbRKSK_: 14028| 4.74M| { 14029| | // if objects are not the same, the comparison is undefined 14030| 4.74M| if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) ------------------ | | 1691| 4.74M|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 4.74M] | | ------------------ ------------------ 14031| 0| { 14032| 0| JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 14033| 0| } 14034| | 14035| | // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493 14036| 4.74M| if (m_object == nullptr) ------------------ | Branch (14036:13): [True: 0, False: 4.74M] ------------------ 14037| 0| { 14038| 0| return true; 14039| 0| } 14040| | 14041| 4.74M| switch (m_object->m_data.m_type) 14042| 4.74M| { 14043| 101k| case value_t::object: ------------------ | Branch (14043:13): [True: 101k, False: 4.64M] ------------------ 14044| 101k| return (m_it.object_iterator == other.m_it.object_iterator); 14045| | 14046| 4.64M| case value_t::array: ------------------ | Branch (14046:13): [True: 4.64M, False: 101k] ------------------ 14047| 4.64M| return (m_it.array_iterator == other.m_it.array_iterator); 14048| | 14049| 0| case value_t::null: ------------------ | Branch (14049:13): [True: 0, False: 4.74M] ------------------ 14050| 0| case value_t::string: ------------------ | Branch (14050:13): [True: 0, False: 4.74M] ------------------ 14051| 0| case value_t::boolean: ------------------ | Branch (14051:13): [True: 0, False: 4.74M] ------------------ 14052| 0| case value_t::number_integer: ------------------ | Branch (14052:13): [True: 0, False: 4.74M] ------------------ 14053| 0| case value_t::number_unsigned: ------------------ | Branch (14053:13): [True: 0, False: 4.74M] ------------------ 14054| 0| case value_t::number_float: ------------------ | Branch (14054:13): [True: 0, False: 4.74M] ------------------ 14055| 0| case value_t::binary: ------------------ | Branch (14055:13): [True: 0, False: 4.74M] ------------------ 14056| 0| case value_t::discarded: ------------------ | Branch (14056:13): [True: 0, False: 4.74M] ------------------ 14057| 0| default: ------------------ | Branch (14057:13): [True: 0, False: 4.74M] ------------------ 14058| 0| return (m_it.primitive_iterator == other.m_it.primitive_iterator); 14059| 4.74M| } 14060| 4.74M| } _ZN8nlohmann16json_abi_v3_12_06detail9exception11diagnosticsINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEESD_PKT_: 4538| 73| { 4539| |#if JSON_DIAGNOSTICS 4540| | std::vector tokens; 4541| | for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent) 4542| | { 4543| | switch (current->m_parent->type()) 4544| | { 4545| | case value_t::array: 4546| | { 4547| | for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i) 4548| | { 4549| | if (¤t->m_parent->m_data.m_value.array->operator[](i) == current) 4550| | { 4551| | tokens.emplace_back(std::to_string(i)); 4552| | break; 4553| | } 4554| | } 4555| | break; 4556| | } 4557| | 4558| | case value_t::object: 4559| | { 4560| | for (const auto& element : *current->m_parent->m_data.m_value.object) 4561| | { 4562| | if (&element.second == current) 4563| | { 4564| | tokens.emplace_back(element.first.c_str()); 4565| | break; 4566| | } 4567| | } 4568| | break; 4569| | } 4570| | 4571| | case value_t::null: // LCOV_EXCL_LINE 4572| | case value_t::string: // LCOV_EXCL_LINE 4573| | case value_t::boolean: // LCOV_EXCL_LINE 4574| | case value_t::number_integer: // LCOV_EXCL_LINE 4575| | case value_t::number_unsigned: // LCOV_EXCL_LINE 4576| | case value_t::number_float: // LCOV_EXCL_LINE 4577| | case value_t::binary: // LCOV_EXCL_LINE 4578| | case value_t::discarded: // LCOV_EXCL_LINE 4579| | default: // LCOV_EXCL_LINE 4580| | break; // LCOV_EXCL_LINE 4581| | } 4582| | } 4583| | 4584| | if (tokens.empty()) 4585| | { 4586| | return ""; 4587| | } 4588| | 4589| | auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{}, 4590| | [](const std::string & a, const std::string & b) 4591| | { 4592| | return concat(a, '/', detail::escape(b)); 4593| | }); 4594| | 4595| | return concat('(', str, ") ", get_byte_positions(leaf_element)); 4596| |#else 4597| 73| return get_byte_positions(leaf_element); 4598| 73|#endif 4599| 73| } _ZN8nlohmann16json_abi_v3_12_06detail9exception18get_byte_positionsINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEESD_PKT_: 4617| 73| { 4618| 73| static_cast(leaf_element); 4619| 73| return ""; 4620| 73| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEdeEv: 13839| 4.68M| { 13840| 4.68M| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 4.68M| #define JSON_ASSERT(x) assert(x) ------------------ 13841| | 13842| 4.68M| switch (m_object->m_data.m_type) 13843| 4.68M| { 13844| 60.6k| case value_t::object: ------------------ | Branch (13844:13): [True: 60.6k, False: 4.62M] ------------------ 13845| 60.6k| { 13846| 60.6k| JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end()); ------------------ | | 2571| 60.6k| #define JSON_ASSERT(x) assert(x) ------------------ 13847| 60.6k| return m_it.object_iterator->second; 13848| 0| } 13849| | 13850| 4.62M| case value_t::array: ------------------ | Branch (13850:13): [True: 4.62M, False: 60.6k] ------------------ 13851| 4.62M| { 13852| 4.62M| JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end()); ------------------ | | 2571| 4.62M| #define JSON_ASSERT(x) assert(x) ------------------ 13853| 4.62M| return *m_it.array_iterator; 13854| 0| } 13855| | 13856| 0| case value_t::null: ------------------ | Branch (13856:13): [True: 0, False: 4.68M] ------------------ 13857| 0| JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 13858| | 13859| 0| case value_t::string: ------------------ | Branch (13859:13): [True: 0, False: 4.68M] ------------------ 13860| 0| case value_t::boolean: ------------------ | Branch (13860:13): [True: 0, False: 4.68M] ------------------ 13861| 0| case value_t::number_integer: ------------------ | Branch (13861:13): [True: 0, False: 4.68M] ------------------ 13862| 0| case value_t::number_unsigned: ------------------ | Branch (13862:13): [True: 0, False: 4.68M] ------------------ 13863| 0| case value_t::number_float: ------------------ | Branch (13863:13): [True: 0, False: 4.68M] ------------------ 13864| 0| case value_t::binary: ------------------ | Branch (13864:13): [True: 0, False: 4.68M] ------------------ 13865| 0| case value_t::discarded: ------------------ | Branch (13865:13): [True: 0, False: 4.68M] ------------------ 13866| 0| default: ------------------ | Branch (13866:13): [True: 0, False: 4.68M] ------------------ 13867| 0| { 13868| 0| if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) ------------------ | | 1690| 0|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 0, False: 0] | | ------------------ ------------------ 13869| 0| { 13870| 0| return *m_object; 13871| 0| } 13872| | 13873| 0| JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 13874| 0| } 13875| 4.68M| } 13876| 4.68M| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEppEv: 13936| 4.68M| { 13937| 4.68M| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 4.68M| #define JSON_ASSERT(x) assert(x) ------------------ 13938| | 13939| 4.68M| switch (m_object->m_data.m_type) 13940| 4.68M| { 13941| 60.6k| case value_t::object: ------------------ | Branch (13941:13): [True: 60.6k, False: 4.62M] ------------------ 13942| 60.6k| { 13943| 60.6k| std::advance(m_it.object_iterator, 1); 13944| 60.6k| break; 13945| 0| } 13946| | 13947| 4.62M| case value_t::array: ------------------ | Branch (13947:13): [True: 4.62M, False: 60.6k] ------------------ 13948| 4.62M| { 13949| 4.62M| std::advance(m_it.array_iterator, 1); 13950| 4.62M| break; 13951| 0| } 13952| | 13953| 0| case value_t::null: ------------------ | Branch (13953:13): [True: 0, False: 4.68M] ------------------ 13954| 0| case value_t::string: ------------------ | Branch (13954:13): [True: 0, False: 4.68M] ------------------ 13955| 0| case value_t::boolean: ------------------ | Branch (13955:13): [True: 0, False: 4.68M] ------------------ 13956| 0| case value_t::number_integer: ------------------ | Branch (13956:13): [True: 0, False: 4.68M] ------------------ 13957| 0| case value_t::number_unsigned: ------------------ | Branch (13957:13): [True: 0, False: 4.68M] ------------------ 13958| 0| case value_t::number_float: ------------------ | Branch (13958:13): [True: 0, False: 4.68M] ------------------ 13959| 0| case value_t::binary: ------------------ | Branch (13959:13): [True: 0, False: 4.68M] ------------------ 13960| 0| case value_t::discarded: ------------------ | Branch (13960:13): [True: 0, False: 4.68M] ------------------ 13961| 0| default: ------------------ | Branch (13961:13): [True: 0, False: 4.68M] ------------------ 13962| 0| { 13963| 0| ++m_it.primitive_iterator; 13964| 0| break; 13965| 0| } 13966| 4.68M| } 13967| | 13968| 4.68M| return *this; 13969| 4.68M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA5_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 1.89M| { 22781| 1.89M| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 498k, False: 1.39M] | Branch (22781:31): [True: 162k, False: 335k] ------------------ 22782| 1.89M| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA5_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 498k| { 20019| 1.23M| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 898k, False: 335k] ------------------ 20020| 898k| { 20021| 898k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 162k, False: 735k] ------------------ 20022| 162k| { 20023| 162k| return it; 20024| 162k| } 20025| 898k| } 20026| 335k| return Container::end(); 20027| 498k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEixIKcEERSE_PT_: 22199| 109k| { 22200| 109k| return operator[](typename object_t::key_type(key)); 22201| 109k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEcvT_ISA_TnNS3_9enable_ifIXsr6detail11conjunctionINS0_6detail8negationINS3_10is_pointerISF_EEEENSJ_INS3_7is_sameISF_DnEEEENSJ_INSN_ISF_NSI_8json_refISE_EEEEEENSJ_INSN_ISF_cEEEENSJ_INSI_13is_basic_jsonISF_EEEENSJ_INSN_ISF_St16initializer_listIcEEEEENSJ_INSN_ISF_NS3_17basic_string_viewIcS7_EEEEEENSJ_INSN_ISF_NS3_3anyEEEEENSI_16is_detected_lazyINSI_21get_template_functionEJRKSE_SF_EEEEE5valueEiE4typeELi0EEEv: 21938| 86.9k| { 21939| | // delegate the call to get<>() const 21940| 86.9k| return get(); 21941| 86.9k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getISA_SA_EEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 115k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 115k| static_assert(!std::is_reference::value, 21793| 115k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 115k| return get_impl(detail::priority_tag<4> {}); 21795| 115k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implISA_TnNS3_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 115k| { 21650| 115k| auto ret = ValueType(); 21651| 115k| JSONSerializer::from_json(*this, ret); 21652| 115k| return ret; 21653| 115k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE9from_jsonIRKNS0_10basic_jsonINS0_11ordered_mapENS2_6vectorES8_blmdS6_S1_NSD_IhNS6_IhEEEEvEES8_EEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 115k| { 6144| 115k| ::nlohmann::from_json(std::forward(j), val); 6145| 115k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERSD_EEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 115k| { 5343| 115k| return from_json(j, std::forward(val)); 5344| 115k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_8string_tE: 4901| 115k|{ 4902| 115k| if (JSON_HEDLEY_UNLIKELY(!j.is_string())) ------------------ | | 1691| 115k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 23, False: 115k] | | ------------------ ------------------ 4903| 23| { 4904| 23| JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j)); ------------------ | | 2536| 23| #define JSON_THROW(exception) throw exception ------------------ 4905| 23| } 4906| 115k| s = *j.template get_ptr(); 4907| 115k|} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE9is_stringEv: 21413| 747k| { 21414| 747k| return m_data.m_type == value_t::string; 21415| 747k| } _ZN8nlohmann16json_abi_v3_12_06detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEETnNS6_9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSD_SL_: 4702| 73| { 4703| 73| const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg); 4704| 73| return {id_, w.c_str()}; 4705| 73| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE9type_nameEv: 24201| 73| { 24202| 73| switch (m_data.m_type) 24203| 73| { 24204| 0| case value_t::null: ------------------ | Branch (24204:13): [True: 0, False: 73] ------------------ 24205| 0| return "null"; 24206| 12| case value_t::object: ------------------ | Branch (24206:13): [True: 12, False: 61] ------------------ 24207| 12| return "object"; 24208| 4| case value_t::array: ------------------ | Branch (24208:13): [True: 4, False: 69] ------------------ 24209| 4| return "array"; 24210| 38| case value_t::string: ------------------ | Branch (24210:13): [True: 38, False: 35] ------------------ 24211| 38| return "string"; 24212| 0| case value_t::boolean: ------------------ | Branch (24212:13): [True: 0, False: 73] ------------------ 24213| 0| return "boolean"; 24214| 0| case value_t::binary: ------------------ | Branch (24214:13): [True: 0, False: 73] ------------------ 24215| 0| return "binary"; 24216| 0| case value_t::discarded: ------------------ | Branch (24216:13): [True: 0, False: 73] ------------------ 24217| 0| return "discarded"; 24218| 6| case value_t::number_integer: ------------------ | Branch (24218:13): [True: 6, False: 67] ------------------ 24219| 18| case value_t::number_unsigned: ------------------ | Branch (24219:13): [True: 12, False: 61] ------------------ 24220| 19| case value_t::number_float: ------------------ | Branch (24220:13): [True: 1, False: 72] ------------------ 24221| 19| default: ------------------ | Branch (24221:13): [True: 0, False: 73] ------------------ 24222| 19| return "number"; 24223| 73| } 24224| 73| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKSA_TnNS3_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS3_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 115k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 115k| return get_impl_ptr(static_cast(nullptr)); 21601| 115k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKSA_: 21488| 115k| { 21489| 115k| return is_string() ? m_data.m_value.string : nullptr; ------------------ | Branch (21489:16): [True: 115k, False: 0] ------------------ 21490| 115k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2ERKSE_: 21168| 72.1M| : json_base_class_t(other) 21169| |#if JSON_DIAGNOSTIC_POSITIONS 21170| | , start_position(other.start_position) 21171| | , end_position(other.end_position) 21172| |#endif 21173| 72.1M| { 21174| 72.1M| m_data.m_type = other.m_data.m_type; 21175| | // check of passed value is valid 21176| 72.1M| other.assert_invariant(); 21177| | 21178| 72.1M| switch (m_data.m_type) 21179| 72.1M| { 21180| 2.87M| case value_t::object: ------------------ | Branch (21180:13): [True: 2.87M, False: 69.3M] ------------------ 21181| 2.87M| { 21182| 2.87M| m_data.m_value = *other.m_data.m_value.object; 21183| 2.87M| break; 21184| 0| } 21185| | 21186| 3.59M| case value_t::array: ------------------ | Branch (21186:13): [True: 3.59M, False: 68.5M] ------------------ 21187| 3.59M| { 21188| 3.59M| m_data.m_value = *other.m_data.m_value.array; 21189| 3.59M| break; 21190| 0| } 21191| | 21192| 14.0M| case value_t::string: ------------------ | Branch (21192:13): [True: 14.0M, False: 58.1M] ------------------ 21193| 14.0M| { 21194| 14.0M| m_data.m_value = *other.m_data.m_value.string; 21195| 14.0M| break; 21196| 0| } 21197| | 21198| 6.08k| case value_t::boolean: ------------------ | Branch (21198:13): [True: 6.08k, False: 72.1M] ------------------ 21199| 6.08k| { 21200| 6.08k| m_data.m_value = other.m_data.m_value.boolean; 21201| 6.08k| break; 21202| 0| } 21203| | 21204| 1.38M| case value_t::number_integer: ------------------ | Branch (21204:13): [True: 1.38M, False: 70.7M] ------------------ 21205| 1.38M| { 21206| 1.38M| m_data.m_value = other.m_data.m_value.number_integer; 21207| 1.38M| break; 21208| 0| } 21209| | 21210| 47.2M| case value_t::number_unsigned: ------------------ | Branch (21210:13): [True: 47.2M, False: 24.9M] ------------------ 21211| 47.2M| { 21212| 47.2M| m_data.m_value = other.m_data.m_value.number_unsigned; 21213| 47.2M| break; 21214| 0| } 21215| | 21216| 1.32M| case value_t::number_float: ------------------ | Branch (21216:13): [True: 1.32M, False: 70.8M] ------------------ 21217| 1.32M| { 21218| 1.32M| m_data.m_value = other.m_data.m_value.number_float; 21219| 1.32M| break; 21220| 0| } 21221| | 21222| 0| case value_t::binary: ------------------ | Branch (21222:13): [True: 0, False: 72.1M] ------------------ 21223| 0| { 21224| 0| m_data.m_value = *other.m_data.m_value.binary; 21225| 0| break; 21226| 0| } 21227| | 21228| 1.73M| case value_t::null: ------------------ | Branch (21228:13): [True: 1.73M, False: 70.4M] ------------------ 21229| 1.73M| case value_t::discarded: ------------------ | Branch (21229:13): [True: 0, False: 72.1M] ------------------ 21230| 1.73M| default: ------------------ | Branch (21230:13): [True: 0, False: 72.1M] ------------------ 21231| 1.73M| break; 21232| 72.1M| } 21233| | 21234| 72.1M| set_parents(); 21235| 72.1M| assert_invariant(); 21236| 72.1M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2ERKNS2_ISA_SE_NS3_4lessIvEENS8_INS3_4pairIKSA_SE_EEEEEE: 20548| 2.87M| json_value(const object_t& value) : object(create(value)) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createINS2_ISA_SE_NS3_4lessIvEENS8_INS3_4pairIKSA_SE_EEEEEEJRKSM_EEEPT_DpOT0_: 20396| 2.87M| { 20397| 2.87M| AllocatorType alloc; 20398| 2.87M| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 2.87M| auto deleter = [&](T * obj) 20401| 2.87M| { 20402| 2.87M| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 2.87M| }; 20404| 2.87M| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 2.87M| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 2.87M| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 2.87M| return obj.release(); 20408| 2.87M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2ERKNS4_ISE_NS8_ISE_EEEE: 20554| 3.59M| json_value(const array_t& value) : array(create(value)) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createINS4_ISE_NS8_ISE_EEEEJRKSH_EEEPT_DpOT0_: 20396| 3.59M| { 20397| 3.59M| AllocatorType alloc; 20398| 3.59M| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 3.59M| auto deleter = [&](T * obj) 20401| 3.59M| { 20402| 3.59M| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 3.59M| }; 20404| 3.59M| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 3.59M| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 3.59M| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 3.59M| return obj.release(); 20408| 3.59M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2ISA_SA_TnNS3_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SH_EE5valueEiE4typeELi0EEEOT_: 20855| 8.21k| { 20856| 8.21k| JSONSerializer::to_json(*this, std::forward(val)); 20857| 8.21k| set_parents(); 20858| 8.21k| assert_invariant(); 20859| 8.21k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENS2_6vectorES8_blmdS6_S1_NSD_IhNS6_IhEEEEvEES8_EEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_: 6163| 8.21k| { 6164| 8.21k| ::nlohmann::to_json(j, std::forward(val)); 6165| 8.21k| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEESD_EEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6107| 8.21k| { 6108| 8.21k| return to_json(j, std::forward(val)); 6109| 8.21k| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRT_ONSH_8string_tE: 5959| 8.21k|{ 5960| 8.21k| external_constructor::construct(j, std::move(s)); 5961| 8.21k|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE3EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEEEvRT_ONSK_8string_tE: 5722| 8.21k| { 5723| 8.21k| j.m_data.m_value.destroy(j.m_data.m_type); 5724| 8.21k| j.m_data.m_type = value_t::string; 5725| 8.21k| j.m_data.m_value = std::move(s); 5726| 8.21k| j.assert_invariant(); 5727| 8.21k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10json_valueC2EOSA_: 20545| 8.21k| json_value(string_t&& value) : string(create(std::move(value))) {} _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createISA_JSA_EEEPT_DpOT0_: 20396| 8.21k| { 20397| 8.21k| AllocatorType alloc; 20398| 8.21k| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 8.21k| auto deleter = [&](T * obj) 20401| 8.21k| { 20402| 8.21k| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 8.21k| }; 20404| 8.21k| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 8.21k| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 8.21k| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 8.21k| return obj.release(); 20408| 8.21k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsERKSA_: 22771| 8.16k| { 22772| 8.16k| return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end(); ------------------ | Branch (22772:16): [True: 8.16k, False: 0] | Branch (22772:31): [True: 4.06k, False: 4.09k] ------------------ 22773| 8.16k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findERSI_: 20004| 191k| { 20005| 343k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20005:39): [True: 339k, False: 4.09k] ------------------ 20006| 339k| { 20007| 339k| if (m_compare(it->first, key)) ------------------ | Branch (20007:17): [True: 187k, False: 152k] ------------------ 20008| 187k| { 20009| 187k| return it; 20010| 187k| } 20011| 339k| } 20012| 4.09k| return Container::end(); 20013| 191k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEixESA_: 22161| 113k| { 22162| | // implicitly convert null value to an empty object 22163| 113k| if (is_null()) ------------------ | Branch (22163:13): [True: 0, False: 113k] ------------------ 22164| 0| { 22165| 0| m_data.m_type = value_t::object; 22166| 0| m_data.m_value.object = create(); 22167| 0| assert_invariant(); 22168| 0| } 22169| | 22170| | // operator[] only works for objects 22171| 113k| if (JSON_HEDLEY_LIKELY(is_object())) ------------------ | | 1690| 113k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 113k, False: 0] | | ------------------ ------------------ 22172| 113k| { 22173| 113k| auto result = m_data.m_value.object->emplace(std::move(key), nullptr); 22174| 113k| return set_parent(result.first->second); 22175| 113k| } 22176| | 22177| 0| JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 22178| 113k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7is_nullEv: 21357| 3.97M| { 21358| 3.97M| return m_data.m_type == value_t::null; 21359| 3.97M| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE7emplaceERSI_OSE_: 19772| 113k| { 19773| 231k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (19773:39): [True: 231k, False: 0] ------------------ 19774| 231k| { 19775| 231k| if (m_compare(it->first, key)) ------------------ | Branch (19775:17): [True: 113k, False: 118k] ------------------ 19776| 113k| { 19777| 113k| return {it, false}; 19778| 113k| } 19779| 231k| } 19780| 0| Container::emplace_back(key, std::forward(t)); 19781| 0| return {std::prev(this->end()), true}; 19782| 113k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10set_parentERSE_m: 20771| 113k| { 20772| |#if JSON_DIAGNOSTICS 20773| | if (old_capacity != detail::unknown_size()) 20774| | { 20775| | // see https://github.com/nlohmann/json/issues/2838 20776| | JSON_ASSERT(type() == value_t::array); 20777| | if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity)) 20778| | { 20779| | // capacity has changed: update all parents 20780| | set_parents(); 20781| | return j; 20782| | } 20783| | } 20784| | 20785| | // ordered_json uses a vector internally, so pointers could have 20786| | // been invalidated; see https://github.com/nlohmann/json/issues/2962 20787| |#ifdef JSON_HEDLEY_MSVC_VERSION 20788| |#pragma warning(push ) 20789| |#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr 20790| |#endif 20791| | if (detail::is_ordered_map::value) 20792| | { 20793| | set_parents(); 20794| | return j; 20795| | } 20796| |#ifdef JSON_HEDLEY_MSVC_VERSION 20797| |#pragma warning( pop ) 20798| |#endif 20799| | 20800| | j.m_parent = this; 20801| |#else 20802| 113k| static_cast(j); 20803| 113k| static_cast(old_capacity); 20804| 113k|#endif 20805| 113k| return j; 20806| 113k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4sizeEv: 22987| 192k| { 22988| 192k| switch (m_data.m_type) 22989| 192k| { 22990| 0| case value_t::null: ------------------ | Branch (22990:13): [True: 0, False: 192k] ------------------ 22991| 0| { 22992| | // null values are empty 22993| 0| return 0; 22994| 0| } 22995| | 22996| 192k| case value_t::array: ------------------ | Branch (22996:13): [True: 192k, False: 0] ------------------ 22997| 192k| { 22998| | // delegate call to array_t::size() 22999| 192k| return m_data.m_value.array->size(); 23000| 0| } 23001| | 23002| 0| case value_t::object: ------------------ | Branch (23002:13): [True: 0, False: 192k] ------------------ 23003| 0| { 23004| | // delegate call to object_t::size() 23005| 0| return m_data.m_value.object->size(); 23006| 0| } 23007| | 23008| 0| case value_t::string: ------------------ | Branch (23008:13): [True: 0, False: 192k] ------------------ 23009| 0| case value_t::boolean: ------------------ | Branch (23009:13): [True: 0, False: 192k] ------------------ 23010| 0| case value_t::number_integer: ------------------ | Branch (23010:13): [True: 0, False: 192k] ------------------ 23011| 0| case value_t::number_unsigned: ------------------ | Branch (23011:13): [True: 0, False: 192k] ------------------ 23012| 0| case value_t::number_float: ------------------ | Branch (23012:13): [True: 0, False: 192k] ------------------ 23013| 0| case value_t::binary: ------------------ | Branch (23013:13): [True: 0, False: 192k] ------------------ 23014| 0| case value_t::discarded: ------------------ | Branch (23014:13): [True: 0, False: 192k] ------------------ 23015| 0| default: ------------------ | Branch (23015:13): [True: 0, False: 192k] ------------------ 23016| 0| { 23017| | // all other types have size 1 23018| 0| return 1; 23019| 0| } 23020| 192k| } 23021| 192k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4dumpEicbNS0_6detail15error_handler_tE: 21317| 737k| { 21318| 737k| string_t result; 21319| 737k| serializer s(detail::output_adapter(result), indent_char, error_handler); 21320| | 21321| 737k| if (indent >= 0) ------------------ | Branch (21321:13): [True: 0, False: 737k] ------------------ 21322| 0| { 21323| 0| s.dump(*this, true, ensure_ascii, static_cast(indent)); 21324| 0| } 21325| 737k| else 21326| 737k| { 21327| 737k| s.dump(*this, false, ensure_ascii, 0); 21328| 737k| } 21329| | 21330| 737k| return result; 21331| 737k| } _ZN8nlohmann16json_abi_v3_12_06detail14output_adapterIcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2ERS9_: 15750| 737k| : oa(std::make_shared>(s)) {} _ZN8nlohmann16json_abi_v3_12_06detail21output_string_adapterIcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2ERS9_: 15718| 737k| : str(s) 15719| 737k| {} _ZN8nlohmann16json_abi_v3_12_06detail23output_adapter_protocolIcEC2Ev: 15651| 737k| output_adapter_protocol() = default; _ZN8nlohmann16json_abi_v3_12_06detail23output_adapter_protocolIcED2Ev: 15649| 737k| virtual ~output_adapter_protocol() = default; _ZN8nlohmann16json_abi_v3_12_06detail21output_string_adapterIcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE15write_characterEc: 15722| 12.4M| { 15723| 12.4M| str.push_back(c); 15724| 12.4M| } _ZN8nlohmann16json_abi_v3_12_06detail21output_string_adapterIcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE16write_charactersEPKcm: 15728| 8.95M| { 15729| 8.95M| str.append(s, length); 15730| 8.95M| } _ZN8nlohmann16json_abi_v3_12_06detail14output_adapterIcNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEcvNS3_10shared_ptrINS1_23output_adapter_protocolIcEEEEEv: 15753| 737k| { 15754| 737k| return oa; 15755| 737k| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEC2ENS5_10shared_ptrINS1_23output_adapter_protocolIcEEEEcNS1_15error_handler_tE: 18790| 737k| : o(std::move(s)) 18791| 737k| , loc(std::localeconv()) 18792| 737k| , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits::to_char_type(* (loc->thousands_sep))) ------------------ | Branch (18792:25): [True: 0, False: 737k] ------------------ 18793| 737k| , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits::to_char_type(* (loc->decimal_point))) ------------------ | Branch (18793:25): [True: 0, False: 737k] ------------------ 18794| 737k| , indent_char(ichar) 18795| 737k| , indent_string(512, indent_char) 18796| 737k| , error_handler(error_handler_) 18797| 737k| {} _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE4dumpERKSG_bbjj: 18833| 8.12M| { 18834| 8.12M| switch (val.m_data.m_type) 18835| 8.12M| { 18836| 1.01M| case value_t::object: ------------------ | Branch (18836:13): [True: 1.01M, False: 7.10M] ------------------ 18837| 1.01M| { 18838| 1.01M| if (val.m_data.m_value.object->empty()) ------------------ | Branch (18838:21): [True: 547, False: 1.01M] ------------------ 18839| 547| { 18840| 547| o->write_characters("{}", 2); 18841| 547| return; 18842| 547| } 18843| | 18844| 1.01M| if (pretty_print) ------------------ | Branch (18844:21): [True: 0, False: 1.01M] ------------------ 18845| 0| { 18846| 0| o->write_characters("{\n", 2); 18847| | 18848| | // variable to hold indentation for recursive calls 18849| 0| const auto new_indent = current_indent + indent_step; 18850| 0| if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) ------------------ | | 1691| 0|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 0] | | ------------------ ------------------ 18851| 0| { 18852| 0| indent_string.resize(indent_string.size() * 2, ' '); 18853| 0| } 18854| | 18855| | // first n-1 elements 18856| 0| auto i = val.m_data.m_value.object->cbegin(); 18857| 0| for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i) ------------------ | Branch (18857:47): [True: 0, False: 0] ------------------ 18858| 0| { 18859| 0| o->write_characters(indent_string.c_str(), new_indent); 18860| 0| o->write_character('\"'); 18861| 0| dump_escaped(i->first, ensure_ascii); 18862| 0| o->write_characters("\": ", 3); 18863| 0| dump(i->second, true, ensure_ascii, indent_step, new_indent); 18864| 0| o->write_characters(",\n", 2); 18865| 0| } 18866| | 18867| | // last element 18868| 0| JSON_ASSERT(i != val.m_data.m_value.object->cend()); ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 18869| 0| JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend()); ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 18870| 0| o->write_characters(indent_string.c_str(), new_indent); 18871| 0| o->write_character('\"'); 18872| 0| dump_escaped(i->first, ensure_ascii); 18873| 0| o->write_characters("\": ", 3); 18874| 0| dump(i->second, true, ensure_ascii, indent_step, new_indent); 18875| | 18876| 0| o->write_character('\n'); 18877| 0| o->write_characters(indent_string.c_str(), current_indent); 18878| 0| o->write_character('}'); 18879| 0| } 18880| 1.01M| else 18881| 1.01M| { 18882| 1.01M| o->write_character('{'); 18883| | 18884| | // first n-1 elements 18885| 1.01M| auto i = val.m_data.m_value.object->cbegin(); 18886| 1.12M| for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i) ------------------ | Branch (18886:47): [True: 109k, False: 1.01M] ------------------ 18887| 109k| { 18888| 109k| o->write_character('\"'); 18889| 109k| dump_escaped(i->first, ensure_ascii); 18890| 109k| o->write_characters("\":", 2); 18891| 109k| dump(i->second, false, ensure_ascii, indent_step, current_indent); 18892| 109k| o->write_character(','); 18893| 109k| } 18894| | 18895| | // last element 18896| 1.01M| JSON_ASSERT(i != val.m_data.m_value.object->cend()); ------------------ | | 2571| 1.01M| #define JSON_ASSERT(x) assert(x) ------------------ 18897| 1.01M| JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend()); ------------------ | | 2571| 1.01M| #define JSON_ASSERT(x) assert(x) ------------------ 18898| 1.01M| o->write_character('\"'); 18899| 1.01M| dump_escaped(i->first, ensure_ascii); 18900| 1.01M| o->write_characters("\":", 2); 18901| 1.01M| dump(i->second, false, ensure_ascii, indent_step, current_indent); 18902| | 18903| 1.01M| o->write_character('}'); 18904| 1.01M| } 18905| | 18906| 1.01M| return; 18907| 1.01M| } 18908| | 18909| 37.9k| case value_t::array: ------------------ | Branch (18909:13): [True: 37.9k, False: 8.08M] ------------------ 18910| 37.9k| { 18911| 37.9k| if (val.m_data.m_value.array->empty()) ------------------ | Branch (18911:21): [True: 4.64k, False: 33.3k] ------------------ 18912| 4.64k| { 18913| 4.64k| o->write_characters("[]", 2); 18914| 4.64k| return; 18915| 4.64k| } 18916| | 18917| 33.3k| if (pretty_print) ------------------ | Branch (18917:21): [True: 0, False: 33.3k] ------------------ 18918| 0| { 18919| 0| o->write_characters("[\n", 2); 18920| | 18921| | // variable to hold indentation for recursive calls 18922| 0| const auto new_indent = current_indent + indent_step; 18923| 0| if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) ------------------ | | 1691| 0|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 0] | | ------------------ ------------------ 18924| 0| { 18925| 0| indent_string.resize(indent_string.size() * 2, ' '); 18926| 0| } 18927| | 18928| | // first n-1 elements 18929| 0| for (auto i = val.m_data.m_value.array->cbegin(); 18930| 0| i != val.m_data.m_value.array->cend() - 1; ++i) ------------------ | Branch (18930:29): [True: 0, False: 0] ------------------ 18931| 0| { 18932| 0| o->write_characters(indent_string.c_str(), new_indent); 18933| 0| dump(*i, true, ensure_ascii, indent_step, new_indent); 18934| 0| o->write_characters(",\n", 2); 18935| 0| } 18936| | 18937| | // last element 18938| 0| JSON_ASSERT(!val.m_data.m_value.array->empty()); ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 18939| 0| o->write_characters(indent_string.c_str(), new_indent); 18940| 0| dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent); 18941| | 18942| 0| o->write_character('\n'); 18943| 0| o->write_characters(indent_string.c_str(), current_indent); 18944| 0| o->write_character(']'); 18945| 0| } 18946| 33.3k| else 18947| 33.3k| { 18948| 33.3k| o->write_character('['); 18949| | 18950| | // first n-1 elements 18951| 33.3k| for (auto i = val.m_data.m_value.array->cbegin(); 18952| 6.26M| i != val.m_data.m_value.array->cend() - 1; ++i) ------------------ | Branch (18952:29): [True: 6.22M, False: 33.3k] ------------------ 18953| 6.22M| { 18954| 6.22M| dump(*i, false, ensure_ascii, indent_step, current_indent); 18955| 6.22M| o->write_character(','); 18956| 6.22M| } 18957| | 18958| | // last element 18959| 33.3k| JSON_ASSERT(!val.m_data.m_value.array->empty()); ------------------ | | 2571| 33.3k| #define JSON_ASSERT(x) assert(x) ------------------ 18960| 33.3k| dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent); 18961| | 18962| 33.3k| o->write_character(']'); 18963| 33.3k| } 18964| | 18965| 33.3k| return; 18966| 37.9k| } 18967| | 18968| 1.19M| case value_t::string: ------------------ | Branch (18968:13): [True: 1.19M, False: 6.92M] ------------------ 18969| 1.19M| { 18970| 1.19M| o->write_character('\"'); 18971| 1.19M| dump_escaped(*val.m_data.m_value.string, ensure_ascii); 18972| 1.19M| o->write_character('\"'); 18973| 1.19M| return; 18974| 37.9k| } 18975| | 18976| 0| case value_t::binary: ------------------ | Branch (18976:13): [True: 0, False: 8.12M] ------------------ 18977| 0| { 18978| 0| if (pretty_print) ------------------ | Branch (18978:21): [True: 0, False: 0] ------------------ 18979| 0| { 18980| 0| o->write_characters("{\n", 2); 18981| | 18982| | // variable to hold indentation for recursive calls 18983| 0| const auto new_indent = current_indent + indent_step; 18984| 0| if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent)) ------------------ | | 1691| 0|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 0] | | ------------------ ------------------ 18985| 0| { 18986| 0| indent_string.resize(indent_string.size() * 2, ' '); 18987| 0| } 18988| | 18989| 0| o->write_characters(indent_string.c_str(), new_indent); 18990| | 18991| 0| o->write_characters("\"bytes\": [", 10); 18992| | 18993| 0| if (!val.m_data.m_value.binary->empty()) ------------------ | Branch (18993:25): [True: 0, False: 0] ------------------ 18994| 0| { 18995| 0| for (auto i = val.m_data.m_value.binary->cbegin(); 18996| 0| i != val.m_data.m_value.binary->cend() - 1; ++i) ------------------ | Branch (18996:33): [True: 0, False: 0] ------------------ 18997| 0| { 18998| 0| dump_integer(*i); 18999| 0| o->write_characters(", ", 2); 19000| 0| } 19001| 0| dump_integer(val.m_data.m_value.binary->back()); 19002| 0| } 19003| | 19004| 0| o->write_characters("],\n", 3); 19005| 0| o->write_characters(indent_string.c_str(), new_indent); 19006| | 19007| 0| o->write_characters("\"subtype\": ", 11); 19008| 0| if (val.m_data.m_value.binary->has_subtype()) ------------------ | Branch (19008:25): [True: 0, False: 0] ------------------ 19009| 0| { 19010| 0| dump_integer(val.m_data.m_value.binary->subtype()); 19011| 0| } 19012| 0| else 19013| 0| { 19014| 0| o->write_characters("null", 4); 19015| 0| } 19016| 0| o->write_character('\n'); 19017| 0| o->write_characters(indent_string.c_str(), current_indent); 19018| 0| o->write_character('}'); 19019| 0| } 19020| 0| else 19021| 0| { 19022| 0| o->write_characters("{\"bytes\":[", 10); 19023| | 19024| 0| if (!val.m_data.m_value.binary->empty()) ------------------ | Branch (19024:25): [True: 0, False: 0] ------------------ 19025| 0| { 19026| 0| for (auto i = val.m_data.m_value.binary->cbegin(); 19027| 0| i != val.m_data.m_value.binary->cend() - 1; ++i) ------------------ | Branch (19027:33): [True: 0, False: 0] ------------------ 19028| 0| { 19029| 0| dump_integer(*i); 19030| 0| o->write_character(','); 19031| 0| } 19032| 0| dump_integer(val.m_data.m_value.binary->back()); 19033| 0| } 19034| | 19035| 0| o->write_characters("],\"subtype\":", 12); 19036| 0| if (val.m_data.m_value.binary->has_subtype()) ------------------ | Branch (19036:25): [True: 0, False: 0] ------------------ 19037| 0| { 19038| 0| dump_integer(val.m_data.m_value.binary->subtype()); 19039| 0| o->write_character('}'); 19040| 0| } 19041| 0| else 19042| 0| { 19043| 0| o->write_characters("null}", 5); 19044| 0| } 19045| 0| } 19046| 0| return; 19047| 37.9k| } 19048| | 19049| 2.21k| case value_t::boolean: ------------------ | Branch (19049:13): [True: 2.21k, False: 8.12M] ------------------ 19050| 2.21k| { 19051| 2.21k| if (val.m_data.m_value.boolean) ------------------ | Branch (19051:21): [True: 2.02k, False: 196] ------------------ 19052| 2.02k| { 19053| 2.02k| o->write_characters("true", 4); 19054| 2.02k| } 19055| 196| else 19056| 196| { 19057| 196| o->write_characters("false", 5); 19058| 196| } 19059| 2.21k| return; 19060| 37.9k| } 19061| | 19062| 105k| case value_t::number_integer: ------------------ | Branch (19062:13): [True: 105k, False: 8.01M] ------------------ 19063| 105k| { 19064| 105k| dump_integer(val.m_data.m_value.number_integer); 19065| 105k| return; 19066| 37.9k| } 19067| | 19068| 5.38M| case value_t::number_unsigned: ------------------ | Branch (19068:13): [True: 5.38M, False: 2.74M] ------------------ 19069| 5.38M| { 19070| 5.38M| dump_integer(val.m_data.m_value.number_unsigned); 19071| 5.38M| return; 19072| 37.9k| } 19073| | 19074| 382k| case value_t::number_float: ------------------ | Branch (19074:13): [True: 382k, False: 7.74M] ------------------ 19075| 382k| { 19076| 382k| dump_float(val.m_data.m_value.number_float); 19077| 382k| return; 19078| 37.9k| } 19079| | 19080| 0| case value_t::discarded: ------------------ | Branch (19080:13): [True: 0, False: 8.12M] ------------------ 19081| 0| { 19082| 0| o->write_characters("", 11); 19083| 0| return; 19084| 37.9k| } 19085| | 19086| 1.72k| case value_t::null: ------------------ | Branch (19086:13): [True: 1.72k, False: 8.12M] ------------------ 19087| 1.72k| { 19088| 1.72k| o->write_characters("null", 4); 19089| 1.72k| return; 19090| 37.9k| } 19091| | 19092| 0| default: // LCOV_EXCL_LINE ------------------ | Branch (19092:13): [True: 0, False: 8.12M] ------------------ 19093| | JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 19094| 8.12M| } 19095| 8.12M| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE12dump_escapedERKSC_b: 19113| 2.32M| { 19114| 2.32M| std::uint32_t codepoint{}; 19115| 2.32M| std::uint8_t state = UTF8_ACCEPT; 19116| 2.32M| std::size_t bytes = 0; // number of bytes written to string_buffer 19117| | 19118| | // number of bytes written at the point of the last valid byte 19119| 2.32M| std::size_t bytes_after_last_accept = 0; 19120| 2.32M| std::size_t undumped_chars = 0; 19121| | 19122| 125M| for (std::size_t i = 0; i < s.size(); ++i) ------------------ | Branch (19122:33): [True: 123M, False: 2.32M] ------------------ 19123| 123M| { 19124| 123M| const auto byte = static_cast(s[i]); 19125| | 19126| 123M| switch (decode(state, codepoint, byte)) 19127| 123M| { 19128| 123M| case UTF8_ACCEPT: // decode found a new code point ------------------ | Branch (19128:17): [True: 123M, False: 125k] ------------------ 19129| 123M| { 19130| 123M| switch (codepoint) 19131| 123M| { 19132| 4.77k| case 0x08: // backspace ------------------ | Branch (19132:25): [True: 4.77k, False: 123M] ------------------ 19133| 4.77k| { 19134| 4.77k| string_buffer[bytes++] = '\\'; 19135| 4.77k| string_buffer[bytes++] = 'b'; 19136| 4.77k| break; 19137| 0| } 19138| | 19139| 2.99k| case 0x09: // horizontal tab ------------------ | Branch (19139:25): [True: 2.99k, False: 123M] ------------------ 19140| 2.99k| { 19141| 2.99k| string_buffer[bytes++] = '\\'; 19142| 2.99k| string_buffer[bytes++] = 't'; 19143| 2.99k| break; 19144| 0| } 19145| | 19146| 1.63k| case 0x0A: // newline ------------------ | Branch (19146:25): [True: 1.63k, False: 123M] ------------------ 19147| 1.63k| { 19148| 1.63k| string_buffer[bytes++] = '\\'; 19149| 1.63k| string_buffer[bytes++] = 'n'; 19150| 1.63k| break; 19151| 0| } 19152| | 19153| 1.61k| case 0x0C: // formfeed ------------------ | Branch (19153:25): [True: 1.61k, False: 123M] ------------------ 19154| 1.61k| { 19155| 1.61k| string_buffer[bytes++] = '\\'; 19156| 1.61k| string_buffer[bytes++] = 'f'; 19157| 1.61k| break; 19158| 0| } 19159| | 19160| 983| case 0x0D: // carriage return ------------------ | Branch (19160:25): [True: 983, False: 123M] ------------------ 19161| 983| { 19162| 983| string_buffer[bytes++] = '\\'; 19163| 983| string_buffer[bytes++] = 'r'; 19164| 983| break; 19165| 0| } 19166| | 19167| 1.87k| case 0x22: // quotation mark ------------------ | Branch (19167:25): [True: 1.87k, False: 123M] ------------------ 19168| 1.87k| { 19169| 1.87k| string_buffer[bytes++] = '\\'; 19170| 1.87k| string_buffer[bytes++] = '\"'; 19171| 1.87k| break; 19172| 0| } 19173| | 19174| 13.2k| case 0x5C: // reverse solidus ------------------ | Branch (19174:25): [True: 13.2k, False: 123M] ------------------ 19175| 13.2k| { 19176| 13.2k| string_buffer[bytes++] = '\\'; 19177| 13.2k| string_buffer[bytes++] = '\\'; 19178| 13.2k| break; 19179| 0| } 19180| | 19181| 123M| default: ------------------ | Branch (19181:25): [True: 123M, False: 27.1k] ------------------ 19182| 123M| { 19183| | // escape control characters (0x00..0x1F) or, if 19184| | // ensure_ascii parameter is used, non-ASCII characters 19185| 123M| if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F))) ------------------ | Branch (19185:33): [True: 2.92k, False: 123M] | Branch (19185:57): [True: 0, False: 123M] | Branch (19185:73): [True: 0, False: 0] ------------------ 19186| 2.92k| { 19187| 2.92k| if (codepoint <= 0xFFFF) ------------------ | Branch (19187:37): [True: 2.92k, False: 0] ------------------ 19188| 2.92k| { 19189| | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg) 19190| 2.92k| static_cast((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x", 19191| 2.92k| static_cast(codepoint))); 19192| 2.92k| bytes += 6; 19193| 2.92k| } 19194| 0| else 19195| 0| { 19196| | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg) 19197| 0| static_cast((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x", 19198| 0| static_cast(0xD7C0u + (codepoint >> 10u)), 19199| 0| static_cast(0xDC00u + (codepoint & 0x3FFu)))); 19200| 0| bytes += 12; 19201| 0| } 19202| 2.92k| } 19203| 123M| else 19204| 123M| { 19205| | // copy byte to buffer (all previous bytes 19206| | // been copied have in default case above) 19207| 123M| string_buffer[bytes++] = s[i]; 19208| 123M| } 19209| 123M| break; 19210| 0| } 19211| 123M| } 19212| | 19213| | // write buffer and reset index; there must be 13 bytes 19214| | // left, as this is the maximal number of bytes to be 19215| | // written ("\uxxxx\uxxxx\0") for one code point 19216| 123M| if (string_buffer.size() - bytes < 13) ------------------ | Branch (19216:25): [True: 122k, False: 123M] ------------------ 19217| 122k| { 19218| 122k| o->write_characters(string_buffer.data(), bytes); 19219| 122k| bytes = 0; 19220| 122k| } 19221| | 19222| | // remember the byte position of this accept 19223| 123M| bytes_after_last_accept = bytes; 19224| 123M| undumped_chars = 0; 19225| 123M| break; 19226| 123M| } 19227| | 19228| 0| case UTF8_REJECT: // decode found invalid UTF-8 byte ------------------ | Branch (19228:17): [True: 0, False: 123M] ------------------ 19229| 0| { 19230| 0| switch (error_handler) 19231| 0| { 19232| 0| case error_handler_t::strict: ------------------ | Branch (19232:25): [True: 0, False: 0] ------------------ 19233| 0| { 19234| 0| JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 19235| 0| } 19236| | 19237| 0| case error_handler_t::ignore: ------------------ | Branch (19237:25): [True: 0, False: 0] ------------------ 19238| 0| case error_handler_t::replace: ------------------ | Branch (19238:25): [True: 0, False: 0] ------------------ 19239| 0| { 19240| | // in case we saw this character the first time, we 19241| | // would like to read it again, because the byte 19242| | // may be OK for itself, but just not OK for the 19243| | // previous sequence 19244| 0| if (undumped_chars > 0) ------------------ | Branch (19244:33): [True: 0, False: 0] ------------------ 19245| 0| { 19246| 0| --i; 19247| 0| } 19248| | 19249| | // reset length buffer to the last accepted index; 19250| | // thus removing/ignoring the invalid characters 19251| 0| bytes = bytes_after_last_accept; 19252| | 19253| 0| if (error_handler == error_handler_t::replace) ------------------ | Branch (19253:33): [True: 0, False: 0] ------------------ 19254| 0| { 19255| | // add a replacement character 19256| 0| if (ensure_ascii) ------------------ | Branch (19256:37): [True: 0, False: 0] ------------------ 19257| 0| { 19258| 0| string_buffer[bytes++] = '\\'; 19259| 0| string_buffer[bytes++] = 'u'; 19260| 0| string_buffer[bytes++] = 'f'; 19261| 0| string_buffer[bytes++] = 'f'; 19262| 0| string_buffer[bytes++] = 'f'; 19263| 0| string_buffer[bytes++] = 'd'; 19264| 0| } 19265| 0| else 19266| 0| { 19267| 0| string_buffer[bytes++] = detail::binary_writer::to_char_type('\xEF'); 19268| 0| string_buffer[bytes++] = detail::binary_writer::to_char_type('\xBF'); 19269| 0| string_buffer[bytes++] = detail::binary_writer::to_char_type('\xBD'); 19270| 0| } 19271| | 19272| | // write buffer and reset index; there must be 13 bytes 19273| | // left, as this is the maximal number of bytes to be 19274| | // written ("\uxxxx\uxxxx\0") for one code point 19275| 0| if (string_buffer.size() - bytes < 13) ------------------ | Branch (19275:37): [True: 0, False: 0] ------------------ 19276| 0| { 19277| 0| o->write_characters(string_buffer.data(), bytes); 19278| 0| bytes = 0; 19279| 0| } 19280| | 19281| 0| bytes_after_last_accept = bytes; 19282| 0| } 19283| | 19284| 0| undumped_chars = 0; 19285| | 19286| | // continue processing the string 19287| 0| state = UTF8_ACCEPT; 19288| 0| break; 19289| 0| } 19290| | 19291| 0| default: // LCOV_EXCL_LINE ------------------ | Branch (19291:25): [True: 0, False: 0] ------------------ 19292| 0| JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 19293| 0| } 19294| 0| break; 19295| 0| } 19296| | 19297| 125k| default: // decode found yet incomplete multi-byte code point ------------------ | Branch (19297:17): [True: 125k, False: 123M] ------------------ 19298| 125k| { 19299| 125k| if (!ensure_ascii) ------------------ | Branch (19299:25): [True: 125k, False: 0] ------------------ 19300| 125k| { 19301| | // code point will not be escaped - copy byte to buffer 19302| 125k| string_buffer[bytes++] = s[i]; 19303| 125k| } 19304| 125k| ++undumped_chars; 19305| 125k| break; 19306| 0| } 19307| 123M| } 19308| 123M| } 19309| | 19310| | // we finished processing the string 19311| 2.32M| if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT)) ------------------ | | 1690| 2.32M|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 2.32M, False: 0] | | ------------------ ------------------ 19312| 2.32M| { 19313| | // write buffer 19314| 2.32M| if (bytes > 0) ------------------ | Branch (19314:17): [True: 2.31M, False: 6.75k] ------------------ 19315| 2.31M| { 19316| 2.31M| o->write_characters(string_buffer.data(), bytes); 19317| 2.31M| } 19318| 2.32M| } 19319| 0| else 19320| 0| { 19321| | // we finish reading, but do not accept: string was incomplete 19322| 0| switch (error_handler) 19323| 0| { 19324| 0| case error_handler_t::strict: ------------------ | Branch (19324:17): [True: 0, False: 0] ------------------ 19325| 0| { 19326| 0| JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast(s.back() | 0))), nullptr)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 19327| 0| } 19328| | 19329| 0| case error_handler_t::ignore: ------------------ | Branch (19329:17): [True: 0, False: 0] ------------------ 19330| 0| { 19331| | // write all accepted bytes 19332| 0| o->write_characters(string_buffer.data(), bytes_after_last_accept); 19333| 0| break; 19334| 0| } 19335| | 19336| 0| case error_handler_t::replace: ------------------ | Branch (19336:17): [True: 0, False: 0] ------------------ 19337| 0| { 19338| | // write all accepted bytes 19339| 0| o->write_characters(string_buffer.data(), bytes_after_last_accept); 19340| | // add a replacement character 19341| 0| if (ensure_ascii) ------------------ | Branch (19341:25): [True: 0, False: 0] ------------------ 19342| 0| { 19343| 0| o->write_characters("\\ufffd", 6); 19344| 0| } 19345| 0| else 19346| 0| { 19347| 0| o->write_characters("\xEF\xBF\xBD", 3); 19348| 0| } 19349| 0| break; 19350| 0| } 19351| | 19352| 0| default: // LCOV_EXCL_LINE ------------------ | Branch (19352:17): [True: 0, False: 0] ------------------ 19353| | JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE ------------------ | | 2571| 0| #define JSON_ASSERT(x) assert(x) ------------------ 19354| 0| } 19355| 0| } 19356| 2.32M| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE6decodeERhRjh: 19622| 123M| { 19623| 123M| static const std::array utf8d = 19624| 123M| { 19625| 123M| { 19626| 123M| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F 19627| 123M| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F 19628| 123M| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F 19629| 123M| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F 19630| 123M| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F 19631| 123M| 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF 19632| 123M| 8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF 19633| 123M| 0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF 19634| 123M| 0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF 19635| 123M| 0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0 19636| 123M| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2 19637| 123M| 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4 19638| 123M| 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6 19639| 123M| 1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8 19640| 123M| } 19641| 123M| }; 19642| | 19643| 123M| JSON_ASSERT(byte < utf8d.size()); ------------------ | | 2571| 123M| #define JSON_ASSERT(x) assert(x) ------------------ 19644| 123M| const std::uint8_t type = utf8d[byte]; 19645| | 19646| 123M| codep = (state != UTF8_ACCEPT) ------------------ | Branch (19646:17): [True: 125k, False: 123M] ------------------ 19647| 123M| ? (byte & 0x3fu) | (codep << 6u) 19648| 123M| : (0xFFu >> type) & (byte); 19649| | 19650| 123M| const std::size_t index = 256u + (static_cast(state) * 16u) + static_cast(type); 19651| | JSON_ASSERT(index < utf8d.size()); ------------------ | | 2571| 123M| #define JSON_ASSERT(x) assert(x) ------------------ 19652| 123M| state = utf8d[index]; 19653| 123M| return state; 19654| 123M| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE11remove_signEl: 19677| 99.3k| { 19678| | JSON_ASSERT(x < 0 && x < (std::numeric_limits::max)()); // NOLINT(misc-redundant-expression) ------------------ | | 2571| 99.3k| #define JSON_ASSERT(x) assert(x) ------------------ 19679| 99.3k| return static_cast(-(x + 1)) + 1; 19680| 99.3k| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE12count_digitsEm: 19368| 5.00M| { 19369| 5.00M| unsigned int n_digits = 1; 19370| 5.00M| for (;;) 19371| 5.16M| { 19372| 5.16M| if (x < 10) ------------------ | Branch (19372:17): [True: 4.64M, False: 527k] ------------------ 19373| 4.64M| { 19374| 4.64M| return n_digits; 19375| 4.64M| } 19376| 527k| if (x < 100) ------------------ | Branch (19376:17): [True: 157k, False: 370k] ------------------ 19377| 157k| { 19378| 157k| return n_digits + 1; 19379| 157k| } 19380| 370k| if (x < 1000) ------------------ | Branch (19380:17): [True: 180k, False: 189k] ------------------ 19381| 180k| { 19382| 180k| return n_digits + 2; 19383| 180k| } 19384| 189k| if (x < 10000) ------------------ | Branch (19384:17): [True: 21.7k, False: 167k] ------------------ 19385| 21.7k| { 19386| 21.7k| return n_digits + 3; 19387| 21.7k| } 19388| 167k| x = x / 10000u; 19389| 167k| n_digits += 4; 19390| 167k| } 19391| 5.00M| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE12dump_integerImTnNS5_9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISK_mEE5valuesr3std7is_sameISK_lEE5valuesr3std7is_sameISK_hEE5valueEiE4typeELi0EEEvSK_: 19436| 5.38M| { 19437| 5.38M| static constexpr std::array, 100> digits_to_99 19438| 5.38M| { 19439| 5.38M| { 19440| 5.38M| {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}}, 19441| 5.38M| {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}}, 19442| 5.38M| {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}}, 19443| 5.38M| {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}}, 19444| 5.38M| {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}}, 19445| 5.38M| {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}}, 19446| 5.38M| {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}}, 19447| 5.38M| {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}}, 19448| 5.38M| {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}}, 19449| 5.38M| {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}}, 19450| 5.38M| } 19451| 5.38M| }; 19452| | 19453| | // special case for "0" 19454| 5.38M| if (x == 0) ------------------ | Branch (19454:13): [True: 481k, False: 4.90M] ------------------ 19455| 481k| { 19456| 481k| o->write_character('0'); 19457| 481k| return; 19458| 481k| } 19459| | 19460| | // use a pointer to fill the buffer 19461| 4.90M| auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg) 19462| | 19463| 4.90M| number_unsigned_t abs_value; 19464| | 19465| 4.90M| unsigned int n_chars{}; 19466| | 19467| 4.90M| if (is_negative_number(x)) ------------------ | Branch (19467:13): [True: 0, False: 4.90M] ------------------ 19468| 0| { 19469| 0| *buffer_ptr = '-'; 19470| 0| abs_value = remove_sign(static_cast(x)); 19471| | 19472| | // account one more byte for the minus sign 19473| 0| n_chars = 1 + count_digits(abs_value); 19474| 0| } 19475| 4.90M| else 19476| 4.90M| { 19477| 4.90M| abs_value = static_cast(x); 19478| 4.90M| n_chars = count_digits(abs_value); 19479| 4.90M| } 19480| | 19481| | // spare 1 byte for '\0' 19482| 4.90M| JSON_ASSERT(n_chars < number_buffer.size() - 1); ------------------ | | 2571| 4.90M| #define JSON_ASSERT(x) assert(x) ------------------ 19483| | 19484| | // jump to the end to generate the string from backward, 19485| | // so we later avoid reversing the result 19486| 4.90M| buffer_ptr += n_chars; 19487| | 19488| | // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu 19489| | // See: https://www.youtube.com/watch?v=o4-CwDo2zpg 19490| 5.30M| while (abs_value >= 100) ------------------ | Branch (19490:16): [True: 402k, False: 4.90M] ------------------ 19491| 402k| { 19492| 402k| const auto digits_index = static_cast((abs_value % 100)); 19493| 402k| abs_value /= 100; 19494| 402k| *(--buffer_ptr) = digits_to_99[digits_index][1]; 19495| 402k| *(--buffer_ptr) = digits_to_99[digits_index][0]; 19496| 402k| } 19497| | 19498| 4.90M| if (abs_value >= 10) ------------------ | Branch (19498:13): [True: 146k, False: 4.75M] ------------------ 19499| 146k| { 19500| 146k| const auto digits_index = static_cast(abs_value); 19501| 146k| *(--buffer_ptr) = digits_to_99[digits_index][1]; 19502| 146k| *(--buffer_ptr) = digits_to_99[digits_index][0]; 19503| 146k| } 19504| 4.75M| else 19505| 4.75M| { 19506| 4.75M| *(--buffer_ptr) = static_cast('0' + abs_value); 19507| 4.75M| } 19508| | 19509| 4.90M| o->write_characters(number_buffer.data(), n_chars); 19510| 4.90M| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE18is_negative_numberImTnNS5_9enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeELi0EEEbSK_: 19416| 4.90M| { 19417| 4.90M| return false; 19418| 4.90M| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE12dump_integerIlTnNS5_9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISK_mEE5valuesr3std7is_sameISK_lEE5valuesr3std7is_sameISK_hEE5valueEiE4typeELi0EEEvSK_: 19436| 105k| { 19437| 105k| static constexpr std::array, 100> digits_to_99 19438| 105k| { 19439| 105k| { 19440| 105k| {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}}, 19441| 105k| {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}}, 19442| 105k| {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}}, 19443| 105k| {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}}, 19444| 105k| {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}}, 19445| 105k| {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}}, 19446| 105k| {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}}, 19447| 105k| {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}}, 19448| 105k| {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}}, 19449| 105k| {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}}, 19450| 105k| } 19451| 105k| }; 19452| | 19453| | // special case for "0" 19454| 105k| if (x == 0) ------------------ | Branch (19454:13): [True: 6.24k, False: 99.3k] ------------------ 19455| 6.24k| { 19456| 6.24k| o->write_character('0'); 19457| 6.24k| return; 19458| 6.24k| } 19459| | 19460| | // use a pointer to fill the buffer 19461| 99.3k| auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg) 19462| | 19463| 99.3k| number_unsigned_t abs_value; 19464| | 19465| 99.3k| unsigned int n_chars{}; 19466| | 19467| 99.3k| if (is_negative_number(x)) ------------------ | Branch (19467:13): [True: 99.3k, False: 0] ------------------ 19468| 99.3k| { 19469| 99.3k| *buffer_ptr = '-'; 19470| 99.3k| abs_value = remove_sign(static_cast(x)); 19471| | 19472| | // account one more byte for the minus sign 19473| 99.3k| n_chars = 1 + count_digits(abs_value); 19474| 99.3k| } 19475| 0| else 19476| 0| { 19477| 0| abs_value = static_cast(x); 19478| 0| n_chars = count_digits(abs_value); 19479| 0| } 19480| | 19481| | // spare 1 byte for '\0' 19482| 99.3k| JSON_ASSERT(n_chars < number_buffer.size() - 1); ------------------ | | 2571| 99.3k| #define JSON_ASSERT(x) assert(x) ------------------ 19483| | 19484| | // jump to the end to generate the string from backward, 19485| | // so we later avoid reversing the result 19486| 99.3k| buffer_ptr += n_chars; 19487| | 19488| | // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu 19489| | // See: https://www.youtube.com/watch?v=o4-CwDo2zpg 19490| 234k| while (abs_value >= 100) ------------------ | Branch (19490:16): [True: 135k, False: 99.3k] ------------------ 19491| 135k| { 19492| 135k| const auto digits_index = static_cast((abs_value % 100)); 19493| 135k| abs_value /= 100; 19494| 135k| *(--buffer_ptr) = digits_to_99[digits_index][1]; 19495| 135k| *(--buffer_ptr) = digits_to_99[digits_index][0]; 19496| 135k| } 19497| | 19498| 99.3k| if (abs_value >= 10) ------------------ | Branch (19498:13): [True: 32.7k, False: 66.5k] ------------------ 19499| 32.7k| { 19500| 32.7k| const auto digits_index = static_cast(abs_value); 19501| 32.7k| *(--buffer_ptr) = digits_to_99[digits_index][1]; 19502| 32.7k| *(--buffer_ptr) = digits_to_99[digits_index][0]; 19503| 32.7k| } 19504| 66.5k| else 19505| 66.5k| { 19506| 66.5k| *(--buffer_ptr) = static_cast('0' + abs_value); 19507| 66.5k| } 19508| | 19509| 99.3k| o->write_characters(number_buffer.data(), n_chars); 19510| 99.3k| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE18is_negative_numberIlTnNS5_9enable_ifIXsr9is_signedIT_EE5valueEiE4typeELi0EEEbSK_: 19410| 99.3k| { 19411| 99.3k| return x < 0; 19412| 99.3k| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE10dump_floatEd: 19521| 382k| { 19522| | // NaN / inf 19523| 382k| if (!std::isfinite(x)) ------------------ | Branch (19523:13): [True: 0, False: 382k] ------------------ 19524| 0| { 19525| 0| o->write_characters("null", 4); 19526| 0| return; 19527| 0| } 19528| | 19529| | // If number_float_t is an IEEE-754 single or double precision number, 19530| | // use the Grisu2 algorithm to produce short numbers which are 19531| | // guaranteed to round-trip, using strtof and strtod, resp. 19532| | // 19533| | // NB: The test below works if == . 19534| 382k| static constexpr bool is_ieee_single_or_double 19535| 382k| = (std::numeric_limits::is_iec559 && std::numeric_limits::digits == 24 && std::numeric_limits::max_exponent == 128) || ------------------ | Branch (19535:16): [True: 0, Folded] | Branch (19535:66): [Folded, False: 0] | Branch (19535:119): [Folded, False: 0] ------------------ 19536| 0| (std::numeric_limits::is_iec559 && std::numeric_limits::digits == 53 && std::numeric_limits::max_exponent == 1024); ------------------ | Branch (19536:16): [True: 0, Folded] | Branch (19536:66): [True: 0, Folded] | Branch (19536:119): [True: 0, Folded] ------------------ 19537| | 19538| 382k| dump_float(x, std::integral_constant()); 19539| 382k| } _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE10dump_floatEdNS5_17integral_constantIbLb1EEE: 19542| 382k| { 19543| 382k| auto* begin = number_buffer.data(); 19544| 382k| auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x); 19545| | 19546| 382k| o->write_characters(begin, static_cast(end - begin)); 19547| 382k| } _ZN8nlohmann16json_abi_v3_12_06detail8to_charsIdEEPcS3_PKcT_: 18686| 382k|{ 18687| 382k| static_cast(last); // maybe unused - fix warning 18688| 382k| JSON_ASSERT(std::isfinite(value)); ------------------ | | 2571| 382k| #define JSON_ASSERT(x) assert(x) ------------------ 18689| | 18690| | // Use signbit(value) instead of (value < 0) since signbit works for -0. 18691| 382k| if (std::signbit(value)) ------------------ | Branch (18691:9): [True: 13.4k, False: 368k] ------------------ 18692| 13.4k| { 18693| 13.4k| value = -value; 18694| 13.4k| *first++ = '-'; 18695| 13.4k| } 18696| | 18697| 382k|#ifdef __GNUC__ 18698| 382k|#pragma GCC diagnostic push 18699| 382k|#pragma GCC diagnostic ignored "-Wfloat-equal" 18700| 382k|#endif 18701| 382k| if (value == 0) // +-0 ------------------ | Branch (18701:9): [True: 141k, False: 240k] ------------------ 18702| 141k| { 18703| 141k| *first++ = '0'; 18704| | // Make it look like a floating-point number (#362, #378) 18705| 141k| *first++ = '.'; 18706| 141k| *first++ = '0'; 18707| 141k| return first; 18708| 141k| } 18709| 240k|#ifdef __GNUC__ 18710| 240k|#pragma GCC diagnostic pop 18711| 240k|#endif 18712| | 18713| 240k| JSON_ASSERT(last - first >= std::numeric_limits::max_digits10); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18714| | 18715| | // Compute v = buffer * 10^decimal_exponent. 18716| | // The decimal digits are stored in the buffer, which needs to be interpreted 18717| | // as an unsigned decimal integer. 18718| | // len is the length of the buffer, i.e. the number of decimal digits. 18719| 240k| int len = 0; 18720| 240k| int decimal_exponent = 0; 18721| 240k| dtoa_impl::grisu2(first, len, decimal_exponent, value); 18722| | 18723| 240k| JSON_ASSERT(len <= std::numeric_limits::max_digits10); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18724| | 18725| | // Format the buffer like printf("%.*g", prec, value) 18726| 240k| constexpr int kMinExp = -4; 18727| | // Use digits10 here to increase compatibility with version 2. 18728| 240k| constexpr int kMaxExp = std::numeric_limits::digits10; 18729| | 18730| 240k| JSON_ASSERT(last - first >= kMaxExp + 2); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18731| 240k| JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits::max_digits10); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18732| 240k| JSON_ASSERT(last - first >= std::numeric_limits::max_digits10 + 6); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18733| | 18734| 240k| return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp); 18735| 382k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl6grisu2IdEEvPcRiS5_T_: 18509| 240k|{ 18510| 240k| static_assert(diyfp::kPrecision >= std::numeric_limits::digits + 3, 18511| 240k| "internal error: not enough precision"); 18512| | 18513| 240k| JSON_ASSERT(std::isfinite(value)); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18514| 240k| JSON_ASSERT(value > 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 18515| | 18516| | // If the neighbors (and boundaries) of 'value' are always computed for double-precision 18517| | // numbers, all float's can be recovered using strtod (and strtof). However, the resulting 18518| | // decimal representations are not exactly "short". 18519| | // 18520| | // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars) 18521| | // says "value is converted to a string as if by std::sprintf in the default ("C") locale" 18522| | // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars' 18523| | // does. 18524| | // On the other hand, the documentation for 'std::to_chars' requires that "parsing the 18525| | // representation using the corresponding std::from_chars function recovers value exactly". That 18526| | // indicates that single precision floating-point numbers should be recovered using 18527| | // 'std::strtof'. 18528| | // 18529| | // NB: If the neighbors are computed for single-precision numbers, there is a single float 18530| | // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision 18531| | // value is off by 1 ulp. 18532| |#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if) 18533| | const boundaries w = compute_boundaries(static_cast(value)); 18534| |#else 18535| 240k| const boundaries w = compute_boundaries(value); 18536| 240k|#endif 18537| | 18538| 240k| grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus); 18539| 240k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_: 17810| 240k|{ 17811| 240k| JSON_ASSERT(std::isfinite(value)); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 17812| 240k| JSON_ASSERT(value > 0); ------------------ | | 2571| 240k| #define JSON_ASSERT(x) assert(x) ------------------ 17813| | 17814| | // Convert the IEEE representation into a diyfp. 17815| | // 17816| | // If v is denormal: 17817| | // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1)) 17818| | // If v is normalized: 17819| | // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1)) 17820| | 17821| 240k| static_assert(std::numeric_limits::is_iec559, 17822| 240k| "internal error: dtoa_short requires an IEEE-754 floating-point implementation"); 17823| | 17824| 240k| constexpr int kPrecision = std::numeric_limits::digits; // = p (includes the hidden bit) 17825| 240k| constexpr int kBias = std::numeric_limits::max_exponent - 1 + (kPrecision - 1); 17826| 240k| constexpr int kMinExp = 1 - kBias; 17827| 240k| constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1) 17828| | 17829| 240k| using bits_type = typename std::conditional::type; 17830| | 17831| 240k| const auto bits = static_cast(reinterpret_bits(value)); 17832| 240k| const std::uint64_t E = bits >> (kPrecision - 1); 17833| 240k| const std::uint64_t F = bits & (kHiddenBit - 1); 17834| | 17835| 240k| const bool is_denormal = E == 0; 17836| 240k| const diyfp v = is_denormal ------------------ | Branch (17836:21): [True: 806, False: 240k] ------------------ 17837| 240k| ? diyfp(F, kMinExp) 17838| 240k| : diyfp(F + kHiddenBit, static_cast(E) - kBias); 17839| | 17840| | // Compute the boundaries m- and m+ of the floating-point value 17841| | // v = f * 2^e. 17842| | // 17843| | // Determine v- and v+, the floating-point predecessor and successor if v, 17844| | // respectively. 17845| | // 17846| | // v- = v - 2^e if f != 2^(p-1) or e == e_min (A) 17847| | // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B) 17848| | // 17849| | // v+ = v + 2^e 17850| | // 17851| | // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_ 17852| | // between m- and m+ round to v, regardless of how the input rounding 17853| | // algorithm breaks ties. 17854| | // 17855| | // ---+-------------+-------------+-------------+-------------+--- (A) 17856| | // v- m- v m+ v+ 17857| | // 17858| | // -----------------+------+------+-------------+-------------+--- (B) 17859| | // v- m- v m+ v+ 17860| | 17861| 240k| const bool lower_boundary_is_closer = F == 0 && E > 1; ------------------ | Branch (17861:43): [True: 9.63k, False: 231k] | Branch (17861:53): [True: 9.62k, False: 1] ------------------ 17862| 240k| const diyfp m_plus = diyfp((2 * v.f) + 1, v.e - 1); 17863| 240k| const diyfp m_minus = lower_boundary_is_closer ------------------ | Branch (17863:27): [True: 9.62k, False: 231k] ------------------ 17864| 240k| ? diyfp((4 * v.f) - 1, v.e - 2) // (B) 17865| 240k| : diyfp((2 * v.f) - 1, v.e - 1); // (A) 17866| | 17867| | // Determine the normalized w+ = m+. 17868| 240k| const diyfp w_plus = diyfp::normalize(m_plus); 17869| | 17870| | // Determine w- = m- such that e_(w-) = e_(w+). 17871| 240k| const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e); 17872| | 17873| 240k| return {diyfp::normalize(v), w_minus, w_plus}; 17874| 240k|} _ZN8nlohmann16json_abi_v3_12_06detail9dtoa_impl16reinterpret_bitsImdEET_T0_: 17669| 240k|{ 17670| 240k| static_assert(sizeof(Target) == sizeof(Source), "size mismatch"); 17671| | 17672| 240k| Target target; 17673| 240k| std::memcpy(&target, &source, sizeof(Source)); 17674| 240k| return target; 17675| 240k|} _ZN8nlohmann16json_abi_v3_12_06detail10serializerINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEED2Ev: 18804| 737k| ~serializer() = default; _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEixEm: 22102| 183k| { 22103| | // implicitly convert null value to an empty array 22104| 183k| if (is_null()) ------------------ | Branch (22104:13): [True: 0, False: 183k] ------------------ 22105| 0| { 22106| 0| m_data.m_type = value_t::array; 22107| 0| m_data.m_value.array = create(); 22108| 0| assert_invariant(); 22109| 0| } 22110| | 22111| | // operator[] only works for arrays 22112| 183k| if (JSON_HEDLEY_LIKELY(is_array())) ------------------ | | 1690| 183k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 183k, False: 0] | | ------------------ ------------------ 22113| 183k| { 22114| | // fill up array with null values if given idx is outside range 22115| 183k| if (idx >= m_data.m_value.array->size()) ------------------ | Branch (22115:17): [True: 0, False: 183k] ------------------ 22116| 0| { 22117| |#if JSON_DIAGNOSTICS 22118| | // remember array size & capacity before resizing 22119| | const auto old_size = m_data.m_value.array->size(); 22120| | const auto old_capacity = m_data.m_value.array->capacity(); 22121| |#endif 22122| 0| m_data.m_value.array->resize(idx + 1); 22123| | 22124| |#if JSON_DIAGNOSTICS 22125| | if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity)) 22126| | { 22127| | // capacity has changed: update all parents 22128| | set_parents(); 22129| | } 22130| | else 22131| | { 22132| | // set parent for values added above 22133| | set_parents(begin() + static_cast(old_size), static_cast(idx + 1 - old_size)); 22134| | } 22135| |#endif 22136| 0| assert_invariant(); 22137| 0| } 22138| | 22139| 183k| return m_data.m_value.array->operator[](idx); 22140| 183k| } 22141| | 22142| 0| JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 22143| 183k| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE5itemsEv: 22925| 41.3k| { 22926| 41.3k| return iteration_proxy(*this); 22927| 41.3k| } _ZN8nlohmann16json_abi_v3_12_06detail15iteration_proxyINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEC2ERSH_: 5593| 41.3k| : container(&cont) {} _ZNK8nlohmann16json_abi_v3_12_06detail15iteration_proxyINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE5beginEv: 5603| 41.3k| { 5604| 41.3k| return iteration_proxy_value(container->begin()); 5605| 41.3k| } _ZN8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEC2ESI_m: 5488| 82.6k| : anchor(std::move(it)) 5489| 82.6k| , array_index(array_index_) 5490| 82.6k| {} _ZNK8nlohmann16json_abi_v3_12_06detail15iteration_proxyINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE3endEv: 5609| 41.3k| { 5610| 41.3k| return iteration_proxy_value(container->end()); 5611| 41.3k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEneERKSJ_: 5534| 101k| { 5535| 101k| return anchor != o.anchor; 5536| 101k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEdeEv: 5505| 60.6k| { 5506| 60.6k| return *this; 5507| 60.6k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE5valueEv: 5576| 60.6k| { 5577| 60.6k| return anchor.value(); 5578| 60.6k| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE5valueEv: 14306| 60.6k| { 14307| 60.6k| return operator*(); 14308| 60.6k| } _ZN8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEppEv: 5511| 60.6k| { 5512| 60.6k| ++anchor; 5513| 60.6k| ++array_index; 5514| | 5515| 60.6k| return *this; 5516| 60.6k| } _ZN8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEED2Ev: 5501| 82.6k| ~iteration_proxy_value() = default; _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEixIKcEERKSE_PT_: 22205| 183k| { 22206| 183k| return operator[](typename object_t::key_type(key)); 22207| 183k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEixERKSA_: 22183| 183k| { 22184| | // const operator[] only works for objects 22185| 183k| if (JSON_HEDLEY_LIKELY(is_object())) ------------------ | | 1690| 183k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 183k, False: 0] | | ------------------ ------------------ 22186| 183k| { 22187| 183k| auto it = m_data.m_value.object->find(key); 22188| 183k| JSON_ASSERT(it != m_data.m_value.object->end()); ------------------ | | 2571| 183k| #define JSON_ASSERT(x) assert(x) ------------------ 22189| 183k| return it->second; 22190| 183k| } 22191| | 22192| 0| JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 22193| 183k| } _ZN8nlohmann16json_abi_v3_12_0eqIPKcTnNSt3__19enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapENS4_6vectorENS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEblmdSF_NS0_14adl_serializerENSB_IhNSF_IhEEEEvEES6_: 23845| 1.94M| { 23846| 1.94M| return lhs == basic_json(rhs); 23847| 1.94M| } _ZN8nlohmann16json_abi_v3_12_0eqERKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEESG_: 23829| 1.94M| { 23830| 1.94M|#ifdef __GNUC__ 23831| 1.94M|#pragma GCC diagnostic push 23832| 1.94M|#pragma GCC diagnostic ignored "-Wfloat-equal" 23833| 1.94M|#endif 23834| 1.94M| JSON_IMPLEMENT_OPERATOR( ==, true, false, false) ------------------ | |23623| 1.78M| const auto lhs_type = lhs.type(); \ | |23624| 1.78M| const auto rhs_type = rhs.type(); \ | |23625| 1.78M| \ | |23626| 1.94M| if (lhs_type == rhs_type) /* NOLINT(readability/braces) */ \ | | ------------------ | | | Branch (23626:9): [True: 155k, False: 1.78M] | | ------------------ | |23627| 1.78M| { \ | |23628| 155k| switch (lhs_type) \ | |23629| 155k| { \ | |23630| 0| case value_t::array: \ | | ------------------ | | | Branch (23630:13): [True: 0, False: 155k] | | ------------------ | |23631| 0| return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array); \ | |23632| 0| \ | |23633| 0| case value_t::object: \ | | ------------------ | | | Branch (23633:13): [True: 0, False: 155k] | | ------------------ | |23634| 0| return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object); \ | |23635| 0| \ | |23636| 0| case value_t::null: \ | | ------------------ | | | Branch (23636:13): [True: 0, False: 155k] | | ------------------ | |23637| 0| return (null_result); \ | |23638| 0| \ | |23639| 155k| case value_t::string: \ | | ------------------ | | | Branch (23639:13): [True: 155k, False: 0] | | ------------------ | |23640| 155k| return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string); \ | |23641| 0| \ | |23642| 0| case value_t::boolean: \ | | ------------------ | | | Branch (23642:13): [True: 0, False: 155k] | | ------------------ | |23643| 0| return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean); \ | |23644| 0| \ | |23645| 0| case value_t::number_integer: \ | | ------------------ | | | Branch (23645:13): [True: 0, False: 155k] | | ------------------ | |23646| 0| return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer); \ | |23647| 0| \ | |23648| 0| case value_t::number_unsigned: \ | | ------------------ | | | Branch (23648:13): [True: 0, False: 155k] | | ------------------ | |23649| 0| return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned); \ | |23650| 0| \ | |23651| 0| case value_t::number_float: \ | | ------------------ | | | Branch (23651:13): [True: 0, False: 155k] | | ------------------ | |23652| 0| return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float); \ | |23653| 0| \ | |23654| 0| case value_t::binary: \ | | ------------------ | | | Branch (23654:13): [True: 0, False: 155k] | | ------------------ | |23655| 0| return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary); \ | |23656| 0| \ | |23657| 0| case value_t::discarded: \ | | ------------------ | | | Branch (23657:13): [True: 0, False: 155k] | | ------------------ | |23658| 0| default: \ | | ------------------ | | | Branch (23658:13): [True: 0, False: 155k] | | ------------------ | |23659| 0| return (unordered_result); \ | |23660| 155k| } \ | |23661| 155k| } \ | |23662| 1.78M| else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float) \ | | ------------------ | | | Branch (23662:14): [True: 29.5k, False: 1.75M] | | | Branch (23662:53): [True: 0, False: 29.5k] | | ------------------ | |23663| 1.78M| { \ | |23664| 0| return static_cast(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float; \ | |23665| 0| } \ | |23666| 1.78M| else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer) \ | | ------------------ | | | Branch (23666:14): [True: 38.3k, False: 1.74M] | | | Branch (23666:51): [True: 0, False: 38.3k] | | ------------------ | |23667| 1.78M| { \ | |23668| 0| return lhs.m_data.m_value.number_float op static_cast(rhs.m_data.m_value.number_integer); \ | |23669| 0| } \ | |23670| 1.78M| else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float) \ | | ------------------ | | | Branch (23670:14): [True: 345k, False: 1.44M] | | | Branch (23670:54): [True: 0, False: 345k] | | ------------------ | |23671| 1.78M| { \ | |23672| 0| return static_cast(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float; \ | |23673| 0| } \ | |23674| 1.78M| else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned) \ | | ------------------ | | | Branch (23674:14): [True: 38.3k, False: 1.74M] | | | Branch (23674:51): [True: 0, False: 38.3k] | | ------------------ | |23675| 1.78M| { \ | |23676| 0| return lhs.m_data.m_value.number_float op static_cast(rhs.m_data.m_value.number_unsigned); \ | |23677| 0| } \ | |23678| 1.78M| else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer) \ | | ------------------ | | | Branch (23678:14): [True: 345k, False: 1.44M] | | | Branch (23678:54): [True: 0, False: 345k] | | ------------------ | |23679| 1.78M| { \ | |23680| 0| return static_cast(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \ | |23681| 0| } \ | |23682| 1.78M| else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned) \ | | ------------------ | | | Branch (23682:14): [True: 29.5k, False: 1.75M] | | | Branch (23682:53): [True: 0, False: 29.5k] | | ------------------ | |23683| 1.78M| { \ | |23684| 0| return lhs.m_data.m_value.number_integer op static_cast(rhs.m_data.m_value.number_unsigned); \ | |23685| 0| } \ | |23686| 1.78M| else if(compares_unordered(lhs, rhs))\ | | ------------------ | | | Branch (23686:13): [True: 0, False: 1.78M] | | ------------------ | |23687| 1.78M| {\ | |23688| 0| return (unordered_result);\ | |23689| 0| }\ | |23690| 1.78M| \ | |23691| 1.78M| return (default_result); ------------------ 23835| 1.94M|#ifdef __GNUC__ 23836| 1.94M|#pragma GCC diagnostic pop 23837| 1.94M|#endif 23838| 1.94M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4typeEv: 21336| 4.29M| { 21337| 4.29M| return m_data.m_type; 21338| 4.29M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE18compares_unorderedERKSE_SG_b: 23700| 1.78M| { 23701| 1.78M| if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number()) ------------------ | Branch (23701:14): [True: 38.4k, False: 1.75M] | Branch (23701:39): [True: 0, False: 38.4k] | Branch (23701:86): [True: 0, False: 0] ------------------ 23702| 1.78M| || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number())) ------------------ | Branch (23702:21): [True: 0, False: 1.78M] | Branch (23702:46): [True: 0, False: 0] | Branch (23702:93): [True: 0, False: 0] ------------------ 23703| 0| { 23704| 0| return true; 23705| 0| } 23706| |#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 23707| | return (lhs.is_discarded() || rhs.is_discarded()) && !inverse; 23708| |#else 23709| 1.78M| static_cast(inverse); 23710| 1.78M| return lhs.is_discarded() || rhs.is_discarded(); ------------------ | Branch (23710:16): [True: 0, False: 1.78M] | Branch (23710:38): [True: 0, False: 1.78M] ------------------ 23711| 1.78M|#endif 23712| 1.78M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE15is_number_floatEv: 21392| 3.57M| { 21393| 3.57M| return m_data.m_type == value_t::number_float; 21394| 3.57M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE17is_number_integerEv: 21378| 7.53k| { 21379| 7.53k| return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned; ------------------ | Branch (21379:16): [True: 21, False: 7.51k] | Branch (21379:60): [True: 4.21k, False: 3.29k] ------------------ 21380| 7.53k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12is_discardedEv: 21427| 3.57M| { 21428| 3.57M| return m_data.m_type == value_t::discarded; 21429| 3.57M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRPKcSH_TnNS3_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SK_EE5valueEiE4typeELi0EEEOT_: 20855| 1.94M| { 20856| 1.94M| JSONSerializer::to_json(*this, std::forward(val)); 20857| 1.94M| set_parents(); 20858| 1.94M| assert_invariant(); 20859| 1.94M| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIPKcvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_S1_NS9_IhNSD_IhEEEEvEERS3_EEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSK_: 6163| 1.94M| { 6164| 1.94M| ::nlohmann::to_json(j, std::forward(val)); 6165| 1.94M| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERPKcEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSL_: 6107| 1.94M| { 6108| 1.94M| return to_json(j, std::forward(val)); 6109| 1.94M| } _ZN8nlohmann16json_abi_v3_12_06detail7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEPKcTnNS5_9enable_ifIXsr3std16is_constructibleINT_8string_tET0_EE5valueEiE4typeELi0EEEvRSK_RKSM_: 5953| 1.94M|{ 5954| 1.94M| external_constructor::construct(j, s); 5955| 1.94M|} _ZN8nlohmann16json_abi_v3_12_06detail20external_constructorILNS1_7value_tE3EE9constructINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEEPKcTnNS8_9enable_ifIXntsr3std7is_sameIT0_NT_8string_tEEE5valueEiE4typeELi0EEEvRSO_RKSN_: 5733| 1.94M| { 5734| 1.94M| j.m_data.m_value.destroy(j.m_data.m_type); 5735| 1.94M| j.m_data.m_type = value_t::string; 5736| 1.94M| j.m_data.m_value.string = j.template create(str); 5737| 1.94M| j.assert_invariant(); 5738| 1.94M| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6createISA_JRKPKcEEEPT_DpOT0_: 20396| 1.94M| { 20397| 1.94M| AllocatorType alloc; 20398| 1.94M| using AllocatorTraits = std::allocator_traits>; 20399| | 20400| 1.94M| auto deleter = [&](T * obj) 20401| 1.94M| { 20402| 1.94M| AllocatorTraits::deallocate(alloc, obj, 1); 20403| 1.94M| }; 20404| 1.94M| std::unique_ptr obj(AllocatorTraits::allocate(alloc, 1), deleter); 20405| 1.94M| AllocatorTraits::construct(alloc, obj.get(), std::forward(args)...); 20406| | JSON_ASSERT(obj != nullptr); ------------------ | | 2571| 1.94M| #define JSON_ASSERT(x) assert(x) ------------------ 20407| 1.94M| return obj.release(); 20408| 1.94M| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE5beginEv: 22819| 15.6k| { 22820| 15.6k| return cbegin(); 22821| 15.6k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE6cbeginEv: 22826| 15.6k| { 22827| 15.6k| const_iterator result(this); 22828| 15.6k| result.set_begin(); 22829| 15.6k| return result; 22830| 15.6k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEC2EPSH_: 13658| 31.3k| explicit iter_impl(pointer object) noexcept : m_object(object) 13659| 31.3k| { 13660| 31.3k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 31.3k| #define JSON_ASSERT(x) assert(x) ------------------ 13661| | 13662| 31.3k| switch (m_object->m_data.m_type) 13663| 31.3k| { 13664| 8.79k| case value_t::object: ------------------ | Branch (13664:13): [True: 8.79k, False: 22.5k] ------------------ 13665| 8.79k| { 13666| 8.79k| m_it.object_iterator = typename object_t::iterator(); 13667| 8.79k| break; 13668| 0| } 13669| | 13670| 11.5k| case value_t::array: ------------------ | Branch (13670:13): [True: 11.5k, False: 19.7k] ------------------ 13671| 11.5k| { 13672| 11.5k| m_it.array_iterator = typename array_t::iterator(); 13673| 11.5k| break; 13674| 0| } 13675| | 13676| 6| case value_t::null: ------------------ | Branch (13676:13): [True: 6, False: 31.3k] ------------------ 13677| 4.98k| case value_t::string: ------------------ | Branch (13677:13): [True: 4.97k, False: 26.3k] ------------------ 13678| 4.98k| case value_t::boolean: ------------------ | Branch (13678:13): [True: 0, False: 31.3k] ------------------ 13679| 6.80k| case value_t::number_integer: ------------------ | Branch (13679:13): [True: 1.82k, False: 29.5k] ------------------ 13680| 7.14k| case value_t::number_unsigned: ------------------ | Branch (13680:13): [True: 336, False: 30.9k] ------------------ 13681| 10.9k| case value_t::number_float: ------------------ | Branch (13681:13): [True: 3.79k, False: 27.5k] ------------------ 13682| 10.9k| case value_t::binary: ------------------ | Branch (13682:13): [True: 0, False: 31.3k] ------------------ 13683| 10.9k| case value_t::discarded: ------------------ | Branch (13683:13): [True: 0, False: 31.3k] ------------------ 13684| 10.9k| default: ------------------ | Branch (13684:13): [True: 0, False: 31.3k] ------------------ 13685| 10.9k| { 13686| 10.9k| m_it.primitive_iterator = primitive_iterator_t(); 13687| 10.9k| break; 13688| 10.9k| } 13689| 31.3k| } 13690| 31.3k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE9set_beginEv: 13756| 15.6k| { 13757| 15.6k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 15.6k| #define JSON_ASSERT(x) assert(x) ------------------ 13758| | 13759| 15.6k| switch (m_object->m_data.m_type) 13760| 15.6k| { 13761| 4.39k| case value_t::object: ------------------ | Branch (13761:13): [True: 4.39k, False: 11.2k] ------------------ 13762| 4.39k| { 13763| 4.39k| m_it.object_iterator = m_object->m_data.m_value.object->begin(); 13764| 4.39k| break; 13765| 0| } 13766| | 13767| 5.79k| case value_t::array: ------------------ | Branch (13767:13): [True: 5.79k, False: 9.86k] ------------------ 13768| 5.79k| { 13769| 5.79k| m_it.array_iterator = m_object->m_data.m_value.array->begin(); 13770| 5.79k| break; 13771| 0| } 13772| | 13773| 3| case value_t::null: ------------------ | Branch (13773:13): [True: 3, False: 15.6k] ------------------ 13774| 3| { 13775| | // set to end so begin()==end() is true: null is empty 13776| 3| m_it.primitive_iterator.set_end(); 13777| 3| break; 13778| 0| } 13779| | 13780| 2.48k| case value_t::string: ------------------ | Branch (13780:13): [True: 2.48k, False: 13.1k] ------------------ 13781| 2.48k| case value_t::boolean: ------------------ | Branch (13781:13): [True: 0, False: 15.6k] ------------------ 13782| 3.40k| case value_t::number_integer: ------------------ | Branch (13782:13): [True: 914, False: 14.7k] ------------------ 13783| 3.56k| case value_t::number_unsigned: ------------------ | Branch (13783:13): [True: 168, False: 15.4k] ------------------ 13784| 5.46k| case value_t::number_float: ------------------ | Branch (13784:13): [True: 1.89k, False: 13.7k] ------------------ 13785| 5.46k| case value_t::binary: ------------------ | Branch (13785:13): [True: 0, False: 15.6k] ------------------ 13786| 5.46k| case value_t::discarded: ------------------ | Branch (13786:13): [True: 0, False: 15.6k] ------------------ 13787| 5.46k| default: ------------------ | Branch (13787:13): [True: 0, False: 15.6k] ------------------ 13788| 5.46k| { 13789| 5.46k| m_it.primitive_iterator.set_begin(); 13790| 5.46k| break; 13791| 5.46k| } 13792| 15.6k| } 13793| 15.6k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3endEv: 22844| 15.6k| { 22845| 15.6k| return cend(); 22846| 15.6k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE4cendEv: 22851| 15.6k| { 22852| 15.6k| const_iterator result(this); 22853| 15.6k| result.set_end(); 22854| 15.6k| return result; 22855| 15.6k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE7set_endEv: 13800| 15.6k| { 13801| 15.6k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 15.6k| #define JSON_ASSERT(x) assert(x) ------------------ 13802| | 13803| 15.6k| switch (m_object->m_data.m_type) 13804| 15.6k| { 13805| 4.39k| case value_t::object: ------------------ | Branch (13805:13): [True: 4.39k, False: 11.2k] ------------------ 13806| 4.39k| { 13807| 4.39k| m_it.object_iterator = m_object->m_data.m_value.object->end(); 13808| 4.39k| break; 13809| 0| } 13810| | 13811| 5.79k| case value_t::array: ------------------ | Branch (13811:13): [True: 5.79k, False: 9.86k] ------------------ 13812| 5.79k| { 13813| 5.79k| m_it.array_iterator = m_object->m_data.m_value.array->end(); 13814| 5.79k| break; 13815| 0| } 13816| | 13817| 3| case value_t::null: ------------------ | Branch (13817:13): [True: 3, False: 15.6k] ------------------ 13818| 2.49k| case value_t::string: ------------------ | Branch (13818:13): [True: 2.48k, False: 13.1k] ------------------ 13819| 2.49k| case value_t::boolean: ------------------ | Branch (13819:13): [True: 0, False: 15.6k] ------------------ 13820| 3.40k| case value_t::number_integer: ------------------ | Branch (13820:13): [True: 914, False: 14.7k] ------------------ 13821| 3.57k| case value_t::number_unsigned: ------------------ | Branch (13821:13): [True: 168, False: 15.4k] ------------------ 13822| 5.46k| case value_t::number_float: ------------------ | Branch (13822:13): [True: 1.89k, False: 13.7k] ------------------ 13823| 5.46k| case value_t::binary: ------------------ | Branch (13823:13): [True: 0, False: 15.6k] ------------------ 13824| 5.46k| case value_t::discarded: ------------------ | Branch (13824:13): [True: 0, False: 15.6k] ------------------ 13825| 5.46k| default: ------------------ | Branch (13825:13): [True: 0, False: 15.6k] ------------------ 13826| 5.46k| { 13827| 5.46k| m_it.primitive_iterator.set_end(); 13828| 5.46k| break; 13829| 5.46k| } 13830| 15.6k| } 13831| 15.6k| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEneISI_TnNS5_9enable_ifIXoosr3std7is_sameIT_SI_EE5valuesr3std7is_sameISL_NS2_ISG_EEEE5valueEDnE4typeELDn0EEEbRKSL_: 14068| 311k| { 14069| 311k| return !operator==(other); 14070| 311k| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEeqISI_TnNS5_9enable_ifIXoosr3std7is_sameIT_SI_EE5valuesr3std7is_sameISL_NS2_ISG_EEEE5valueEDnE4typeELDn0EEEbRKSL_: 14028| 311k| { 14029| | // if objects are not the same, the comparison is undefined 14030| 311k| if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object)) ------------------ | | 1691| 311k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 0, False: 311k] | | ------------------ ------------------ 14031| 0| { 14032| 0| JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 14033| 0| } 14034| | 14035| | // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493 14036| 311k| if (m_object == nullptr) ------------------ | Branch (14036:13): [True: 0, False: 311k] ------------------ 14037| 0| { 14038| 0| return true; 14039| 0| } 14040| | 14041| 311k| switch (m_object->m_data.m_type) 14042| 311k| { 14043| 26.6k| case value_t::object: ------------------ | Branch (14043:13): [True: 26.6k, False: 284k] ------------------ 14044| 26.6k| return (m_it.object_iterator == other.m_it.object_iterator); 14045| | 14046| 273k| case value_t::array: ------------------ | Branch (14046:13): [True: 273k, False: 37.5k] ------------------ 14047| 273k| return (m_it.array_iterator == other.m_it.array_iterator); 14048| | 14049| 3| case value_t::null: ------------------ | Branch (14049:13): [True: 3, False: 311k] ------------------ 14050| 4.97k| case value_t::string: ------------------ | Branch (14050:13): [True: 4.97k, False: 306k] ------------------ 14051| 4.97k| case value_t::boolean: ------------------ | Branch (14051:13): [True: 0, False: 311k] ------------------ 14052| 6.80k| case value_t::number_integer: ------------------ | Branch (14052:13): [True: 1.82k, False: 309k] ------------------ 14053| 7.14k| case value_t::number_unsigned: ------------------ | Branch (14053:13): [True: 336, False: 311k] ------------------ 14054| 10.9k| case value_t::number_float: ------------------ | Branch (14054:13): [True: 3.79k, False: 307k] ------------------ 14055| 10.9k| case value_t::binary: ------------------ | Branch (14055:13): [True: 0, False: 311k] ------------------ 14056| 10.9k| case value_t::discarded: ------------------ | Branch (14056:13): [True: 0, False: 311k] ------------------ 14057| 10.9k| default: ------------------ | Branch (14057:13): [True: 0, False: 311k] ------------------ 14058| 10.9k| return (m_it.primitive_iterator == other.m_it.primitive_iterator); 14059| 311k| } 14060| 311k| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEdeEv: 13839| 295k| { 13840| 295k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 295k| #define JSON_ASSERT(x) assert(x) ------------------ 13841| | 13842| 295k| switch (m_object->m_data.m_type) 13843| 295k| { 13844| 22.2k| case value_t::object: ------------------ | Branch (13844:13): [True: 22.2k, False: 273k] ------------------ 13845| 22.2k| { 13846| 22.2k| JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end()); ------------------ | | 2571| 22.2k| #define JSON_ASSERT(x) assert(x) ------------------ 13847| 22.2k| return m_it.object_iterator->second; 13848| 0| } 13849| | 13850| 268k| case value_t::array: ------------------ | Branch (13850:13): [True: 268k, False: 27.6k] ------------------ 13851| 268k| { 13852| 268k| JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end()); ------------------ | | 2571| 268k| #define JSON_ASSERT(x) assert(x) ------------------ 13853| 268k| return *m_it.array_iterator; 13854| 0| } 13855| | 13856| 0| case value_t::null: ------------------ | Branch (13856:13): [True: 0, False: 295k] ------------------ 13857| 0| JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 13858| | 13859| 2.48k| case value_t::string: ------------------ | Branch (13859:13): [True: 2.48k, False: 293k] ------------------ 13860| 2.48k| case value_t::boolean: ------------------ | Branch (13860:13): [True: 0, False: 295k] ------------------ 13861| 3.40k| case value_t::number_integer: ------------------ | Branch (13861:13): [True: 914, False: 294k] ------------------ 13862| 3.56k| case value_t::number_unsigned: ------------------ | Branch (13862:13): [True: 168, False: 295k] ------------------ 13863| 5.46k| case value_t::number_float: ------------------ | Branch (13863:13): [True: 1.89k, False: 293k] ------------------ 13864| 5.46k| case value_t::binary: ------------------ | Branch (13864:13): [True: 0, False: 295k] ------------------ 13865| 5.46k| case value_t::discarded: ------------------ | Branch (13865:13): [True: 0, False: 295k] ------------------ 13866| 5.46k| default: ------------------ | Branch (13866:13): [True: 0, False: 295k] ------------------ 13867| 5.46k| { 13868| 5.46k| if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin())) ------------------ | | 1690| 5.46k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 5.46k, False: 0] | | ------------------ ------------------ 13869| 5.46k| { 13870| 5.46k| return *m_object; 13871| 5.46k| } 13872| | 13873| 0| JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 13874| 5.46k| } 13875| 295k| } 13876| 295k| } _ZN8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEppEv: 13936| 295k| { 13937| 295k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 295k| #define JSON_ASSERT(x) assert(x) ------------------ 13938| | 13939| 295k| switch (m_object->m_data.m_type) 13940| 295k| { 13941| 22.2k| case value_t::object: ------------------ | Branch (13941:13): [True: 22.2k, False: 273k] ------------------ 13942| 22.2k| { 13943| 22.2k| std::advance(m_it.object_iterator, 1); 13944| 22.2k| break; 13945| 0| } 13946| | 13947| 268k| case value_t::array: ------------------ | Branch (13947:13): [True: 268k, False: 27.6k] ------------------ 13948| 268k| { 13949| 268k| std::advance(m_it.array_iterator, 1); 13950| 268k| break; 13951| 0| } 13952| | 13953| 0| case value_t::null: ------------------ | Branch (13953:13): [True: 0, False: 295k] ------------------ 13954| 2.48k| case value_t::string: ------------------ | Branch (13954:13): [True: 2.48k, False: 293k] ------------------ 13955| 2.48k| case value_t::boolean: ------------------ | Branch (13955:13): [True: 0, False: 295k] ------------------ 13956| 3.40k| case value_t::number_integer: ------------------ | Branch (13956:13): [True: 914, False: 294k] ------------------ 13957| 3.56k| case value_t::number_unsigned: ------------------ | Branch (13957:13): [True: 168, False: 295k] ------------------ 13958| 5.46k| case value_t::number_float: ------------------ | Branch (13958:13): [True: 1.89k, False: 293k] ------------------ 13959| 5.46k| case value_t::binary: ------------------ | Branch (13959:13): [True: 0, False: 295k] ------------------ 13960| 5.46k| case value_t::discarded: ------------------ | Branch (13960:13): [True: 0, False: 295k] ------------------ 13961| 5.46k| default: ------------------ | Branch (13961:13): [True: 0, False: 295k] ------------------ 13962| 5.46k| { 13963| 5.46k| ++m_it.primitive_iterator; 13964| 5.46k| break; 13965| 5.46k| } 13966| 295k| } 13967| | 13968| 295k| return *this; 13969| 295k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA6_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 2.65M| { 22781| 2.65M| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 413k, False: 2.24M] | Branch (22781:31): [True: 28.7k, False: 384k] ------------------ 22782| 2.65M| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA6_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 413k| { 20019| 1.22M| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 836k, False: 384k] ------------------ 20020| 836k| { 20021| 836k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 28.7k, False: 807k] ------------------ 20022| 28.7k| { 20023| 28.7k| return it; 20024| 28.7k| } 20025| 836k| } 20026| 384k| return Container::end(); 20027| 413k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA8_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 481k| { 22781| 481k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 35.6k, False: 445k] | Branch (22781:31): [True: 13.9k, False: 21.6k] ------------------ 22782| 481k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA8_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 35.6k| { 20019| 83.6k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 61.9k, False: 21.6k] ------------------ 20020| 61.9k| { 20021| 61.9k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 13.9k, False: 48.0k] ------------------ 20022| 13.9k| { 20023| 13.9k| return it; 20024| 13.9k| } 20025| 61.9k| } 20026| 21.6k| return Container::end(); 20027| 35.6k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA10_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 3.13k| { 22781| 3.13k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 3.13k, False: 0] | Branch (22781:31): [True: 669, False: 2.46k] ------------------ 22782| 3.13k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA10_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 3.13k| { 20019| 8.72k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 6.26k, False: 2.46k] ------------------ 20020| 6.26k| { 20021| 6.26k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 669, False: 5.59k] ------------------ 20022| 669| { 20023| 669| return it; 20024| 669| } 20025| 6.26k| } 20026| 2.46k| return Container::end(); 20027| 3.13k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA7_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 603k| { 22781| 603k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 157k, False: 445k] | Branch (22781:31): [True: 1.19k, False: 156k] ------------------ 22782| 603k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA7_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 157k| { 20019| 448k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 291k, False: 156k] ------------------ 20020| 291k| { 20021| 291k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 1.19k, False: 290k] ------------------ 20022| 1.19k| { 20023| 1.19k| return it; 20024| 1.19k| } 20025| 291k| } 20026| 156k| return Container::end(); 20027| 157k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getINS4_ISE_NS8_ISE_EEEESH_EEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 1.24k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 1.24k| static_assert(!std::is_reference::value, 21793| 1.24k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 1.24k| return get_impl(detail::priority_tag<4> {}); 21795| 1.24k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implINS4_ISE_NS8_ISE_EEEETnNS3_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SJ_EE5valueEiE4typeELi0EEESJ_NS0_6detail12priority_tagILj0EEE: 21649| 1.24k| { 21650| 1.24k| auto ret = ValueType(); 21651| 1.24k| JSONSerializer::from_json(*this, ret); 21652| 1.24k| return ret; 21653| 1.24k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerINSt3__16vectorINS0_10basic_jsonINS0_11ordered_mapES3_NS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdS9_S1_NS3_IhNS9_IhEEEEvEENS9_ISE_EEEEvE9from_jsonIRKSE_SG_EEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSL_RT0_: 6143| 1.24k| { 6144| 1.24k| ::nlohmann::from_json(std::forward(j), val); 6145| 1.24k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERNS7_ISH_NSB_ISH_EEEEEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSL_: 5342| 1.24k| { 5343| 1.24k| return from_json(j, std::forward(val)); 5344| 1.24k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEENS6_ISG_NSA_ISG_EEEETnNS5_9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISK_SL_EE5valuentsr28is_constructible_string_typeISK_SL_EE5valuentsr3std7is_sameISL_NSK_8binary_tEEE5valuentsr13is_basic_jsonISL_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSL_10value_typeEEEcvv_EERKSK_RSL_: 5121| 1.24k|{ 5122| 1.24k| if (JSON_HEDLEY_UNLIKELY(!j.is_array())) ------------------ | | 1691| 1.24k|# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) | | ------------------ | | | Branch (1691:57): [True: 39, False: 1.20k] | | ------------------ ------------------ 5123| 39| { 5124| 39| JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j)); ------------------ | | 2536| 39| #define JSON_THROW(exception) throw exception ------------------ 5125| 39| } 5126| | 5127| 1.20k| from_json_array_impl(j, arr, priority_tag<3> {}); 5128| 1.20k|} _ZN8nlohmann16json_abi_v3_12_06detail6concatINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA28_KcPSA_EEET_DpOT0_: 4477| 39|{ 4478| 39| OutStringType str; 4479| 39| str.reserve(concat_length(args...)); 4480| 39| concat_into(str, std::forward(args)...); 4481| 39| return str; 4482| 39|} _ZN8nlohmann16json_abi_v3_12_06detail11concat_intoINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERA28_KcJPSA_ETnNS3_9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_: 4440| 39|{ 4441| 39| out.append(std::forward(arg)); 4442| 39| concat_into(out, std::forward(rest)...); 4443| 39|} _ZN8nlohmann16json_abi_v3_12_06detail20from_json_array_implINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_7array_tENS1_12priority_tagILj3EEE: 5049| 1.20k|{ 5050| 1.20k| arr = *j.template get_ptr(); 5051| 1.20k|} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKNS4_ISE_NS8_ISE_EEEETnNS3_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS3_14remove_pointerISL_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISL_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISL_EEEEv: 21598| 1.20k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 1.20k| return get_impl_ptr(static_cast(nullptr)); 21601| 1.20k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKNS4_ISE_NS8_ISE_EEEE: 21476| 1.20k| { 21477| 1.20k| return is_array() ? m_data.m_value.array : nullptr; ------------------ | Branch (21477:16): [True: 1.20k, False: 0] ------------------ 21478| 1.20k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA11_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 523k| { 22781| 523k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 48.9k, False: 474k] | Branch (22781:31): [True: 9.88k, False: 39.0k] ------------------ 22782| 523k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA11_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 48.9k| { 20019| 116k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 77.7k, False: 39.0k] ------------------ 20020| 77.7k| { 20021| 77.7k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 9.88k, False: 67.9k] ------------------ 20022| 9.88k| { 20023| 9.88k| return it; 20024| 9.88k| } 20025| 77.7k| } 20026| 39.0k| return Container::end(); 20027| 48.9k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA21_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 485k| { 22781| 485k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 39.2k, False: 445k] | Branch (22781:31): [True: 1.33k, False: 37.9k] ------------------ 22782| 485k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA21_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 39.2k| { 20019| 103k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 65.2k, False: 37.9k] ------------------ 20020| 65.2k| { 20021| 65.2k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 1.33k, False: 63.9k] ------------------ 20022| 1.33k| { 20023| 1.33k| return it; 20024| 1.33k| } 20025| 65.2k| } 20026| 37.9k| return Container::end(); 20027| 39.2k| } _ZN8nlohmann16json_abi_v3_12_0neIbTnNSt3__19enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapENS2_6vectorENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEblmdSD_NS0_14adl_serializerENS9_IhNSD_IhEEEEvEES4_: 23874| 664| { 23875| 664| return lhs != basic_json(rhs); 23876| 664| } _ZN8nlohmann16json_abi_v3_12_0neERKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEESG_: 23861| 664| { 23862| 664| if (compares_unordered(lhs, rhs, true)) ------------------ | Branch (23862:13): [True: 0, False: 664] ------------------ 23863| 0| { 23864| 0| return false; 23865| 0| } 23866| 664| return !(lhs == rhs); 23867| 664| } _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRbbTnNS3_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SI_EE5valueEiE4typeELi0EEEOT_: 20855| 664| { 20856| 664| JSONSerializer::to_json(*this, std::forward(val)); 20857| 664| set_parents(); 20858| 664| assert_invariant(); 20859| 664| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIbvE7to_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEERbEEDTcmclL_ZNS0_7to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_: 6163| 664| { 6164| 664| ::nlohmann::to_json(j, std::forward(val)); 6165| 664| } _ZNK8nlohmann16json_abi_v3_12_06detail10to_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERbEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSJ_: 6107| 664| { 6108| 664| return to_json(j, std::forward(val)); 6109| 664| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA9_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 19.5k| { 22781| 19.5k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 19.5k, False: 0] | Branch (22781:31): [True: 7.19k, False: 12.3k] ------------------ 22782| 19.5k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA9_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 19.5k| { 20019| 60.0k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 47.7k, False: 12.3k] ------------------ 20020| 47.7k| { 20021| 47.7k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 7.19k, False: 40.5k] ------------------ 20022| 7.19k| { 20023| 7.19k| return it; 20024| 7.19k| } 20025| 47.7k| } 20026| 12.3k| return Container::end(); 20027| 19.5k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE5itemsEv: 22932| 6.12k| { 22933| 6.12k| return iteration_proxy(*this); 22934| 6.12k| } _ZN8nlohmann16json_abi_v3_12_06detail15iteration_proxyINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEC2ERSI_: 5593| 6.12k| : container(&cont) {} _ZNK8nlohmann16json_abi_v3_12_06detail15iteration_proxyINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE5beginEv: 5603| 6.12k| { 5604| 6.12k| return iteration_proxy_value(container->begin()); 5605| 6.12k| } _ZN8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEC2ESJ_m: 5488| 12.2k| : anchor(std::move(it)) 5489| 12.2k| , array_index(array_index_) 5490| 12.2k| {} _ZNK8nlohmann16json_abi_v3_12_06detail15iteration_proxyINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE3endEv: 5609| 6.12k| { 5610| 6.12k| return iteration_proxy_value(container->end()); 5611| 6.12k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEneERKSK_: 5534| 223k| { 5535| 223k| return anchor != o.anchor; 5536| 223k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEdeEv: 5505| 217k| { 5506| 217k| return *this; 5507| 217k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE3keyEv: 5540| 408k| { 5541| 408k| JSON_ASSERT(anchor.m_object != nullptr); ------------------ | | 2571| 408k| #define JSON_ASSERT(x) assert(x) ------------------ 5542| | 5543| 408k| switch (anchor.m_object->type()) 5544| 408k| { 5545| | // use integer array index as key 5546| 378k| case value_t::array: ------------------ | Branch (5546:13): [True: 378k, False: 29.8k] ------------------ 5547| 378k| { 5548| 378k| if (array_index != array_index_last) ------------------ | Branch (5548:21): [True: 193k, False: 184k] ------------------ 5549| 193k| { 5550| 193k| int_to_string( array_index_str, array_index ); 5551| 193k| array_index_last = array_index; 5552| 193k| } 5553| 378k| return array_index_str; 5554| 0| } 5555| | 5556| | // use key from the object 5557| 28.1k| case value_t::object: ------------------ | Branch (5557:13): [True: 28.1k, False: 380k] ------------------ 5558| 28.1k| return anchor.key(); 5559| | 5560| | // use an empty key for all primitive types 5561| 0| case value_t::null: ------------------ | Branch (5561:13): [True: 0, False: 408k] ------------------ 5562| 786| case value_t::string: ------------------ | Branch (5562:13): [True: 786, False: 407k] ------------------ 5563| 786| case value_t::boolean: ------------------ | Branch (5563:13): [True: 0, False: 408k] ------------------ 5564| 1.59k| case value_t::number_integer: ------------------ | Branch (5564:13): [True: 806, False: 407k] ------------------ 5565| 1.68k| case value_t::number_unsigned: ------------------ | Branch (5565:13): [True: 91, False: 408k] ------------------ 5566| 1.68k| case value_t::number_float: ------------------ | Branch (5566:13): [True: 0, False: 408k] ------------------ 5567| 1.68k| case value_t::binary: ------------------ | Branch (5567:13): [True: 0, False: 408k] ------------------ 5568| 1.68k| case value_t::discarded: ------------------ | Branch (5568:13): [True: 0, False: 408k] ------------------ 5569| 1.68k| default: ------------------ | Branch (5569:13): [True: 0, False: 408k] ------------------ 5570| 1.68k| return empty_str; 5571| 408k| } 5572| 408k| } _ZN8nlohmann16json_abi_v3_12_06detail13int_to_stringINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRT_m: 5437| 193k|{ 5438| | // For ADL 5439| 193k| using std::to_string; 5440| 193k| target = to_string(value); 5441| 193k|} _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE3keyEv: 14290| 28.1k| { 14291| 28.1k| JSON_ASSERT(m_object != nullptr); ------------------ | | 2571| 28.1k| #define JSON_ASSERT(x) assert(x) ------------------ 14292| | 14293| 28.1k| if (JSON_HEDLEY_LIKELY(m_object->is_object())) ------------------ | | 1690| 28.1k|# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) | | ------------------ | | | Branch (1690:57): [True: 28.1k, False: 0] | | ------------------ ------------------ 14294| 28.1k| { 14295| 28.1k| return m_it.object_iterator->first; 14296| 28.1k| } 14297| | 14298| 0| JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object)); ------------------ | | 2536| 0| #define JSON_THROW(exception) throw exception ------------------ 14299| 28.1k| } _ZNK8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEE5valueEv: 5576| 217k| { 5577| 217k| return anchor.value(); 5578| 217k| } _ZNK8nlohmann16json_abi_v3_12_06detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEE5valueEv: 14306| 217k| { 14307| 217k| return operator*(); 14308| 217k| } _ZN8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEEppEv: 5511| 217k| { 5512| 217k| ++anchor; 5513| 217k| ++array_index; 5514| | 5515| 217k| return *this; 5516| 217k| } _ZN8nlohmann16json_abi_v3_12_06detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEEEEED2Ev: 5501| 12.2k| ~iteration_proxy_value() = default; _ZN8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEC2IRKSA_SA_TnNS3_9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISE_SJ_EE5valueEiE4typeELi0EEEOT_: 20855| 217k| { 20856| 217k| JSONSerializer::to_json(*this, std::forward(val)); 20857| 217k| set_parents(); 20858| 217k| assert_invariant(); 20859| 217k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE10is_booleanEv: 21364| 6.23k| { 21365| 6.23k| return m_data.m_type == value_t::boolean; 21366| 6.23k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA12_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 467k| { 22781| 467k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 22.0k, False: 445k] | Branch (22781:31): [True: 649, False: 21.4k] ------------------ 22782| 467k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA12_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 22.0k| { 20019| 48.5k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 27.1k, False: 21.4k] ------------------ 20020| 27.1k| { 20021| 27.1k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 649, False: 26.4k] ------------------ 20022| 649| { 20023| 649| return it; 20024| 649| } 20025| 27.1k| } 20026| 21.4k| return Container::end(); 20027| 22.0k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getIiiEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 6.07k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 6.07k| static_assert(!std::is_reference::value, 21793| 6.07k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 6.07k| return get_impl(detail::priority_tag<4> {}); 21795| 6.07k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implIiTnNS3_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 6.07k| { 21650| 6.07k| auto ret = ValueType(); 21651| 6.07k| JSONSerializer::from_json(*this, ret); 21652| 6.07k| return ret; 21653| 6.07k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIivE9from_jsonIRKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEEiEEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 6.07k| { 6144| 6.07k| ::nlohmann::from_json(std::forward(j), val); 6145| 6.07k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERiEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 6.07k| { 5343| 6.07k| return from_json(j, std::forward(val)); 5344| 6.07k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEiTnNS5_9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISI_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISI_NSJ_16number_integer_tEEE5valuentsr3std7is_sameISI_NSJ_14number_float_tEEE5valuentsr3std7is_sameISI_NSJ_9boolean_tEEE5valueEiE4typeELi0EEEvRKSJ_RSI_: 5195| 6.07k|{ 5196| 6.07k| switch (static_cast(j)) 5197| 6.07k| { 5198| 5.27k| case value_t::number_unsigned: ------------------ | Branch (5198:9): [True: 5.27k, False: 800] ------------------ 5199| 5.27k| { 5200| 5.27k| val = static_cast(*j.template get_ptr()); 5201| 5.27k| break; 5202| 0| } 5203| 631| case value_t::number_integer: ------------------ | Branch (5203:9): [True: 631, False: 5.44k] ------------------ 5204| 631| { 5205| 631| val = static_cast(*j.template get_ptr()); 5206| 631| break; 5207| 0| } 5208| 159| case value_t::number_float: ------------------ | Branch (5208:9): [True: 159, False: 5.92k] ------------------ 5209| 159| { 5210| 159| val = static_cast(*j.template get_ptr()); 5211| 159| break; 5212| 0| } 5213| 0| case value_t::boolean: ------------------ | Branch (5213:9): [True: 0, False: 6.07k] ------------------ 5214| 0| { 5215| 0| val = static_cast(*j.template get_ptr()); 5216| 0| break; 5217| 0| } 5218| | 5219| 0| case value_t::null: ------------------ | Branch (5219:9): [True: 0, False: 6.07k] ------------------ 5220| 0| case value_t::object: ------------------ | Branch (5220:9): [True: 0, False: 6.07k] ------------------ 5221| 0| case value_t::array: ------------------ | Branch (5221:9): [True: 0, False: 6.07k] ------------------ 5222| 10| case value_t::string: ------------------ | Branch (5222:9): [True: 10, False: 6.06k] ------------------ 5223| 10| case value_t::binary: ------------------ | Branch (5223:9): [True: 0, False: 6.07k] ------------------ 5224| 10| case value_t::discarded: ------------------ | Branch (5224:9): [True: 0, False: 6.07k] ------------------ 5225| 10| default: ------------------ | Branch (5225:9): [True: 0, False: 6.07k] ------------------ 5226| 10| JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); ------------------ | | 2536| 10| #define JSON_THROW(exception) throw exception ------------------ 5227| 6.07k| } 5228| 6.07k|} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvEcvNS0_6detail7value_tEEv: 21434| 10.7k| { 21435| 10.7k| return m_data.m_type; 21436| 10.7k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKmTnNS3_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS3_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 8.32k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 8.32k| return get_impl_ptr(static_cast(nullptr)); 21601| 8.32k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKm: 21524| 8.32k| { 21525| 8.32k| return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr; ------------------ | Branch (21525:16): [True: 8.32k, False: 0] ------------------ 21526| 8.32k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE18is_number_unsignedEv: 21385| 8.32k| { 21386| 8.32k| return m_data.m_type == value_t::number_unsigned; 21387| 8.32k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKlTnNS3_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS3_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 2.09k| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 2.09k| return get_impl_ptr(static_cast(nullptr)); 21601| 2.09k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKl: 21512| 2.09k| { 21513| 2.09k| return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr; ------------------ | Branch (21513:16): [True: 2.09k, False: 0] ------------------ 21514| 2.09k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE7get_ptrIPKdTnNS3_9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINS3_14remove_pointerISJ_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISJ_EEEEv: 21598| 312| { 21599| | // delegate the call to get_impl_ptr<>() const 21600| 312| return get_impl_ptr(static_cast(nullptr)); 21601| 312| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE12get_impl_ptrEPKd: 21536| 312| { 21537| 312| return is_number_float() ? &m_data.m_value.number_float : nullptr; ------------------ | Branch (21537:16): [True: 312, False: 0] ------------------ 21538| 312| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8containsIRA17_KcTnNS3_9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISE_T_EE5valueEiE4typeELi0EEEbOSK_: 22780| 5.02k| { 22781| 5.02k| return is_object() && m_data.m_value.object->find(std::forward(key)) != m_data.m_value.object->end(); ------------------ | Branch (22781:16): [True: 5.02k, False: 0] | Branch (22781:31): [True: 265, False: 4.75k] ------------------ 22782| 5.02k| } _ZN8nlohmann16json_abi_v3_12_011ordered_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_10basic_jsonIS1_NS2_6vectorES8_blmdS6_NS0_14adl_serializerENSA_IhNS6_IhEEEEvEENS2_4lessIvEENS6_INS2_4pairIKS8_SE_EEEEE4findIRA17_KcTnNS2_9enable_ifIXsr6detail21is_usable_as_key_typeINS2_8equal_toIvEES8_T_EE5valueEiE4typeELi0EEENS2_11__wrap_iterIPSJ_EEOST_: 20018| 5.02k| { 20019| 20.3k| for (auto it = this->begin(); it != this->end(); ++it) ------------------ | Branch (20019:39): [True: 15.5k, False: 4.75k] ------------------ 20020| 15.5k| { 20021| 15.5k| if (m_compare(it->first, key)) ------------------ | Branch (20021:17): [True: 265, False: 15.3k] ------------------ 20022| 265| { 20023| 265| return it; 20024| 265| } 20025| 15.5k| } 20026| 4.75k| return Container::end(); 20027| 5.02k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE3getIllEEDTcldtclL_ZNS3_7declvalB8ne220000IRKSE_EEDTclsr3stdE9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv: 21788| 4.66k| { 21789| | // we cannot static_assert on ValueTypeCV being non-const, because 21790| | // there is support for get(), which is why we 21791| | // still need the uncvref 21792| 4.66k| static_assert(!std::is_reference::value, 21793| 4.66k| "get() cannot be used with reference types, you might want to use get_ref()"); 21794| 4.66k| return get_impl(detail::priority_tag<4> {}); 21795| 4.66k| } _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE8get_implIlTnNS3_9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISE_SH_EE5valueEiE4typeELi0EEESH_NS0_6detail12priority_tagILj0EEE: 21649| 4.66k| { 21650| 4.66k| auto ret = ValueType(); 21651| 4.66k| JSONSerializer::from_json(*this, ret); 21652| 4.66k| return ret; 21653| 4.66k| } _ZN8nlohmann16json_abi_v3_12_014adl_serializerIlvE9from_jsonIRKNS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_S1_NS7_IhNSB_IhEEEEvEElEEDTcmclL_ZNS0_9from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSJ_RT0_: 6143| 4.66k| { 6144| 4.66k| ::nlohmann::from_json(std::forward(j), val); 6145| 4.66k| } _ZNK8nlohmann16json_abi_v3_12_06detail12from_json_fnclINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEblmdSB_NS0_14adl_serializerENS7_IhNSB_IhEEEEvEERlEEDTcl9from_jsonfp_clsr3stdE7forwardIT0_Efp0_EEERKT_OSJ_: 5342| 4.66k| { 5343| 4.66k| return from_json(j, std::forward(val)); 5344| 4.66k| } _ZN8nlohmann16json_abi_v3_12_06detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEEEEvRKT_RNSH_16number_integer_tE: 4940| 4.66k|{ 4941| 4.66k| get_arithmetic_value(j, val); 4942| 4.66k|} _ZN8nlohmann16json_abi_v3_12_06detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapENSt3__16vectorENS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEblmdSA_NS0_14adl_serializerENS6_IhNSA_IhEEEEvEElTnNS5_9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISI_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSJ_RSI_: 4858| 4.66k|{ 4859| 4.66k| switch (static_cast(j)) 4860| 4.66k| { 4861| 3.04k| case value_t::number_unsigned: ------------------ | Branch (4861:9): [True: 3.04k, False: 1.62k] ------------------ 4862| 3.04k| { 4863| 3.04k| val = static_cast(*j.template get_ptr()); 4864| 3.04k| break; 4865| 0| } 4866| 1.46k| case value_t::number_integer: ------------------ | Branch (4866:9): [True: 1.46k, False: 3.19k] ------------------ 4867| 1.46k| { 4868| 1.46k| val = static_cast(*j.template get_ptr()); 4869| 1.46k| break; 4870| 0| } 4871| 153| case value_t::number_float: ------------------ | Branch (4871:9): [True: 153, False: 4.51k] ------------------ 4872| 153| { 4873| 153| val = static_cast(*j.template get_ptr()); 4874| 153| break; 4875| 0| } 4876| | 4877| 0| case value_t::null: ------------------ | Branch (4877:9): [True: 0, False: 4.66k] ------------------ 4878| 0| case value_t::object: ------------------ | Branch (4878:9): [True: 0, False: 4.66k] ------------------ 4879| 0| case value_t::array: ------------------ | Branch (4879:9): [True: 0, False: 4.66k] ------------------ 4880| 1| case value_t::string: ------------------ | Branch (4880:9): [True: 1, False: 4.66k] ------------------ 4881| 1| case value_t::boolean: ------------------ | Branch (4881:9): [True: 0, False: 4.66k] ------------------ 4882| 1| case value_t::binary: ------------------ | Branch (4882:9): [True: 0, False: 4.66k] ------------------ 4883| 1| case value_t::discarded: ------------------ | Branch (4883:9): [True: 0, False: 4.66k] ------------------ 4884| 1| default: ------------------ | Branch (4884:9): [True: 0, False: 4.66k] ------------------ 4885| 1| JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j)); ------------------ | | 2536| 1| #define JSON_THROW(exception) throw exception ------------------ 4886| 4.66k| } 4887| 4.66k|} _ZNK8nlohmann16json_abi_v3_12_010basic_jsonINS0_11ordered_mapENSt3__16vectorENS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEblmdS8_NS0_14adl_serializerENS4_IhNS8_IhEEEEvE5emptyEv: 22948| 514k| { 22949| 514k| switch (m_data.m_type) 22950| 514k| { 22951| 5.27k| case value_t::null: ------------------ | Branch (22951:13): [True: 5.27k, False: 509k] ------------------ 22952| 5.27k| { 22953| | // null values are empty 22954| 5.27k| return true; 22955| 0| } 22956| | 22957| 6.78k| case value_t::array: ------------------ | Branch (22957:13): [True: 6.78k, False: 507k] ------------------ 22958| 6.78k| { 22959| | // delegate call to array_t::empty() 22960| 6.78k| return m_data.m_value.array->empty(); 22961| 0| } 22962| | 22963| 68.5k| case value_t::object: ------------------ | Branch (22963:13): [True: 68.5k, False: 445k] ------------------ 22964| 68.5k| { 22965| | // delegate call to object_t::empty() 22966| 68.5k| return m_data.m_value.object->empty(); 22967| 0| } 22968| | 22969| 2.12k| case value_t::string: ------------------ | Branch (22969:13): [True: 2.12k, False: 512k] ------------------ 22970| 2.12k| case value_t::boolean: ------------------ | Branch (22970:13): [True: 3, False: 514k] ------------------ 22971| 33.9k| case value_t::number_integer: ------------------ | Branch (22971:13): [True: 31.7k, False: 482k] ------------------ 22972| 404k| case value_t::number_unsigned: ------------------ | Branch (22972:13): [True: 371k, False: 143k] ------------------ 22973| 433k| case value_t::number_float: ------------------ | Branch (22973:13): [True: 28.8k, False: 485k] ------------------ 22974| 433k| case value_t::binary: ------------------ | Branch (22974:13): [True: 0, False: 514k] ------------------ 22975| 433k| case value_t::discarded: ------------------ | Branch (22975:13): [True: 0, False: 514k] ------------------ 22976| 433k| default: ------------------ | Branch (22976:13): [True: 0, False: 514k] ------------------ 22977| 433k| { 22978| | // all other types are nonempty 22979| 433k| return false; 22980| 433k| } 22981| 514k| } 22982| 514k| }